diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index f47289d7fde0953c0e2c2af093955c5487dabfe7..7375c2c184e7f0affcba16faa363e39cdabff552 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -2,6 +2,7 @@
 
 default:
    image: gmulas/np-tmcode
+   #image: debian:trixie
 
 # Switch from branch pipelines to merge request pipelines when a merge request is created
 workflow:
diff --git a/README.md b/README.md
index c92092892c2af54f6c7176a50a137d0044f60883..566a46a4d55ebb784d33acc3dc89ef54ea5815c6 100644
--- a/README.md
+++ b/README.md
@@ -19,7 +19,7 @@ Supported by Italian Research Center on High Performance Computing Big Data and
 
 # License
 
-   Copyright (C) 2024   INAF - Osservatorio Astronomico di Cagliari
+   Copyright (C) 2025   INAF - Osservatorio Astronomico di Cagliari
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/build/README.md b/build/README.md
index 4f940ee95b2ce81659c61b27ab7072494cfeea61..1f8637e27300af8b35d78199661e1ca235b52803 100644
--- a/build/README.md
+++ b/build/README.md
@@ -115,7 +115,7 @@ where the arguments must be valid paths to binary transition matrix files saved
 
 # License
 
-   Copyright (C) 2024   INAF - Osservatorio Astronomico di Cagliari
+   Copyright (C) 2025   INAF - Osservatorio Astronomico di Cagliari
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/containers/docker/Dockerfile b/containers/docker/Dockerfile
index cd921b412d7f5bf796f14fa952a54fa5990249b5..436d0e1266c431456c5ee2b61810c1495a54c0c8 100644
--- a/containers/docker/Dockerfile
+++ b/containers/docker/Dockerfile
@@ -57,19 +57,19 @@ ADD doc /root/np-tmcode/doc
 ADD build /root/np-tmcode/build
 ADD test_data /root/np-tmcode/test_data
 #RUN cd np-tmcode/src && BUILDDIR=../../build BUILDDIR_NPTM=../../build/libnptm LIBNPTM=../../build/libnptm/libnptm.a USE_ILP64=1 USE_LAPACK=1 USE_MAGMA=1 USE_OPENMP=1 USE_MPI=1 CXX=mpicxx FC=gfortran make wipe && BUILDDIR=../../build BUILDDIR_NPTM=../../build/libnptm LIBNPTM=../../build/libnptm/libnptm.a USE_ILP64=1 USE_LAPACK=1 USE_MAGMA=1 USE_OPENMP=1 USE_MPI=1 CXX=mpicxx FC=gfortran make -j && mv ../build/cluster/np_cluster ../build/cluster/np_cluster_magma_mpi
-RUN cd np-tmcode/build && CXX=mpicxx FC=gfortran ./configure --enable-openmp --with-lapack --with-magma --enable-refinement --without-cublas && make clean && make -j && mv cluster/np_cluster cluster/np_cluster_magma_mpi && mv sphere/np_sphere sphere/np_sphere_magma_mpi && mv inclusion/np_inclusion inclusion/np_inclusion_magma_mpi && mv trapping/np_trapping trapping/np_trapping_magma_mpi
+RUN cd np-tmcode/build && CXX=mpicxx FC=gfortran ./configure --enable-openmp --with-lapack --with-magma --enable-refinement --without-cublas && make clean && make -j && mv cluster/np_cluster cluster/np_cluster_magma_mpi && mv inclusion/np_inclusion inclusion/np_inclusion_magma_mpi 
 #RUN cd np-tmcode/src && BUILDDIR=../../build BUILDDIR_NPTM=../../build/libnptm LIBNPTM=../../build/libnptm/libnptm.a USE_ILP64=1 USE_LAPACK=1 USE_MAGMA=1 USE_OPENMP=1 CXX=g++ FC=gfortran make wipe && BUILDDIR=../../build BUILDDIR_NPTM=../../build/libnptm LIBNPTM=../../build/libnptm/libnptm.a USE_ILP64=1 USE_LAPACK=1 USE_MAGMA=1 USE_OPENMP=1 CXX=g++ FC=gfortran make -j && mv ../build/cluster/np_cluster ../build/cluster/np_cluster_magma_serial
-RUN cd np-tmcode/build && CXX=g++ FC=gfortran ./configure --enable-openmp --with-lapack --with-magma --enable-refinement --without-cublas && make clean && make -j && mv cluster/np_cluster cluster/np_cluster_magma_serial && mv sphere/np_sphere sphere/np_sphere_magma_serial && mv inclusion/np_inclusion inclusion/np_inclusion_magma_serial && mv trapping/np_trapping trapping/np_trapping_magma_serial
-RUN cd np-tmcode/build && CXX=mpicxx FC=gfortran ./configure --enable-openmp --with-lapack --without-magma --enable-refinement --with-cublas && make clean && make -j && mv cluster/np_cluster cluster/np_cluster_cublas_mpi && mv sphere/np_sphere sphere/np_sphere_cublas_mpi && mv inclusion/np_inclusion inclusion/np_inclusion_cublas_mpi && mv trapping/np_trapping trapping/np_trapping_cublas_mpi
-RUN cd np-tmcode/build && CXX=g++ FC=gfortran ./configure --enable-openmp --with-lapack --without-magma --enable-refinement --with-cublas && make clean && make -j && mv cluster/np_cluster cluster/np_cluster_cublas_serial && mv sphere/np_sphere sphere/np_sphere_cublas_serial && mv inclusion/np_inclusion inclusion/np_inclusion_cublas_serial && mv trapping/np_trapping trapping/np_trapping_cublas_serial
+RUN cd np-tmcode/build && CXX=g++ FC=gfortran ./configure --enable-openmp --with-lapack --with-magma --enable-refinement --without-cublas && make clean && make -j && mv cluster/np_cluster cluster/np_cluster_magma_serial && mv inclusion/np_inclusion inclusion/np_inclusion_magma_serial 
+RUN cd np-tmcode/build && CXX=mpicxx FC=gfortran ./configure --enable-openmp --with-lapack --without-magma --enable-refinement --with-cublas && make clean && make -j && mv cluster/np_cluster cluster/np_cluster_cublas_mpi && mv inclusion/np_inclusion inclusion/np_inclusion_cublas_mpi 
+RUN cd np-tmcode/build && CXX=g++ FC=gfortran ./configure --enable-openmp --with-lapack --without-magma --enable-refinement --with-cublas && make clean && make -j && mv cluster/np_cluster cluster/np_cluster_cublas_serial && mv inclusion/np_inclusion inclusion/np_inclusion_cublas_serial 
 #RUN cd np-tmcode/src && BUILDDIR=../../build BUILDDIR_NPTM=../../build/libnptm LIBNPTM=../../build/libnptm/libnptm.a USE_ILP64=1 USE_LAPACK=1 USE_OPENMP=1 USE_MPI=1 CXX=mpicxx FC=gfortran make wipe && BUILDDIR=../../build BUILDDIR_NPTM=../../build/libnptm LIBNPTM=../../build/libnptm/libnptm.a USE_ILP64=1 USE_LAPACK=1 USE_OPENMP=1 USE_MPI=1 CXX=mpicxx FC=gfortran make -j && mv ../build/cluster/np_cluster ../build/cluster/np_cluster_lapack_mpi && cd ../build/cluster && ln -s np_cluster_lapack_mpi np_cluster
-RUN cd np-tmcode/build && CXX=mpicxx FC=gfortran ./configure --enable-openmp --with-lapack --without-magma --enable-refinement --without-cublas && make clean && make -j && mv cluster/np_cluster cluster/np_cluster_lapack_mpi && mv sphere/np_sphere sphere/np_sphere_lapack_mpi && mv inclusion/np_inclusion inclusion/np_inclusion_lapack_mpi && mv trapping/np_trapping trapping/np_trapping_lapack_mpi && cd cluster && ln -s np_cluster_lapack_mpi np_cluster && cd ../sphere && ln -s np_sphere_lapack_mpi np_sphere && cd ../inclusion && ln -s np_inclusion_lapack_mpi np_inclusion && cd ../trapping && ln -s np_trapping_lapack_mpi np_trapping   
+RUN cd np-tmcode/build && CXX=mpicxx FC=gfortran ./configure --enable-openmp --with-lapack --without-magma --enable-refinement --without-cublas && make clean && make -j && mv cluster/np_cluster cluster/np_cluster_lapack_mpi && mv inclusion/np_inclusion inclusion/np_inclusion_lapack_mpi && mv trapping/np_trapping trapping/np_trapping_lapack_mpi && cd cluster && ln -s np_cluster_lapack_mpi np_cluster && cd ../inclusion && ln -s np_inclusion_lapack_mpi np_inclusion 
 #RUN cd np-tmcode/src && BUILDDIR=../../build BUILDDIR_NPTM=../../build/libnptm LIBNPTM=../../build/libnptm/libnptm.a USE_ILP64=1 USE_LAPACK=1 USE_OPENMP=1 CXX=g++ FC=gfortran make wipe && BUILDDIR=../../build BUILDDIR_NPTM=../../build/libnptm LIBNPTM=../../build/libnptm/libnptm.a USE_ILP64=1 USE_LAPACK=1 USE_OPENMP=1 CXX=g++ FC=gfortran make -j && mv ../build/cluster/np_cluster ../build/cluster/np_cluster_lapack_serial
-RUN cd np-tmcode/build && CXX=g++ FC=gfortran ./configure --enable-openmp --with-lapack --without-magma --enable-refinement --without-cublas && make clean && make -j && mv cluster/np_cluster cluster/np_cluster_lapack_serial && mv sphere/np_sphere sphere/np_sphere_lapack_serial && mv inclusion/np_inclusion inclusion/np_inclusion_lapack_serial && mv trapping/np_trapping trapping/np_trapping_lapack_serial
+RUN cd np-tmcode/build && CXX=g++ FC=gfortran ./configure --enable-openmp --with-lapack --without-magma --enable-refinement --without-cublas && make clean && make -j && mv cluster/np_cluster cluster/np_cluster_lapack_serial && mv inclusion/np_inclusion inclusion/np_inclusion_lapack_serial 
 #RUN cd np-tmcode/src && BUILDDIR=../../build BUILDDIR_NPTM=../../build/libnptm LIBNPTM=../../build/libnptm/libnptm.a USE_ILP64=1 USE_OPENMP=1 USE_MPI=1 CXX=mpicxx FC=gfortran make wipe && BUILDDIR=../../build BUILDDIR_NPTM=../../build/libnptm LIBNPTM=../../build/libnptm/libnptm.a USE_ILP64=1 USE_OPENMP=1 USE_MPI=1 CXX=mpicxx FC=gfortran make -j && mv ../build/cluster/np_cluster ../build/cluster/np_cluster_legacy_mpi
-RUN cd np-tmcode/build && CXX=mpicxx FC=gfortran ./configure --enable-openmp --without-lapack --without-magma --without-cublas && make clean && make -j && mv cluster/np_cluster cluster/np_cluster_legacy_mpi && mv sphere/np_sphere sphere/np_sphere_legacy_mpi && mv inclusion/np_inclusion inclusion/np_inclusion_legacy_mpi && mv trapping/np_trapping trapping/np_trapping_legacy_mpi
+RUN cd np-tmcode/build && CXX=mpicxx FC=gfortran ./configure --enable-openmp --without-lapack --without-magma --without-cublas && make clean && make -j && mv cluster/np_cluster cluster/np_cluster_legacy_mpi && mv sphere/np_sphere sphere/np_sphere_legacy_mpi && mv inclusion/np_inclusion inclusion/np_inclusion_legacy_mpi && cd sphere && ln -s np_sphere_legacy_mpi np_sphere
 #RUN cd np-tmcode/src && BUILDDIR=../../build BUILDDIR_NPTM=../../build/libnptm LIBNPTM=../../build/libnptm/libnptm.a USE_ILP64=1 USE_OPENMP=1 CXX=g++ FC=gfortran make wipe && BUILDDIR=../../build BUILDDIR_NPTM=../../build/libnptm LIBNPTM=../../build/libnptm/libnptm.a USE_ILP64=1 USE_OPENMP=1 CXX=g++ FC=gfortran make -j && mv ../build/cluster/np_cluster ../build/cluster/np_cluster_legacy_serial
-RUN cd np-tmcode/build && CXX=g++ FC=gfortran ./configure --disable-openmp --without-lapack --without-magma --without-cublas && make clean && make -j && mv cluster/np_cluster cluster/np_cluster_legacy_serial && mv sphere/np_sphere sphere/np_sphere_legacy_serial && mv inclusion/np_inclusion inclusion/np_inclusion_legacy_serial && mv trapping/np_trapping trapping/np_trapping_legacy_serial
+RUN cd np-tmcode/build && CXX=g++ FC=gfortran ./configure --disable-openmp --without-lapack --without-magma --without-cublas && make clean && make -j && mv cluster/np_cluster cluster/np_cluster_legacy_serial && mv sphere/np_sphere sphere/np_sphere_legacy_serial && mv inclusion/np_inclusion inclusion/np_inclusion_legacy_serial 
 RUN cd np-tmcode/doc/src && doxygen config.dox && cd ../build/latex && make -j
 
 
diff --git a/containers/docker/README.md b/containers/docker/README.md
index 708f2840f20af02b141ec027b25c4df41b2a2335..736420807b2d256726d2725c13356f922e99018c 100644
--- a/containers/docker/README.md
+++ b/containers/docker/README.md
@@ -1,9 +1,9 @@
 # Docker support for the NP-TMcode project
 
 ## Using the pre-built image
-The current version of NP-TMcode (M8.03) has been bundled in a pre-built `docker` image, distributed via `https://hub.docker.com/`. To use this image, run the command:
+The current version of NP-TMcode (M10a) has been bundled in a pre-built `docker` image, distributed via `https://hub.docker.com/`. To use this image, run the command:
 
-   > docker run -it gmulas/np-tmcode-run:M8 /bin/bash
+   > docker run -it gmulas/np-tmcode-run:m10a.00 /bin/bash
 
 The image will be automatically downloaded, if it is not available in the system, then it will be run in interactive mode, starting a shell session. Follow the instructions provided in Sec. 3.4.1 of the Release Notes document to proceed with testing and code use.
 
@@ -21,7 +21,7 @@ where `<image name>` is either `np-tmcode` or `np-tmcode-run`. One may also add
 
 # License
 
-   Copyright (C) 2024   INAF - Osservatorio Astronomico di Cagliari
+   Copyright (C) 2025   INAF - Osservatorio Astronomico di Cagliari
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/containers/singularity/README.md b/containers/singularity/README.md
index e648af486d2b70c475c6b2327d7761dd13fb8acc..480f891b7401b60c4098b5c35275c3de61a23239 100644
--- a/containers/singularity/README.md
+++ b/containers/singularity/README.md
@@ -1,7 +1,11 @@
 # Singularity support for the NP-TMcode project
 
 ## Using the pre-built image
-The current version of NP-TMcode (M8.03) has been bundled in a pre-built `singularity` image, distributed at `https://www.ict.inaf.it/gitlab/giacomo.mulas/np-tmcode-singularity/-/releases/np-tmcode-singularity-run-M8.03`. To use this image, download and unpack the pre-built image bundle, then place the `np-tmcode-run.sif` file in the `containers/singularity` folder of the NP-TMcode project.
+The current version of NP-TMcode (M10a) has been bundled in a pre-built `singularity` image, available from the sylabs cloud repository of singularity images at `https://cloud.sylabs.io/library/gmulas/np-tmcode-run/np-tmcode-run.sif`. To use this image, pull it with the command:
+
+   > singularity pull np-tmcode-run.sif library://gmulas/np-tmcode-run/np-tmcode-run.sif:m10a.00
+
+then place the `np-tmcode-run.sif` file in the `containers/singularity` folder of the NP-TMcode project.
 
 ## Building a local image
 A local image containing the necessary code requirements and binary files can be built through the image definition file provided along with the code. This `np-tmcode-run.def` file allows to create a `np-tmcode-run` image, that contains only the pre-built executables, python test scripts, compiled documentation, and the minimal runtime to run them.
@@ -20,11 +24,12 @@ or directly as
 
    > \<full path to image name\> \<np-tmcode command\>
 
-where `<full path to image name>` is the name of the sif image, including full or relative path to it, and `<np-tmcode command>` is one of the executables built in np-tmcode project, or the `pycompare.py` script used to compare results between the Fortran and C++ versions of the code. These executables, as well as the minimum runtime for them to execute correctly, are embedded in the image, and "see" the current directory the image is run in (which technically is automatically bind-mounted by singularity in the running image instance).
+where `<full path to image name>` is the name of the sif image, including full or relative path to it, and `<np-tmcode command>` is one of the executables built in np-tmcode project, or one of the accessory python scripts distributed with the code. These executables, as well as the minimum runtime for them to execute correctly, are embedded in the image, and "see" the current directory the image is run in (which technically is automatically bind-mounted by singularity in the running image instance). To further ease their use, one can also use the provided wrapper shell script, by setting the `SIFFILE` environment variable to the full path to the singularity image and then running the links with their respective names to `singwrapper` in the `scripts` directory.
+
 
 # License
 
-   Copyright (C) 2024   INAF - Osservatorio Astronomico di Cagliari
+   Copyright (C) 2025   INAF - Osservatorio Astronomico di Cagliari
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/containers/singularity/np-tmcode-run.def b/containers/singularity/np-tmcode-run.def
index a9f336788acc5126a7b0a68d1ecfd1961e9e970e..52947a7678f6a9fb60c9beaaf867c277aa3847b3 100644
--- a/containers/singularity/np-tmcode-run.def
+++ b/containers/singularity/np-tmcode-run.def
@@ -34,8 +34,8 @@ Stage: np-tmcode-run-dev
 	make -j
 	mv cluster/np_cluster cluster/np_cluster_magma_mpi
 	mv inclusion/np_inclusion inclusion/np_inclusion_magma_mpi
-	mv sphere/np_sphere sphere/np_sphere_magma_mpi
-	mv trapping/np_trapping trapping/np_trapping_magma_mpi
+	#mv sphere/np_sphere sphere/np_sphere_magma_mpi
+	#mv trapping/np_trapping trapping/np_trapping_magma_mpi
 	# with magma, ilp64, no mpi, openmp
 	#BUILDDIR=../../build BUILDDIR_NPTM=../../build/libnptm LIBNPTM=../../build/libnptm/libnptm.a USE_ILP64=1 USE_LAPACK=1 USE_MAGMA=1 USE_OPENMP=1 CXX=g++ FC=gfortran make wipe
 	CXX=g++ FC=gfortran ./configure --disable-shared --enable-ilp64 --enable-openmp --with-lapack --with-magma --enable-refinement --without-cublas
@@ -43,8 +43,8 @@ Stage: np-tmcode-run-dev
 	make -j
 	mv cluster/np_cluster cluster/np_cluster_magma_serial
 	mv inclusion/np_inclusion inclusion/np_inclusion_magma_serial
-	mv sphere/np_sphere sphere/np_sphere_magma_serial
-	mv trapping/np_trapping trapping/np_trapping_magma_serial
+	#mv sphere/np_sphere sphere/np_sphere_magma_serial
+	#mv trapping/np_trapping trapping/np_trapping_magma_serial
 	# with cublas, ilp64, mpi, openmp
 	#BUILDDIR=../../build BUILDDIR_NPTM=../../build/libnptm LIBNPTM=../../build/libnptm/libnptm.a USE_ILP64=1 USE_LAPACK=1 USE_MAGMA=1 USE_OPENMP=1 USE_MPI=1 CXX=mpicxx FC=gfortran make wipe
 	CXX=mpicxx FC=gfortran ./configure  --disable-shared --enable-refinement --enable-openmp --with-lapack --without-magma --with-cublas
@@ -52,8 +52,8 @@ Stage: np-tmcode-run-dev
 	make -j
 	mv cluster/np_cluster cluster/np_cluster_cublas_mpi
 	mv inclusion/np_inclusion inclusion/np_inclusion_cublas_mpi
-	mv sphere/np_sphere sphere/np_sphere_cublas_mpi
-	mv trapping/np_trapping trapping/np_trapping_cublas_mpi
+	#mv sphere/np_sphere sphere/np_sphere_cublas_mpi
+	#mv trapping/np_trapping trapping/np_trapping_cublas_mpi
 	# with cublas, ilp64, no mpi, openmp
 	#BUILDDIR=../../build BUILDDIR_NPTM=../../build/libnptm LIBNPTM=../../build/libnptm/libnptm.a USE_ILP64=1 USE_LAPACK=1 USE_MAGMA=1 USE_OPENMP=1 CXX=g++ FC=gfortran make wipe
 	CXX=g++ FC=gfortran ./configure --disable-shared --enable-ilp64 --enable-openmp --with-lapack --without-magma --enable-refinement --with-cublas
@@ -61,8 +61,8 @@ Stage: np-tmcode-run-dev
 	make -j
 	mv cluster/np_cluster cluster/np_cluster_cublas_serial
 	mv inclusion/np_inclusion inclusion/np_inclusion_cublas_serial
-	mv sphere/np_sphere sphere/np_sphere_cublas_serial
-	mv trapping/np_trapping trapping/np_trapping_cublas_serial
+	#mv sphere/np_sphere sphere/np_sphere_cublas_serial
+	#mv trapping/np_trapping trapping/np_trapping_cublas_serial
 	# with lapack, ilp64, mpi, openmp
 	#BUILDDIR=../../build BUILDDIR_NPTM=../../build/libnptm LIBNPTM=../../build/libnptm/libnptm.a USE_ILP64=1 USE_LAPACK=1 USE_OPENMP=1 USE_MPI=1 CXX=mpicxx FC=gfortran make wipe
 	CXX=mpicxx FC=gfortran ./configure --disable-shared --enable-ilp64 --enable-openmp --with-lapack --without-magma --enable-refinement --without-cublas
@@ -70,8 +70,8 @@ Stage: np-tmcode-run-dev
 	make -j
 	mv cluster/np_cluster cluster/np_cluster_lapack_mpi
 	mv inclusion/np_inclusion inclusion/np_inclusion_lapack_mpi
-	mv sphere/np_sphere sphere/np_sphere_lapack_mpi
-	mv trapping/np_trapping trapping/np_trapping_lapack_mpi
+	#mv sphere/np_sphere sphere/np_sphere_lapack_mpi
+	#mv trapping/np_trapping trapping/np_trapping_lapack_mpi
 	# with lapack, ilp64, no mpi, openmp
 	#BUILDDIR=../../build BUILDDIR_NPTM=../../build/libnptm LIBNPTM=../../build/libnptm/libnptm.a USE_ILP64=1 USE_LAPACK=1 USE_OPENMP=1 CXX=g++ FC=gfortran make wipe
 	CXX=g++ FC=gfortran ./configure --enable-ilp64 --enable-openmp --with-lapack --without-magma --disable-shared --enable-refinement --without-cublas
@@ -79,8 +79,8 @@ Stage: np-tmcode-run-dev
 	make -j
 	mv cluster/np_cluster cluster/np_cluster_lapack_serial
 	mv inclusion/np_inclusion inclusion/np_inclusion_lapack_serial
-	mv sphere/np_sphere sphere/np_sphere_lapack_serial
-	mv trapping/np_trapping trapping/np_trapping_lapack_serial
+	#mv sphere/np_sphere sphere/np_sphere_lapack_serial
+	#mv trapping/np_trapping trapping/np_trapping_lapack_serial
 	# with lucin, ilp64, mpi, openmp
 	#BUILDDIR=../../build BUILDDIR_NPTM=../../build/libnptm LIBNPTM=../../build/libnptm/libnptm.a USE_ILP64=1 USE_OPENMP=1 USE_MPI=1 CXX=mpicxx FC=gfortran make wipe
 	CXX=mpicxx FC=gfortran ./configure --enable-ilp64 --enable-openmp --without-lapack --without-magma --disable-shared --without-cublas
@@ -89,7 +89,7 @@ Stage: np-tmcode-run-dev
 	mv cluster/np_cluster cluster/np_cluster_legacy_mpi
 	mv inclusion/np_inclusion inclusion/np_inclusion_legacy_mpi
 	mv sphere/np_sphere sphere/np_sphere_legacy_mpi
-	mv trapping/np_trapping trapping/np_trapping_legacy_mpi
+	#mv trapping/np_trapping trapping/np_trapping_legacy_mpi
 	# with lucin, ilp64, no mpi, openmp
 	#BUILDDIR=../../build BUILDDIR_NPTM=../../build/libnptm LIBNPTM=../../build/libnptm/libnptm.a USE_ILP64=1 USE_OPENMP=1 CXX=g++ FC=gfortran make wipe
 	CXX=g++ FC=gfortran ./configure --enable-ilp64 --enable-openmp --without-lapack --without-magma --disable-shared --without-cublas
@@ -98,7 +98,7 @@ Stage: np-tmcode-run-dev
 	mv cluster/np_cluster cluster/np_cluster_legacy_serial
 	mv inclusion/np_inclusion inclusion/np_inclusion_legacy_serial
 	mv sphere/np_sphere sphere/np_sphere_legacy_serial
-	mv trapping/np_trapping trapping/np_trapping_legacy_serial
+	#mv trapping/np_trapping trapping/np_trapping_legacy_serial
 	#cd ../doc/src
 	#doxygen config.dox
 	#cd ../build/latex
@@ -109,9 +109,9 @@ Stage: np-tmcode-run-dev
 	cd ../inclusion
 	ln -s np_inclusion_lapack_mpi np_inclusion
 	cd ../sphere
-	ln -s np_sphere_lapack_mpi np_sphere
-	cd ../trapping
-	ln -s np_trapping_lapack_mpi np_trapping
+	ln -s np_sphere_legacy_mpi np_sphere
+	# cd ../trapping
+	# ln -s np_trapping_lapack_mpi np_trapping
 
 
 Bootstrap: docker
diff --git a/containers/singularity/scripts/clu b/containers/singularity/scripts/clu
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/clu
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/edfb_clu b/containers/singularity/scripts/edfb_clu
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/edfb_clu
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/edfb_inclu b/containers/singularity/scripts/edfb_inclu
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/edfb_inclu
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/edfb_sph b/containers/singularity/scripts/edfb_sph
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/edfb_sph
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/frfme b/containers/singularity/scripts/frfme
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/frfme
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/inclu b/containers/singularity/scripts/inclu
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/inclu
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/lffft b/containers/singularity/scripts/lffft
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/lffft
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/model_maker.py b/containers/singularity/scripts/model_maker.py
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/model_maker.py
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_cluster b/containers/singularity/scripts/np_cluster
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_cluster
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_cluster_cublas_mpi b/containers/singularity/scripts/np_cluster_cublas_mpi
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_cluster_cublas_mpi
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_cluster_cublas_serial b/containers/singularity/scripts/np_cluster_cublas_serial
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_cluster_cublas_serial
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_cluster_lapack_mpi b/containers/singularity/scripts/np_cluster_lapack_mpi
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_cluster_lapack_mpi
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_cluster_lapack_serial b/containers/singularity/scripts/np_cluster_lapack_serial
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_cluster_lapack_serial
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_cluster_legacy_mpi b/containers/singularity/scripts/np_cluster_legacy_mpi
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_cluster_legacy_mpi
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_cluster_legacy_serial b/containers/singularity/scripts/np_cluster_legacy_serial
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_cluster_legacy_serial
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_cluster_magma_mpi b/containers/singularity/scripts/np_cluster_magma_mpi
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_cluster_magma_mpi
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_cluster_magma_serial b/containers/singularity/scripts/np_cluster_magma_serial
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_cluster_magma_serial
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_inclusion b/containers/singularity/scripts/np_inclusion
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_inclusion
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_inclusion_cublas_mpi b/containers/singularity/scripts/np_inclusion_cublas_mpi
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_inclusion_cublas_mpi
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_inclusion_cublas_serial b/containers/singularity/scripts/np_inclusion_cublas_serial
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_inclusion_cublas_serial
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_inclusion_lapack_mpi b/containers/singularity/scripts/np_inclusion_lapack_mpi
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_inclusion_lapack_mpi
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_inclusion_lapack_serial b/containers/singularity/scripts/np_inclusion_lapack_serial
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_inclusion_lapack_serial
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_inclusion_legacy_mpi b/containers/singularity/scripts/np_inclusion_legacy_mpi
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_inclusion_legacy_mpi
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_inclusion_legacy_serial b/containers/singularity/scripts/np_inclusion_legacy_serial
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_inclusion_legacy_serial
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_inclusion_magma_mpi b/containers/singularity/scripts/np_inclusion_magma_mpi
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_inclusion_magma_mpi
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_inclusion_magma_serial b/containers/singularity/scripts/np_inclusion_magma_serial
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_inclusion_magma_serial
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_sphere b/containers/singularity/scripts/np_sphere
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_sphere
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_sphere_legacy_mpi b/containers/singularity/scripts/np_sphere_legacy_mpi
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_sphere_legacy_mpi
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_sphere_legacy_serial b/containers/singularity/scripts/np_sphere_legacy_serial
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_sphere_legacy_serial
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/np_trapping b/containers/singularity/scripts/np_trapping
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/np_trapping
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/pycompare.py b/containers/singularity/scripts/pycompare.py
new file mode 120000
index 0000000000000000000000000000000000000000..881714892c3c4e25f0ed33c2b9feab04f7aa5ea6
--- /dev/null
+++ b/containers/singularity/scripts/pycompare.py
@@ -0,0 +1 @@
+np_cluster
\ No newline at end of file
diff --git a/containers/singularity/scripts/pydynrange.py b/containers/singularity/scripts/pydynrange.py
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/pydynrange.py
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/pytiming.py b/containers/singularity/scripts/pytiming.py
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/pytiming.py
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/singwrapper b/containers/singularity/scripts/singwrapper
new file mode 100755
index 0000000000000000000000000000000000000000..9f8556706e9cf1c28f8e00126d084410837faa7c
--- /dev/null
+++ b/containers/singularity/scripts/singwrapper
@@ -0,0 +1,14 @@
+#!/bin/sh
+#
+# This script runs np_tmcode and connected programs in a singularity container,
+# to overcome idiotic library version compatibility issues
+
+#set -x
+
+APPLICATION=`basename $0`
+SCRIPTDIR=`dirname $0`
+INSTDIR="${SCRIPTDIR}/.."
+SIFFILE="${SIFFILE:-${INSTDIR}/np-tmcode-run.sif}"
+
+exec singularity run $SIFFILE $APPLICATION $@
+
diff --git a/containers/singularity/scripts/sph b/containers/singularity/scripts/sph
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/sph
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/test_ParticleDescriptor b/containers/singularity/scripts/test_ParticleDescriptor
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/test_ParticleDescriptor
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/test_TEDF b/containers/singularity/scripts/test_TEDF
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/test_TEDF
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/test_TTMS b/containers/singularity/scripts/test_TTMS
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/test_TTMS
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/test_cluster_outputs b/containers/singularity/scripts/test_cluster_outputs
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/test_cluster_outputs
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/test_inclusion_outputs b/containers/singularity/scripts/test_inclusion_outputs
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/test_inclusion_outputs
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/containers/singularity/scripts/test_sphere_outputs b/containers/singularity/scripts/test_sphere_outputs
new file mode 120000
index 0000000000000000000000000000000000000000..38e204a2377e42c3f91e87ae8d81c4111847de30
--- /dev/null
+++ b/containers/singularity/scripts/test_sphere_outputs
@@ -0,0 +1 @@
+singwrapper
\ No newline at end of file
diff --git a/doc/Release_Notes_M10a.02.pdf b/doc/Release_Notes_M10a.02.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..0882994ed3ad23bd1e5ff124d669714647f13705
Binary files /dev/null and b/doc/Release_Notes_M10a.02.pdf differ
diff --git a/doc/src/README.md b/doc/src/README.md
index f53470a3a08a663ccd34e6132f461804c9a3766f..20ad1dbb1aa8bf8274422825794ae66c6050f5c7 100644
--- a/doc/src/README.md
+++ b/doc/src/README.md
@@ -12,7 +12,7 @@ The project documentation is managed by *doxygen*, a documentation generator tha
 
 # License
 
-   Copyright (C) 2024   INAF - Osservatorio Astronomico di Cagliari
+   Copyright (C) 2025   INAF - Osservatorio Astronomico di Cagliari
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/ref_data/README.md b/ref_data/README.md
index d58e3fe9a15f8c0c4b096a3e3d9bf2d8462e7fef..ba2508bf511ca889ed2ea5bd3f9a2f1bf5fdec8f 100644
--- a/ref_data/README.md
+++ b/ref_data/README.md
@@ -10,7 +10,7 @@ If the calculation uses the exact grid matching, then all the dielectric constan
 
 # License
 
-   Copyright (C) 2024   INAF - Osservatorio Astronomico di Cagliari
+   Copyright (C) 2025   INAF - Osservatorio Astronomico di Cagliari
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/src/README.md b/src/README.md
index a7b4c701e2e6675a28c320667d8b54499dfd6906..246f2deebf5be34ffbaab35308b5c2f239826bd3 100644
--- a/src/README.md
+++ b/src/README.md
@@ -13,7 +13,7 @@ Instructions on how to set up and use the code are instead given in the project'
 
 # License
 
-   Copyright (C) 2024   INAF - Osservatorio Astronomico di Cagliari
+   Copyright (C) 2025   INAF - Osservatorio Astronomico di Cagliari
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/src/cluster/cluster.cpp b/src/cluster/cluster.cpp
index 46de0e4970fd32402cd1b9b96d1b9ae902131263..f3e9141dd5567e96a0155c03099870a1f6d7fcd8 100644
--- a/src/cluster/cluster.cpp
+++ b/src/cluster/cluster.cpp
@@ -440,8 +440,8 @@ void cluster(const string& config_file, const string& data_file, const string& o
 	    int jer = cluster_jxi488_cycle(myjxi488, sconf, gconf, p_scattering_angles, cid_2, p_output_2, output_path, vtppoanp_2);
 	  } else {
 	    if (myompthread > 0) {
-	      // If there is no input for this thread, set output pointer to NULL.
-	      p_outarray[myompthread] = NULL;
+	      // If there is no input for this thread, mark to skip.
+	      p_outarray[myompthread] = new ClusterOutputInfo(1);
 	    }
 	  }
 #pragma omp barrier
@@ -453,11 +453,9 @@ void cluster(const string& config_file, const string& data_file, const string& o
 	  // threads different from 0 append their virtual files to the one of thread 0, and delete them
 	  if (myompthread == 0) {
 	    for (int ti=1; ti<ompnumthreads; ti++) {
-	      if (p_outarray[ti] != NULL) {
-		p_outarray[0]->insert(*(p_outarray[ti]));
-		delete p_outarray[ti];
-		p_outarray[ti] = NULL;
-	      }
+	      p_outarray[0]->insert(*(p_outarray[ti]));
+	      delete p_outarray[ti];
+	      p_outarray[ti] = NULL;
 	      vtppoanarray[0]->append(*(vtppoanarray[ti]));
 	      delete vtppoanarray[ti];
 	    }
@@ -628,39 +626,25 @@ void cluster(const string& config_file, const string& data_file, const string& o
 	  }
 	  int jer = cluster_jxi488_cycle(myjxi488, sconf, gconf, p_scattering_angles, cid_2, p_output_2, output_path, vtppoanp_2);
 	} else {
-	  // if (myompthread > 0) {
-	    // If there is no input for this thread, set the output pointer to NULL.
-	    p_outarray[myompthread] = NULL;
-	  //}
+	  p_outarray[myompthread] = new ClusterOutputInfo(1);
 	}
 
 #pragma omp barrier
 	// threads different from 0 append their virtual files to the one of thread 0, and delete them
 	if (myompthread == 0) {
 	  for (int ti=1; ti<ompnumthreads; ti++) {
-	    if (p_outarray[ti] != NULL) {
-	      p_outarray[0]->insert(*(p_outarray[ti]));
-	      delete p_outarray[ti];
-	      p_outarray[ti] = NULL;
-	    }
+	    p_outarray[0]->insert(*(p_outarray[ti]));
+	    delete p_outarray[ti];
+	    p_outarray[ti] = NULL;
 	    vtppoanarray[0]->append(*(vtppoanarray[ti]));
 	    delete vtppoanarray[ti];
 	  }
 	  // thread 0 sends the collected virtualfiles to thread 0 of MPI process 0, then deletes them
 	  for (int rr=1; rr<mpidata->nprocs; rr++) {
 	    if (rr == mpidata->rank) {
-	      if (p_outarray[0] == NULL) {
-		// signal that we are not sending anything
-		int skip_flag = 1;
-		MPI_Send(&skip_flag, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-	      }
-	      else {
-		// signal that we are sending something
-		int skip_flag = 0;
-		MPI_Send(&skip_flag, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-		p_outarray[0]->mpisend(mpidata);
-		delete p_outarray[0];
-	      }
+	      p_outarray[0]->mpisend(mpidata);
+	      delete p_outarray[0];
+	      p_outarray[0] = NULL;
 	      vtppoanarray[0]->mpisend(mpidata);
 	      delete vtppoanarray[0];
 	    }
diff --git a/src/include/errors.h b/src/include/errors.h
index a986defa166fb9c7edbcdf5911f45084461e6590..1908ade318ecb90db059bde369971a27bcf85d16 100644
--- a/src/include/errors.h
+++ b/src/include/errors.h
@@ -22,6 +22,32 @@
 #ifndef INCLUDE_ERRORS_H_
 #define INCLUDE_ERRORS_H_
 
+/*! \brief Exception for wrong OutputInfo NULL calls.
+ */
+class UnrecognizedOutputInfo: public std::exception {
+protected:
+  //! Description of the problem.
+  std::string message;
+
+public:
+  /**
+   * \brief Exception instance constructor.
+   *
+   * \param requested: `int` The index that was requested.
+   */
+  UnrecognizedOutputInfo(int requested) {
+    message = "Error: passed parameter " + std::to_string(requested)
+      + ", but only 1 is allowed";
+  }
+  
+  /**
+   * \brief Exception message.
+   */
+  virtual const char* what() const throw() {
+    return message.c_str();
+  }
+};
+
 /*! \brief Exception for out of bounds List requests.
  */
 class ListOutOfBoundsException: public std::exception {
diff --git a/src/include/outputs.h b/src/include/outputs.h
index b4f9b02ed34cbb91a56cfbe9de2832e6fd28be52..82ee40ae0c2d19dbaa18135e680c1f001a94ecd6 100644
--- a/src/include/outputs.h
+++ b/src/include/outputs.h
@@ -33,6 +33,8 @@
  */
 class ClusterOutputInfo {
 protected:
+  //! \brief Flag for skipping mpisend() and mpireceive()
+  int _skip_flag;
   //! \brief Number of incident azimuth calculations.
   int _num_theta;
   //! \brief Number of scattered azimuth calculations.
@@ -63,6 +65,8 @@ protected:
   int write_legacy(const std::string &output);
   
 public:
+  //! \brief Read-only view on skip_flag
+  const int &skip_flag = _skip_flag;
   //! \brief Read-only view on the ID of the first scale
   const int &first_xi = _first_xi;
   //! \brief Number of spheres in the aggregate.
@@ -471,6 +475,12 @@ public:
    */   
   ClusterOutputInfo(const std::string &hdf5_name);
 
+  /*! \brief `ClusterOutputInfo` constructor for the dummy NULL case
+   *
+   * \param skip_flag: `const int` must be passed as the `1` constant.
+   */   
+  ClusterOutputInfo(const int skip_flag);
+
   /*! \brief `ClusterOutputInfo` instance destroyer.
    */
   ~ClusterOutputInfo();
@@ -551,6 +561,8 @@ public:
  */
 class InclusionOutputInfo {
 protected:
+  //! \brief Flag for skipping mpisend() and mpireceive()
+  int _skip_flag;
   //! \brief Number of incident azimuth calculations.
   int _num_theta;
   //! \brief Number of scattered azimuth calculations.
@@ -581,6 +593,8 @@ protected:
   int write_legacy(const std::string &output);
   
 public:
+  //! \brief Read-only view on skip_flag
+  const int &skip_flag = _skip_flag;
   //! \brief Read-only view on the ID of the first scale
   const int &first_xi = _first_xi;
   //! \brief Number of spheres in the aggregate.
@@ -901,6 +915,12 @@ public:
    */   
   InclusionOutputInfo(const std::string &hdf5_name);
 
+  /*! \brief `InclusionOutputInfo` constructor for the dummy NULL case
+   *
+   * \param skip_flag: `const int` must be passed as the `1` constant.
+   */   
+  InclusionOutputInfo(const int skip_flag);
+
   /*! \brief `InclusionOutputInfo` instance destroyer.
    */
   ~InclusionOutputInfo();
@@ -981,6 +1001,8 @@ public:
  */
 class SphereOutputInfo {
 protected:
+  //! \brief Flag for skipping mpisend() and mpireceive()
+  int _skip_flag;
   //! \brief Number of incident azimuth calculations.
   int _num_theta;
   //! \brief Number of scattered azimuth calculations.
@@ -1011,6 +1033,8 @@ protected:
   int write_legacy(const std::string &output);
   
 public:
+  //! \brief Read-only view on skip_flag
+  const int &skip_flag = _skip_flag;
   //! \brief Read-only view on the ID of the first scale
   const int &first_xi = _first_xi;
   //! \brief Number of spheres.
@@ -1181,6 +1205,12 @@ public:
    */   
   SphereOutputInfo(const std::string &hdf5_name);
 
+  /*! \brief `SphereOutputInfo` constructor for the dummy NULL case
+   *
+   * \param skip_flag: `const int` must be passed as the `1` constant.
+   */   
+  SphereOutputInfo(const int skip_flag);
+
   /*! \brief `InclusionOutputInfo` instance destroyer.
    */
   ~SphereOutputInfo();
diff --git a/src/inclusion/inclusion.cpp b/src/inclusion/inclusion.cpp
index d7aff78d25324f36f466294a3b357b88df9774b4..0b0033c4a20f7609c5fd5e9dc940efdf8f7509df 100644
--- a/src/inclusion/inclusion.cpp
+++ b/src/inclusion/inclusion.cpp
@@ -437,7 +437,7 @@ void inclusion(const string& config_file, const string& data_file, const string&
 	  } else {
 	    if (myompthread > 0) {
 	      // If there is no input for this thread, set output pointer to NULL.
-	      p_outarray[myompthread] = NULL;
+	      p_outarray[myompthread] = new InclusionOutputInfo(1);
 	    }
 	  }
 #pragma omp barrier
@@ -449,11 +449,9 @@ void inclusion(const string& config_file, const string& data_file, const string&
 	  // threads different from 0 append their virtual files to the one of thread 0, and delete them
 	  if (myompthread == 0) {
 	    for (int ti=1; ti<ompnumthreads; ti++) {
-	      if (p_outarray[ti] != NULL) {
-		p_outarray[0]->insert(*(p_outarray[ti]));
-		delete p_outarray[ti];
-		p_outarray[ti] = NULL;
-	      }
+	      p_outarray[0]->insert(*(p_outarray[ti]));
+	      delete p_outarray[ti];
+	      p_outarray[ti] = NULL;
 	      vtppoanarray[0]->append(*(vtppoanarray[ti]));
 	      delete vtppoanarray[ti];
 	    }
@@ -616,27 +614,24 @@ void inclusion(const string& config_file, const string& data_file, const string&
 	    p_outarray[myompthread] = p_output_2;
 	  } else {
 	    // Thread 0 of non-zero MPI processes needs to allocate memory for the
-	    // output of all threads.
-	    p_output_2 = new InclusionOutputInfo(sconf, gconf, mpidata, myjxi488, ompnumthreads);
+	    // output of all threads _doing something_.
+	    int iterstodo = cid_2->number_of_scales - myjxi488 + 1;
+	    if (iterstodo > ompnumthreads) iterstodo = ompnumthreads;
+	    p_output_2 = new InclusionOutputInfo(sconf, gconf, mpidata, myjxi488, iterstodo);
 	    p_outarray[0] = p_output_2;
 	  }
 	  int jer = inclusion_jxi488_cycle(myjxi488, sconf, gconf, p_scattering_angles, cid_2, p_output_2, output_path, vtppoanp_2);
 	} else {
-	  if (myompthread > 0) {
-	    // If there is no input for this thread, set the output pointer to NULL.
-	    p_outarray[myompthread] = NULL;
-	  }	  
+	  p_outarray[myompthread] = new InclusionOutputInfo(1);
 	}
 
 #pragma omp barrier
 	// threads different from 0 append their virtual files to the one of thread 0, and delete them
 	if (myompthread == 0) {
 	  for (int ti=1; ti<ompnumthreads; ti++) {
-	    if (p_outarray[ti] != NULL) {
-	      p_outarray[0]->insert(*(p_outarray[ti]));
-	      delete p_outarray[ti];
-	      p_outarray[ti] = NULL;
-	    }
+	    p_outarray[0]->insert(*(p_outarray[ti]));
+	    delete p_outarray[ti];
+	    p_outarray[ti] = NULL;
 	    vtppoanarray[0]->append(*(vtppoanarray[ti]));
 	    delete vtppoanarray[ti];
 	  }
@@ -645,6 +640,7 @@ void inclusion(const string& config_file, const string& data_file, const string&
 	    if (rr == mpidata->rank) {
 	      p_outarray[0]->mpisend(mpidata);
 	      delete p_outarray[0];
+	      p_outarray[0] = NULL;
 	      vtppoanarray[0]->mpisend(mpidata);
 	      delete vtppoanarray[0];
 	    }
diff --git a/src/libnptm/outputs.cpp b/src/libnptm/outputs.cpp
index 3cf5c1b474dcd3eeca1d71677abbd882b54532e9..48791dc9a947ef24f9183d974b5855d7ebe24602 100644
--- a/src/libnptm/outputs.cpp
+++ b/src/libnptm/outputs.cpp
@@ -61,6 +61,7 @@ ClusterOutputInfo::ClusterOutputInfo(
   ScattererConfiguration *sc, GeometryConfiguration *gc,
   const mixMPI *mpidata, int first_xi, int xi_length
 ) {
+  _skip_flag = 0;
   nsph = gc->number_of_spheres;
   li = gc->li;
   le = gc->le;
@@ -293,6 +294,7 @@ ClusterOutputInfo::ClusterOutputInfo(const std::string &hdf5_name) {
   HDFFile *hdf_file = new HDFFile(hdf5_name, flags);
   herr_t status = hdf_file->get_status();
   string str_name, str_type;
+  _skip_flag = 0;
   if (status == 0) {
     status = hdf_file->read("NSPH", "INT32_(1)", &nsph);
     status = hdf_file->read("LI", "INT32_(1)", &li);
@@ -701,170 +703,184 @@ ClusterOutputInfo::ClusterOutputInfo(const std::string &hdf5_name) {
   }
 }
 
+ClusterOutputInfo::ClusterOutputInfo(const int flag) {
+  /*
+    create a dummy placeholder just to know I should skip MPI_Send and MPI_Recv
+  */
+  if (flag == 1) {
+    _skip_flag = 1;
+  } else {
+    UnrecognizedOutputInfo ex(flag);
+    throw ex;
+  }
+}
+
 ClusterOutputInfo::~ClusterOutputInfo() {
-  delete[] vec_x_coords;
-  delete[] vec_y_coords;
-  delete[] vec_z_coords;
-  delete[] vec_jxi;
-  delete[] vec_ier;
-  delete[] vec_vk;
-  delete[] vec_xi;
-  delete[] vec_sphere_sizes;
-  delete[] vec_sphere_ref_indices;
-  delete[] vec_sphere_scs;
-  delete[] vec_sphere_abs;
-  delete[] vec_sphere_exs;
-  delete[] vec_sphere_albs;
-  delete[] vec_sphere_sqscs;
-  delete[] vec_sphere_sqabs;
-  delete[] vec_sphere_sqexs;
-  delete[] vec_fsas;
-  delete[] vec_qschus;
-  delete[] vec_pschus;
-  delete[] vec_s0mags;
-  delete[] vec_cosavs;
-  delete[] vec_raprs;
-  delete[] vec_tqek1;
-  delete[] vec_tqsk1;
-  delete[] vec_tqek2;
-  delete[] vec_tqsk2;
-  delete[] vec_fsat;
-  delete[] vec_qschut;
-  delete[] vec_pschut;
-  delete[] vec_s0magt;
-  delete[] vec_scc1;
-  delete[] vec_scc2;
-  delete[] vec_abc1;
-  delete[] vec_abc2;
-  delete[] vec_exc1;
-  delete[] vec_exc2;
-  delete[] vec_albedc1;
-  delete[] vec_albedc2;
-  delete[] vec_sccrt1;
-  delete[] vec_sccrt2;
-  delete[] vec_abcrt1;
-  delete[] vec_abcrt2;
-  delete[] vec_excrt1;
-  delete[] vec_excrt2;
-  delete[] vec_fsac11;
-  delete[] vec_fsac21;
-  delete[] vec_fsac22;
-  delete[] vec_fsac12;
-  delete[] vec_qschuc1;
-  delete[] vec_qschuc2;
-  delete[] vec_pschuc1;
-  delete[] vec_pschuc2;
-  delete[] vec_s0magc1;
-  delete[] vec_s0magc2;
-  delete[] vec_cosavc1;
-  delete[] vec_cosavc2;
-  delete[] vec_raprc1;
-  delete[] vec_raprc2;
-  delete[] vec_fkc1;
-  delete[] vec_fkc2;
-  delete[] vec_dir_tidg;
-  delete[] vec_dir_pidg;
-  delete[] vec_dir_tsdg;
-  delete[] vec_dir_psdg;
-  delete[] vec_dir_scand;
-  delete[] vec_dir_cfmp;
-  delete[] vec_dir_sfmp;
-  delete[] vec_dir_cfsp;
-  delete[] vec_dir_sfsp;
-  delete[] vec_dir_un;
-  delete[] vec_dir_uns;
-  delete[] vec_dir_sas11;
-  delete[] vec_dir_sas21;
-  delete[] vec_dir_sas12;
-  delete[] vec_dir_sas22;
-  delete[] vec_dir_muls;
-  delete[] vec_dir_mulslr;
-  delete[] vec_dir_sat11;
-  delete[] vec_dir_sat21;
-  delete[] vec_dir_sat12;
-  delete[] vec_dir_sat22;
-  delete[] vec_dir_scc1;
-  delete[] vec_dir_scc2;
-  delete[] vec_dir_abc1;
-  delete[] vec_dir_abc2;
-  delete[] vec_dir_exc1;
-  delete[] vec_dir_exc2;
-  delete[] vec_dir_albedc1;
-  delete[] vec_dir_albedc2;
-  delete[] vec_dir_qscc1;
-  delete[] vec_dir_qscc2;
-  delete[] vec_dir_qabc1;
-  delete[] vec_dir_qabc2;
-  delete[] vec_dir_qexc1;
-  delete[] vec_dir_qexc2;
-  delete[] vec_qscamc1;
-  delete[] vec_qscamc2;
-  delete[] vec_qabsmc1;
-  delete[] vec_qabsmc2;
-  delete[] vec_qextmc1;
-  delete[] vec_qextmc2;
-  delete[] vec_dir_sccrt1;
-  delete[] vec_dir_sccrt2;
-  delete[] vec_dir_abcrt1;
-  delete[] vec_dir_abcrt2;
-  delete[] vec_dir_excrt1;
-  delete[] vec_dir_excrt2;
-  delete[] vec_dir_fsac11;
-  delete[] vec_dir_fsac21;
-  delete[] vec_dir_fsac12;
-  delete[] vec_dir_fsac22;
-  delete[] vec_dir_sac11;
-  delete[] vec_dir_sac21;
-  delete[] vec_dir_sac12;
-  delete[] vec_dir_sac22;
-  delete[] vec_dir_qschuc1;
-  delete[] vec_dir_qschuc2;
-  delete[] vec_dir_pschuc1;
-  delete[] vec_dir_pschuc2;
-  delete[] vec_dir_s0magc1;
-  delete[] vec_dir_s0magc2;
-  delete[] vec_dir_cosavc1;
-  delete[] vec_dir_cosavc2;
-  delete[] vec_dir_raprc1;
-  delete[] vec_dir_raprc2;
-  delete[] vec_dir_flc1;
-  delete[] vec_dir_flc2;
-  delete[] vec_dir_frc1;
-  delete[] vec_dir_frc2;
-  delete[] vec_dir_fkc1;
-  delete[] vec_dir_fkc2;
-  delete[] vec_dir_fxc1;
-  delete[] vec_dir_fxc2;
-  delete[] vec_dir_fyc1;
-  delete[] vec_dir_fyc2;
-  delete[] vec_dir_fzc1;
-  delete[] vec_dir_fzc2;
-  delete[] vec_dir_tqelc1;
-  delete[] vec_dir_tqelc2;
-  delete[] vec_dir_tqerc1;
-  delete[] vec_dir_tqerc2;
-  delete[] vec_dir_tqekc1;
-  delete[] vec_dir_tqekc2;
-  delete[] vec_dir_tqexc1;
-  delete[] vec_dir_tqexc2;
-  delete[] vec_dir_tqeyc1;
-  delete[] vec_dir_tqeyc2;
-  delete[] vec_dir_tqezc1;
-  delete[] vec_dir_tqezc2;
-  delete[] vec_dir_tqslc1;
-  delete[] vec_dir_tqslc2;
-  delete[] vec_dir_tqsrc1;
-  delete[] vec_dir_tqsrc2;
-  delete[] vec_dir_tqskc1;
-  delete[] vec_dir_tqskc2;
-  delete[] vec_dir_tqsxc1;
-  delete[] vec_dir_tqsxc2;
-  delete[] vec_dir_tqsyc1;
-  delete[] vec_dir_tqsyc2;
-  delete[] vec_dir_tqszc1;
-  delete[] vec_dir_tqszc2;
-  delete[] vec_dir_mulc;
-  delete[] vec_dir_mulclr;
+  if (_skip_flag != 1) {
+    delete[] vec_x_coords;
+    delete[] vec_y_coords;
+    delete[] vec_z_coords;
+    delete[] vec_jxi;
+    delete[] vec_ier;
+    delete[] vec_vk;
+    delete[] vec_xi;
+    delete[] vec_sphere_sizes;
+    delete[] vec_sphere_ref_indices;
+    delete[] vec_sphere_scs;
+    delete[] vec_sphere_abs;
+    delete[] vec_sphere_exs;
+    delete[] vec_sphere_albs;
+    delete[] vec_sphere_sqscs;
+    delete[] vec_sphere_sqabs;
+    delete[] vec_sphere_sqexs;
+    delete[] vec_fsas;
+    delete[] vec_qschus;
+    delete[] vec_pschus;
+    delete[] vec_s0mags;
+    delete[] vec_cosavs;
+    delete[] vec_raprs;
+    delete[] vec_tqek1;
+    delete[] vec_tqsk1;
+    delete[] vec_tqek2;
+    delete[] vec_tqsk2;
+    delete[] vec_fsat;
+    delete[] vec_qschut;
+    delete[] vec_pschut;
+    delete[] vec_s0magt;
+    delete[] vec_scc1;
+    delete[] vec_scc2;
+    delete[] vec_abc1;
+    delete[] vec_abc2;
+    delete[] vec_exc1;
+    delete[] vec_exc2;
+    delete[] vec_albedc1;
+    delete[] vec_albedc2;
+    delete[] vec_sccrt1;
+    delete[] vec_sccrt2;
+    delete[] vec_abcrt1;
+    delete[] vec_abcrt2;
+    delete[] vec_excrt1;
+    delete[] vec_excrt2;
+    delete[] vec_fsac11;
+    delete[] vec_fsac21;
+    delete[] vec_fsac22;
+    delete[] vec_fsac12;
+    delete[] vec_qschuc1;
+    delete[] vec_qschuc2;
+    delete[] vec_pschuc1;
+    delete[] vec_pschuc2;
+    delete[] vec_s0magc1;
+    delete[] vec_s0magc2;
+    delete[] vec_cosavc1;
+    delete[] vec_cosavc2;
+    delete[] vec_raprc1;
+    delete[] vec_raprc2;
+    delete[] vec_fkc1;
+    delete[] vec_fkc2;
+    delete[] vec_dir_tidg;
+    delete[] vec_dir_pidg;
+    delete[] vec_dir_tsdg;
+    delete[] vec_dir_psdg;
+    delete[] vec_dir_scand;
+    delete[] vec_dir_cfmp;
+    delete[] vec_dir_sfmp;
+    delete[] vec_dir_cfsp;
+    delete[] vec_dir_sfsp;
+    delete[] vec_dir_un;
+    delete[] vec_dir_uns;
+    delete[] vec_dir_sas11;
+    delete[] vec_dir_sas21;
+    delete[] vec_dir_sas12;
+    delete[] vec_dir_sas22;
+    delete[] vec_dir_muls;
+    delete[] vec_dir_mulslr;
+    delete[] vec_dir_sat11;
+    delete[] vec_dir_sat21;
+    delete[] vec_dir_sat12;
+    delete[] vec_dir_sat22;
+    delete[] vec_dir_scc1;
+    delete[] vec_dir_scc2;
+    delete[] vec_dir_abc1;
+    delete[] vec_dir_abc2;
+    delete[] vec_dir_exc1;
+    delete[] vec_dir_exc2;
+    delete[] vec_dir_albedc1;
+    delete[] vec_dir_albedc2;
+    delete[] vec_dir_qscc1;
+    delete[] vec_dir_qscc2;
+    delete[] vec_dir_qabc1;
+    delete[] vec_dir_qabc2;
+    delete[] vec_dir_qexc1;
+    delete[] vec_dir_qexc2;
+    delete[] vec_qscamc1;
+    delete[] vec_qscamc2;
+    delete[] vec_qabsmc1;
+    delete[] vec_qabsmc2;
+    delete[] vec_qextmc1;
+    delete[] vec_qextmc2;
+    delete[] vec_dir_sccrt1;
+    delete[] vec_dir_sccrt2;
+    delete[] vec_dir_abcrt1;
+    delete[] vec_dir_abcrt2;
+    delete[] vec_dir_excrt1;
+    delete[] vec_dir_excrt2;
+    delete[] vec_dir_fsac11;
+    delete[] vec_dir_fsac21;
+    delete[] vec_dir_fsac12;
+    delete[] vec_dir_fsac22;
+    delete[] vec_dir_sac11;
+    delete[] vec_dir_sac21;
+    delete[] vec_dir_sac12;
+    delete[] vec_dir_sac22;
+    delete[] vec_dir_qschuc1;
+    delete[] vec_dir_qschuc2;
+    delete[] vec_dir_pschuc1;
+    delete[] vec_dir_pschuc2;
+    delete[] vec_dir_s0magc1;
+    delete[] vec_dir_s0magc2;
+    delete[] vec_dir_cosavc1;
+    delete[] vec_dir_cosavc2;
+    delete[] vec_dir_raprc1;
+    delete[] vec_dir_raprc2;
+    delete[] vec_dir_flc1;
+    delete[] vec_dir_flc2;
+    delete[] vec_dir_frc1;
+    delete[] vec_dir_frc2;
+    delete[] vec_dir_fkc1;
+    delete[] vec_dir_fkc2;
+    delete[] vec_dir_fxc1;
+    delete[] vec_dir_fxc2;
+    delete[] vec_dir_fyc1;
+    delete[] vec_dir_fyc2;
+    delete[] vec_dir_fzc1;
+    delete[] vec_dir_fzc2;
+    delete[] vec_dir_tqelc1;
+    delete[] vec_dir_tqelc2;
+    delete[] vec_dir_tqerc1;
+    delete[] vec_dir_tqerc2;
+    delete[] vec_dir_tqekc1;
+    delete[] vec_dir_tqekc2;
+    delete[] vec_dir_tqexc1;
+    delete[] vec_dir_tqexc2;
+    delete[] vec_dir_tqeyc1;
+    delete[] vec_dir_tqeyc2;
+    delete[] vec_dir_tqezc1;
+    delete[] vec_dir_tqezc2;
+    delete[] vec_dir_tqslc1;
+    delete[] vec_dir_tqslc2;
+    delete[] vec_dir_tqsrc1;
+    delete[] vec_dir_tqsrc2;
+    delete[] vec_dir_tqskc1;
+    delete[] vec_dir_tqskc2;
+    delete[] vec_dir_tqsxc1;
+    delete[] vec_dir_tqsxc2;
+    delete[] vec_dir_tqsyc1;
+    delete[] vec_dir_tqsyc2;
+    delete[] vec_dir_tqszc1;
+    delete[] vec_dir_tqszc2;
+    delete[] vec_dir_mulc;
+    delete[] vec_dir_mulclr;
+  }
 }
 
 long ClusterOutputInfo::compute_size(
@@ -961,182 +977,184 @@ long ClusterOutputInfo::compute_size() {
 
 int ClusterOutputInfo::insert(const ClusterOutputInfo &rhs) {
   int result = 0;
-  result += (rhs.nsph == nsph) ? 0 : 1;
-  result += (rhs.inpol == inpol) ? 0 : 1;
-  result += (rhs.iavm == iavm) ? 0 : 1;
-  result += (rhs.isam == isam) ? 0 : 1;
-  result += (rhs._num_theta == _num_theta) ? 0 : 1;
-  result += (rhs._num_thetas == _num_thetas) ? 0 : 1;
-  result += (rhs._num_phi == _num_phi) ? 0 : 1;
-  result += (rhs._num_phis == _num_phis) ? 0 : 1;
-  result += (rhs.ndirs == ndirs) ? 0 : 1;
-  result += (rhs.exri == exri) ? 0 : 1;
-  result += (rhs.idfc == idfc) ? 0 : 1;
-  result += (rhs.configurations == configurations) ? 0 : 1;
-  if (result == 0) {
-    int offset, chunk_size, xi1;
-    xi1 = rhs._first_xi;
-    // Insert vectors whose size depends on wavelengths
-    offset = xi1 - _first_xi;
-    chunk_size = rhs.xi_block_size;
-    memcpy(vec_jxi + offset, rhs.vec_jxi, chunk_size * sizeof(int));
-    memcpy(vec_ier + offset, rhs.vec_ier, chunk_size * sizeof(short));
-    memcpy(vec_vk + offset, rhs.vec_vk, chunk_size * sizeof(double));
-    memcpy(vec_xi + offset, rhs.vec_xi, chunk_size * sizeof(double));
-    memcpy(vec_fsat + offset, rhs.vec_fsat, chunk_size * sizeof(dcomplex));
-    memcpy(vec_qschut + offset, rhs.vec_qschut, chunk_size * sizeof(double));
-    memcpy(vec_pschut + offset, rhs.vec_pschut, chunk_size * sizeof(double));
-    memcpy(vec_s0magt + offset, rhs.vec_s0magt, chunk_size * sizeof(double));
-    memcpy(vec_scc1 + offset, rhs.vec_scc1, chunk_size * sizeof(double));
-    memcpy(vec_scc2 + offset, rhs.vec_scc2, chunk_size * sizeof(double));
-    memcpy(vec_abc1 + offset, rhs.vec_abc1, chunk_size * sizeof(double));
-    memcpy(vec_abc2 + offset, rhs.vec_abc2, chunk_size * sizeof(double));
-    memcpy(vec_exc1 + offset, rhs.vec_exc1, chunk_size * sizeof(double));
-    memcpy(vec_exc2 + offset, rhs.vec_exc2, chunk_size * sizeof(double));
-    memcpy(vec_albedc1 + offset, rhs.vec_albedc1, chunk_size * sizeof(double));
-    memcpy(vec_albedc2 + offset, rhs.vec_albedc2, chunk_size * sizeof(double));
-    memcpy(vec_qscamc1 + offset, rhs.vec_qscamc1, chunk_size * sizeof(double));
-    memcpy(vec_qscamc2 + offset, rhs.vec_qscamc2, chunk_size * sizeof(double));
-    memcpy(vec_qabsmc1 + offset, rhs.vec_qabsmc1, chunk_size * sizeof(double));
-    memcpy(vec_qabsmc2 + offset, rhs.vec_qabsmc2, chunk_size * sizeof(double));
-    memcpy(vec_qextmc1 + offset, rhs.vec_qextmc1, chunk_size * sizeof(double));
-    memcpy(vec_qextmc2 + offset, rhs.vec_qextmc2, chunk_size * sizeof(double));
-    memcpy(vec_sccrt1 + offset, rhs.vec_sccrt1, chunk_size * sizeof(double));
-    memcpy(vec_sccrt2 + offset, rhs.vec_sccrt2, chunk_size * sizeof(double));
-    memcpy(vec_abcrt1 + offset, rhs.vec_abcrt1, chunk_size * sizeof(double));
-    memcpy(vec_abcrt2 + offset, rhs.vec_abcrt2, chunk_size * sizeof(double));
-    memcpy(vec_excrt1 + offset, rhs.vec_excrt1, chunk_size * sizeof(double));
-    memcpy(vec_excrt2 + offset, rhs.vec_excrt2, chunk_size * sizeof(double));
-    memcpy(vec_fsac11 + offset, rhs.vec_fsac11, chunk_size * sizeof(dcomplex));
-    memcpy(vec_fsac21 + offset, rhs.vec_fsac21, chunk_size * sizeof(dcomplex));
-    memcpy(vec_fsac22 + offset, rhs.vec_fsac22, chunk_size * sizeof(dcomplex));
-    memcpy(vec_fsac12 + offset, rhs.vec_fsac12, chunk_size * sizeof(dcomplex));
-    memcpy(vec_qschuc1 + offset, rhs.vec_qschuc1, chunk_size * sizeof(double));
-    memcpy(vec_qschuc2 + offset, rhs.vec_qschuc2, chunk_size * sizeof(double));
-    memcpy(vec_pschuc1 + offset, rhs.vec_pschuc1, chunk_size * sizeof(double));
-    memcpy(vec_pschuc2 + offset, rhs.vec_pschuc2, chunk_size * sizeof(double));
-    memcpy(vec_s0magc1 + offset, rhs.vec_s0magc1, chunk_size * sizeof(double));
-    memcpy(vec_s0magc2 + offset, rhs.vec_s0magc2, chunk_size * sizeof(double));
-    memcpy(vec_cosavc1 + offset, rhs.vec_cosavc1, chunk_size * sizeof(double));
-    memcpy(vec_cosavc2 + offset, rhs.vec_cosavc2, chunk_size * sizeof(double));
-    memcpy(vec_raprc1 + offset, rhs.vec_raprc1, chunk_size * sizeof(double));
-    memcpy(vec_raprc2 + offset, rhs.vec_raprc2, chunk_size * sizeof(double));
-    memcpy(vec_fkc1 + offset, rhs.vec_fkc1, chunk_size * sizeof(double));
-    memcpy(vec_fkc2 + offset, rhs.vec_fkc2, chunk_size * sizeof(double));
-    // Insert vectors of multiple configuration values per scale
-    offset = (xi1 - _first_xi) * configurations;
-    chunk_size = rhs.xi_block_size * configurations;
-    memcpy(vec_sphere_sizes + offset, rhs.vec_sphere_sizes, chunk_size * sizeof(double));
-    memcpy(vec_sphere_ref_indices + offset, rhs.vec_sphere_ref_indices, chunk_size * sizeof(dcomplex));
-    memcpy(vec_sphere_scs + offset, rhs.vec_sphere_scs, chunk_size * sizeof(double));
-    memcpy(vec_sphere_abs + offset, rhs.vec_sphere_abs, chunk_size * sizeof(double));
-    memcpy(vec_sphere_exs + offset, rhs.vec_sphere_exs, chunk_size * sizeof(double));
-    memcpy(vec_sphere_albs + offset, rhs.vec_sphere_albs, chunk_size * sizeof(double));
-    memcpy(vec_sphere_sqscs + offset, rhs.vec_sphere_sqscs, chunk_size * sizeof(double));
-    memcpy(vec_sphere_sqabs + offset, rhs.vec_sphere_sqabs, chunk_size * sizeof(double));
-    memcpy(vec_sphere_sqexs + offset, rhs.vec_sphere_sqexs, chunk_size * sizeof(double));
-    memcpy(vec_fsas + offset, rhs.vec_fsas, chunk_size * sizeof(dcomplex));
-    memcpy(vec_qschus + offset, rhs.vec_qschus, chunk_size * sizeof(double));
-    memcpy(vec_pschus + offset, rhs.vec_pschus, chunk_size * sizeof(double));
-    memcpy(vec_s0mags + offset, rhs.vec_s0mags, chunk_size * sizeof(double));
-    memcpy(vec_cosavs + offset, rhs.vec_cosavs, chunk_size * sizeof(double));
-    memcpy(vec_raprs + offset, rhs.vec_raprs, chunk_size * sizeof(double));
-    memcpy(vec_tqek1 + offset, rhs.vec_tqek1, chunk_size * sizeof(double));
-    memcpy(vec_tqsk1 + offset, rhs.vec_tqsk1, chunk_size * sizeof(double));
-    memcpy(vec_tqek2 + offset, rhs.vec_tqek2, chunk_size * sizeof(double));
-    memcpy(vec_tqsk2 + offset, rhs.vec_tqsk2, chunk_size * sizeof(double));
-    // Insert vectors of multiple directions per configuration
-    offset = (xi1 - _first_xi) * configurations * ndirs;
-    chunk_size = rhs.xi_block_size * configurations * ndirs;
-    memcpy(vec_dir_sas11 + offset, rhs.vec_dir_sas11, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_sas21 + offset, rhs.vec_dir_sas21, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_sas12 + offset, rhs.vec_dir_sas12, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_sas22 + offset, rhs.vec_dir_sas22, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_muls + 16 * offset, rhs.vec_dir_muls, 16 * chunk_size * sizeof(double));
-    memcpy(vec_dir_mulslr + 16 * offset, rhs.vec_dir_mulslr, 16 * chunk_size * sizeof(double));
-    // Insert vectors whose sizes depend on wavelengths and directions
-    offset = (xi1 - _first_xi) * ndirs;
-    chunk_size = rhs.xi_block_size * ndirs;
-    memcpy(vec_dir_sat11 + offset, rhs.vec_dir_sat11, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_sat21 + offset, rhs.vec_dir_sat21, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_sat12 + offset, rhs.vec_dir_sat12, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_sat22 + offset, rhs.vec_dir_sat22, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_scc1 + offset, rhs.vec_dir_scc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_scc2 + offset, rhs.vec_dir_scc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_abc1 + offset, rhs.vec_dir_abc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_abc2 + offset, rhs.vec_dir_abc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_exc1 + offset, rhs.vec_dir_exc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_exc2 + offset, rhs.vec_dir_exc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_albedc1 + offset, rhs.vec_dir_albedc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_albedc2 + offset, rhs.vec_dir_albedc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_qscc1 + offset, rhs.vec_dir_qscc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_qscc2 + offset, rhs.vec_dir_qscc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_qabc1 + offset, rhs.vec_dir_qabc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_qabc2 + offset, rhs.vec_dir_qabc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_qexc1 + offset, rhs.vec_dir_qexc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_qexc2 + offset, rhs.vec_dir_qexc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_sccrt1 + offset, rhs.vec_dir_sccrt1, chunk_size * sizeof(double));
-    memcpy(vec_dir_sccrt2 + offset, rhs.vec_dir_sccrt2, chunk_size * sizeof(double));
-    memcpy(vec_dir_abcrt1 + offset, rhs.vec_dir_abcrt1, chunk_size * sizeof(double));
-    memcpy(vec_dir_abcrt2 + offset, rhs.vec_dir_abcrt2, chunk_size * sizeof(double));
-    memcpy(vec_dir_excrt1 + offset, rhs.vec_dir_excrt1, chunk_size * sizeof(double));
-    memcpy(vec_dir_excrt2 + offset, rhs.vec_dir_excrt2, chunk_size * sizeof(double));
-    memcpy(vec_dir_fsac11 + offset, rhs.vec_dir_fsac11, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_fsac21 + offset, rhs.vec_dir_fsac21, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_fsac12 + offset, rhs.vec_dir_fsac12, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_fsac22 + offset, rhs.vec_dir_fsac22, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_sac11 + offset, rhs.vec_dir_sac11, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_sac21 + offset, rhs.vec_dir_sac21, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_sac12 + offset, rhs.vec_dir_sac12, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_sac22 + offset, rhs.vec_dir_sac22, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_qschuc1 + offset, rhs.vec_dir_qschuc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_qschuc2 + offset, rhs.vec_dir_qschuc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_pschuc1 + offset, rhs.vec_dir_pschuc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_pschuc2 + offset, rhs.vec_dir_pschuc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_s0magc1 + offset, rhs.vec_dir_s0magc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_s0magc2 + offset, rhs.vec_dir_s0magc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_cosavc1 + offset, rhs.vec_dir_cosavc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_cosavc2 + offset, rhs.vec_dir_cosavc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_raprc1 + offset, rhs.vec_dir_raprc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_raprc2 + offset, rhs.vec_dir_raprc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_flc1 + offset, rhs.vec_dir_flc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_flc2 + offset, rhs.vec_dir_flc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_frc1 + offset, rhs.vec_dir_frc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_frc2 + offset, rhs.vec_dir_frc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_fkc1 + offset, rhs.vec_dir_fkc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_fkc2 + offset, rhs.vec_dir_fkc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_fxc1 + offset, rhs.vec_dir_fxc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_fxc2 + offset, rhs.vec_dir_fxc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_fyc1 + offset, rhs.vec_dir_fyc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_fyc2 + offset, rhs.vec_dir_fyc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_fzc1 + offset, rhs.vec_dir_fzc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_fzc2 + offset, rhs.vec_dir_fzc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqelc1 + offset, rhs.vec_dir_tqelc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqelc2 + offset, rhs.vec_dir_tqelc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqerc1 + offset, rhs.vec_dir_tqerc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqerc2 + offset, rhs.vec_dir_tqerc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqekc1 + offset, rhs.vec_dir_tqekc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqekc2 + offset, rhs.vec_dir_tqekc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqexc1 + offset, rhs.vec_dir_tqexc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqexc2 + offset, rhs.vec_dir_tqexc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqeyc1 + offset, rhs.vec_dir_tqeyc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqeyc2 + offset, rhs.vec_dir_tqeyc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqezc1 + offset, rhs.vec_dir_tqezc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqezc2 + offset, rhs.vec_dir_tqezc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqslc1 + offset, rhs.vec_dir_tqslc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqslc2 + offset, rhs.vec_dir_tqslc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqsrc1 + offset, rhs.vec_dir_tqsrc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqsrc2 + offset, rhs.vec_dir_tqsrc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqskc1 + offset, rhs.vec_dir_tqskc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqskc2 + offset, rhs.vec_dir_tqskc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqsxc1 + offset, rhs.vec_dir_tqsxc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqsxc2 + offset, rhs.vec_dir_tqsxc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqsyc1 + offset, rhs.vec_dir_tqsyc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqsyc2 + offset, rhs.vec_dir_tqsyc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqszc1 + offset, rhs.vec_dir_tqszc1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqszc2 + offset, rhs.vec_dir_tqszc2, chunk_size * sizeof(double));
-    memcpy(vec_dir_mulc + 16 * offset, rhs.vec_dir_mulc, 16 * chunk_size * sizeof(double));
-    memcpy(vec_dir_mulclr + 16 * offset, rhs.vec_dir_mulclr, 16 * chunk_size * sizeof(double));
+  if (rhs.skip_flag != 1) {
+    result += (rhs.nsph == nsph) ? 0 : 1;
+    result += (rhs.inpol == inpol) ? 0 : 1;
+    result += (rhs.iavm == iavm) ? 0 : 1;
+    result += (rhs.isam == isam) ? 0 : 1;
+    result += (rhs._num_theta == _num_theta) ? 0 : 1;
+    result += (rhs._num_thetas == _num_thetas) ? 0 : 1;
+    result += (rhs._num_phi == _num_phi) ? 0 : 1;
+    result += (rhs._num_phis == _num_phis) ? 0 : 1;
+    result += (rhs.ndirs == ndirs) ? 0 : 1;
+    result += (rhs.exri == exri) ? 0 : 1;
+    result += (rhs.idfc == idfc) ? 0 : 1;
+    result += (rhs.configurations == configurations) ? 0 : 1;
+    if (result == 0) {
+      int offset, chunk_size, xi1;
+      xi1 = rhs._first_xi;
+      // Insert vectors whose size depends on wavelengths
+      offset = xi1 - _first_xi;
+      chunk_size = rhs.xi_block_size;
+      memcpy(vec_jxi + offset, rhs.vec_jxi, chunk_size * sizeof(int));
+      memcpy(vec_ier + offset, rhs.vec_ier, chunk_size * sizeof(short));
+      memcpy(vec_vk + offset, rhs.vec_vk, chunk_size * sizeof(double));
+      memcpy(vec_xi + offset, rhs.vec_xi, chunk_size * sizeof(double));
+      memcpy(vec_fsat + offset, rhs.vec_fsat, chunk_size * sizeof(dcomplex));
+      memcpy(vec_qschut + offset, rhs.vec_qschut, chunk_size * sizeof(double));
+      memcpy(vec_pschut + offset, rhs.vec_pschut, chunk_size * sizeof(double));
+      memcpy(vec_s0magt + offset, rhs.vec_s0magt, chunk_size * sizeof(double));
+      memcpy(vec_scc1 + offset, rhs.vec_scc1, chunk_size * sizeof(double));
+      memcpy(vec_scc2 + offset, rhs.vec_scc2, chunk_size * sizeof(double));
+      memcpy(vec_abc1 + offset, rhs.vec_abc1, chunk_size * sizeof(double));
+      memcpy(vec_abc2 + offset, rhs.vec_abc2, chunk_size * sizeof(double));
+      memcpy(vec_exc1 + offset, rhs.vec_exc1, chunk_size * sizeof(double));
+      memcpy(vec_exc2 + offset, rhs.vec_exc2, chunk_size * sizeof(double));
+      memcpy(vec_albedc1 + offset, rhs.vec_albedc1, chunk_size * sizeof(double));
+      memcpy(vec_albedc2 + offset, rhs.vec_albedc2, chunk_size * sizeof(double));
+      memcpy(vec_qscamc1 + offset, rhs.vec_qscamc1, chunk_size * sizeof(double));
+      memcpy(vec_qscamc2 + offset, rhs.vec_qscamc2, chunk_size * sizeof(double));
+      memcpy(vec_qabsmc1 + offset, rhs.vec_qabsmc1, chunk_size * sizeof(double));
+      memcpy(vec_qabsmc2 + offset, rhs.vec_qabsmc2, chunk_size * sizeof(double));
+      memcpy(vec_qextmc1 + offset, rhs.vec_qextmc1, chunk_size * sizeof(double));
+      memcpy(vec_qextmc2 + offset, rhs.vec_qextmc2, chunk_size * sizeof(double));
+      memcpy(vec_sccrt1 + offset, rhs.vec_sccrt1, chunk_size * sizeof(double));
+      memcpy(vec_sccrt2 + offset, rhs.vec_sccrt2, chunk_size * sizeof(double));
+      memcpy(vec_abcrt1 + offset, rhs.vec_abcrt1, chunk_size * sizeof(double));
+      memcpy(vec_abcrt2 + offset, rhs.vec_abcrt2, chunk_size * sizeof(double));
+      memcpy(vec_excrt1 + offset, rhs.vec_excrt1, chunk_size * sizeof(double));
+      memcpy(vec_excrt2 + offset, rhs.vec_excrt2, chunk_size * sizeof(double));
+      memcpy(vec_fsac11 + offset, rhs.vec_fsac11, chunk_size * sizeof(dcomplex));
+      memcpy(vec_fsac21 + offset, rhs.vec_fsac21, chunk_size * sizeof(dcomplex));
+      memcpy(vec_fsac22 + offset, rhs.vec_fsac22, chunk_size * sizeof(dcomplex));
+      memcpy(vec_fsac12 + offset, rhs.vec_fsac12, chunk_size * sizeof(dcomplex));
+      memcpy(vec_qschuc1 + offset, rhs.vec_qschuc1, chunk_size * sizeof(double));
+      memcpy(vec_qschuc2 + offset, rhs.vec_qschuc2, chunk_size * sizeof(double));
+      memcpy(vec_pschuc1 + offset, rhs.vec_pschuc1, chunk_size * sizeof(double));
+      memcpy(vec_pschuc2 + offset, rhs.vec_pschuc2, chunk_size * sizeof(double));
+      memcpy(vec_s0magc1 + offset, rhs.vec_s0magc1, chunk_size * sizeof(double));
+      memcpy(vec_s0magc2 + offset, rhs.vec_s0magc2, chunk_size * sizeof(double));
+      memcpy(vec_cosavc1 + offset, rhs.vec_cosavc1, chunk_size * sizeof(double));
+      memcpy(vec_cosavc2 + offset, rhs.vec_cosavc2, chunk_size * sizeof(double));
+      memcpy(vec_raprc1 + offset, rhs.vec_raprc1, chunk_size * sizeof(double));
+      memcpy(vec_raprc2 + offset, rhs.vec_raprc2, chunk_size * sizeof(double));
+      memcpy(vec_fkc1 + offset, rhs.vec_fkc1, chunk_size * sizeof(double));
+      memcpy(vec_fkc2 + offset, rhs.vec_fkc2, chunk_size * sizeof(double));
+      // Insert vectors of multiple configuration values per scale
+      offset = (xi1 - _first_xi) * configurations;
+      chunk_size = rhs.xi_block_size * configurations;
+      memcpy(vec_sphere_sizes + offset, rhs.vec_sphere_sizes, chunk_size * sizeof(double));
+      memcpy(vec_sphere_ref_indices + offset, rhs.vec_sphere_ref_indices, chunk_size * sizeof(dcomplex));
+      memcpy(vec_sphere_scs + offset, rhs.vec_sphere_scs, chunk_size * sizeof(double));
+      memcpy(vec_sphere_abs + offset, rhs.vec_sphere_abs, chunk_size * sizeof(double));
+      memcpy(vec_sphere_exs + offset, rhs.vec_sphere_exs, chunk_size * sizeof(double));
+      memcpy(vec_sphere_albs + offset, rhs.vec_sphere_albs, chunk_size * sizeof(double));
+      memcpy(vec_sphere_sqscs + offset, rhs.vec_sphere_sqscs, chunk_size * sizeof(double));
+      memcpy(vec_sphere_sqabs + offset, rhs.vec_sphere_sqabs, chunk_size * sizeof(double));
+      memcpy(vec_sphere_sqexs + offset, rhs.vec_sphere_sqexs, chunk_size * sizeof(double));
+      memcpy(vec_fsas + offset, rhs.vec_fsas, chunk_size * sizeof(dcomplex));
+      memcpy(vec_qschus + offset, rhs.vec_qschus, chunk_size * sizeof(double));
+      memcpy(vec_pschus + offset, rhs.vec_pschus, chunk_size * sizeof(double));
+      memcpy(vec_s0mags + offset, rhs.vec_s0mags, chunk_size * sizeof(double));
+      memcpy(vec_cosavs + offset, rhs.vec_cosavs, chunk_size * sizeof(double));
+      memcpy(vec_raprs + offset, rhs.vec_raprs, chunk_size * sizeof(double));
+      memcpy(vec_tqek1 + offset, rhs.vec_tqek1, chunk_size * sizeof(double));
+      memcpy(vec_tqsk1 + offset, rhs.vec_tqsk1, chunk_size * sizeof(double));
+      memcpy(vec_tqek2 + offset, rhs.vec_tqek2, chunk_size * sizeof(double));
+      memcpy(vec_tqsk2 + offset, rhs.vec_tqsk2, chunk_size * sizeof(double));
+      // Insert vectors of multiple directions per configuration
+      offset = (xi1 - _first_xi) * configurations * ndirs;
+      chunk_size = rhs.xi_block_size * configurations * ndirs;
+      memcpy(vec_dir_sas11 + offset, rhs.vec_dir_sas11, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_sas21 + offset, rhs.vec_dir_sas21, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_sas12 + offset, rhs.vec_dir_sas12, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_sas22 + offset, rhs.vec_dir_sas22, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_muls + 16 * offset, rhs.vec_dir_muls, 16 * chunk_size * sizeof(double));
+      memcpy(vec_dir_mulslr + 16 * offset, rhs.vec_dir_mulslr, 16 * chunk_size * sizeof(double));
+      // Insert vectors whose sizes depend on wavelengths and directions
+      offset = (xi1 - _first_xi) * ndirs;
+      chunk_size = rhs.xi_block_size * ndirs;
+      memcpy(vec_dir_sat11 + offset, rhs.vec_dir_sat11, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_sat21 + offset, rhs.vec_dir_sat21, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_sat12 + offset, rhs.vec_dir_sat12, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_sat22 + offset, rhs.vec_dir_sat22, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_scc1 + offset, rhs.vec_dir_scc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_scc2 + offset, rhs.vec_dir_scc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_abc1 + offset, rhs.vec_dir_abc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_abc2 + offset, rhs.vec_dir_abc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_exc1 + offset, rhs.vec_dir_exc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_exc2 + offset, rhs.vec_dir_exc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_albedc1 + offset, rhs.vec_dir_albedc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_albedc2 + offset, rhs.vec_dir_albedc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_qscc1 + offset, rhs.vec_dir_qscc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_qscc2 + offset, rhs.vec_dir_qscc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_qabc1 + offset, rhs.vec_dir_qabc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_qabc2 + offset, rhs.vec_dir_qabc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_qexc1 + offset, rhs.vec_dir_qexc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_qexc2 + offset, rhs.vec_dir_qexc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_sccrt1 + offset, rhs.vec_dir_sccrt1, chunk_size * sizeof(double));
+      memcpy(vec_dir_sccrt2 + offset, rhs.vec_dir_sccrt2, chunk_size * sizeof(double));
+      memcpy(vec_dir_abcrt1 + offset, rhs.vec_dir_abcrt1, chunk_size * sizeof(double));
+      memcpy(vec_dir_abcrt2 + offset, rhs.vec_dir_abcrt2, chunk_size * sizeof(double));
+      memcpy(vec_dir_excrt1 + offset, rhs.vec_dir_excrt1, chunk_size * sizeof(double));
+      memcpy(vec_dir_excrt2 + offset, rhs.vec_dir_excrt2, chunk_size * sizeof(double));
+      memcpy(vec_dir_fsac11 + offset, rhs.vec_dir_fsac11, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_fsac21 + offset, rhs.vec_dir_fsac21, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_fsac12 + offset, rhs.vec_dir_fsac12, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_fsac22 + offset, rhs.vec_dir_fsac22, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_sac11 + offset, rhs.vec_dir_sac11, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_sac21 + offset, rhs.vec_dir_sac21, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_sac12 + offset, rhs.vec_dir_sac12, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_sac22 + offset, rhs.vec_dir_sac22, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_qschuc1 + offset, rhs.vec_dir_qschuc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_qschuc2 + offset, rhs.vec_dir_qschuc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_pschuc1 + offset, rhs.vec_dir_pschuc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_pschuc2 + offset, rhs.vec_dir_pschuc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_s0magc1 + offset, rhs.vec_dir_s0magc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_s0magc2 + offset, rhs.vec_dir_s0magc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_cosavc1 + offset, rhs.vec_dir_cosavc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_cosavc2 + offset, rhs.vec_dir_cosavc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_raprc1 + offset, rhs.vec_dir_raprc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_raprc2 + offset, rhs.vec_dir_raprc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_flc1 + offset, rhs.vec_dir_flc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_flc2 + offset, rhs.vec_dir_flc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_frc1 + offset, rhs.vec_dir_frc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_frc2 + offset, rhs.vec_dir_frc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_fkc1 + offset, rhs.vec_dir_fkc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_fkc2 + offset, rhs.vec_dir_fkc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_fxc1 + offset, rhs.vec_dir_fxc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_fxc2 + offset, rhs.vec_dir_fxc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_fyc1 + offset, rhs.vec_dir_fyc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_fyc2 + offset, rhs.vec_dir_fyc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_fzc1 + offset, rhs.vec_dir_fzc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_fzc2 + offset, rhs.vec_dir_fzc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqelc1 + offset, rhs.vec_dir_tqelc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqelc2 + offset, rhs.vec_dir_tqelc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqerc1 + offset, rhs.vec_dir_tqerc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqerc2 + offset, rhs.vec_dir_tqerc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqekc1 + offset, rhs.vec_dir_tqekc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqekc2 + offset, rhs.vec_dir_tqekc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqexc1 + offset, rhs.vec_dir_tqexc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqexc2 + offset, rhs.vec_dir_tqexc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqeyc1 + offset, rhs.vec_dir_tqeyc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqeyc2 + offset, rhs.vec_dir_tqeyc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqezc1 + offset, rhs.vec_dir_tqezc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqezc2 + offset, rhs.vec_dir_tqezc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqslc1 + offset, rhs.vec_dir_tqslc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqslc2 + offset, rhs.vec_dir_tqslc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqsrc1 + offset, rhs.vec_dir_tqsrc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqsrc2 + offset, rhs.vec_dir_tqsrc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqskc1 + offset, rhs.vec_dir_tqskc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqskc2 + offset, rhs.vec_dir_tqskc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqsxc1 + offset, rhs.vec_dir_tqsxc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqsxc2 + offset, rhs.vec_dir_tqsxc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqsyc1 + offset, rhs.vec_dir_tqsyc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqsyc2 + offset, rhs.vec_dir_tqsyc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqszc1 + offset, rhs.vec_dir_tqszc1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqszc2 + offset, rhs.vec_dir_tqszc2, chunk_size * sizeof(double));
+      memcpy(vec_dir_mulc + 16 * offset, rhs.vec_dir_mulc, 16 * chunk_size * sizeof(double));
+      memcpy(vec_dir_mulclr + 16 * offset, rhs.vec_dir_mulclr, 16 * chunk_size * sizeof(double));
+    }
   }
   return result;
 }
@@ -2356,13 +2374,13 @@ int ClusterOutputInfo::write_legacy(const std::string &output) {
 #ifdef MPI_VERSION
 int ClusterOutputInfo::mpireceive(const mixMPI *mpidata, int pid) {
   int result = 0;
-  int skip_flag;
+  int flag;
   int chk_nsph, chk_inpol, chk_iavm, chk_isam, chk_num_theta, chk_num_thetas;
   int chk_num_phi, chk_num_phis, chk_ndirs, chk_idfc, chk_configs;
   double chk_exri;
-  MPI_Recv(&skip_flag, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  // Proceed with the rest _only if__ skip_flag==0, else nothing is to be received
-  if (skip_flag == 0) {
+  MPI_Recv(&flag, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+  // Proceed with the rest _only if_ skip_flag==0, else nothing is to be received
+  if (flag == 0) {
     MPI_Recv(&chk_nsph, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
     MPI_Recv(&chk_inpol, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
     MPI_Recv(&chk_iavm, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
@@ -2562,191 +2580,200 @@ int ClusterOutputInfo::mpireceive(const mixMPI *mpidata, int pid) {
   return result;
 }
 
-
 int ClusterOutputInfo::mpisend(const mixMPI *mpidata) {
   int result = 0;
   int chunk_size;
-  // Send output metadata for configuration cross-check
-  MPI_Send(&nsph, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&inpol, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&iavm, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&isam, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&_num_theta, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&_num_thetas, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&_num_phi, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&_num_phis, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&ndirs, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&exri, 1, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&idfc, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&configurations, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  // Wait for process 0 to cross-check the configuration
-  MPI_Recv(&result, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  if (result == 0) {
-    // Process 0 confirmed the consistency of configuration. Send the data.
-    // Send vectors of single values per scale
-    MPI_Send(&_first_xi, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(&xi_block_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_jxi, xi_block_size, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_ier, xi_block_size, MPI_SHORT, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_vk, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_xi, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_fsat, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_qschut, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_pschut, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_s0magt, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_scc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_scc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_abc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_abc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_exc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_exc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_albedc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_albedc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_qscamc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_qscamc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_qabsmc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_qabsmc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_qextmc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_qextmc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_sccrt1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_sccrt2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_abcrt1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_abcrt2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_excrt1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_excrt2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_fsac11, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_fsac21, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_fsac22, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_fsac12, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_qschuc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_qschuc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_pschuc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_pschuc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_s0magc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_s0magc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_cosavc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_cosavc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_raprc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_raprc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_fkc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_fkc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+  if (_skip_flag == 1) {
+    // tell the receiver we are not sending anything
+    int flag = 1;
+    MPI_Send(&flag, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+  }
+  else {
+    // tell the receiver we are sending actual stuff
+    int flag = 0;
+    MPI_Send(&flag, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    // Send output metadata for configuration cross-check
+    MPI_Send(&nsph, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&inpol, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&iavm, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&isam, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&_num_theta, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&_num_thetas, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&_num_phi, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&_num_phis, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&ndirs, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&exri, 1, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&idfc, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&configurations, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    // Wait for process 0 to cross-check the configuration
+    MPI_Recv(&result, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    if (result == 0) {
+      // Process 0 confirmed the consistency of configuration. Send the data.
+      // Send vectors of single values per scale
+      MPI_Send(&_first_xi, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(&xi_block_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_jxi, xi_block_size, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_ier, xi_block_size, MPI_SHORT, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_vk, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_xi, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_fsat, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_qschut, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_pschut, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_s0magt, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_scc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_scc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_abc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_abc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_exc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_exc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_albedc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_albedc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_qscamc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_qscamc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_qabsmc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_qabsmc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_qextmc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_qextmc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_sccrt1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_sccrt2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_abcrt1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_abcrt2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_excrt1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_excrt2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_fsac11, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_fsac21, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_fsac22, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_fsac12, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_qschuc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_qschuc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_pschuc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_pschuc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_s0magc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_s0magc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_cosavc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_cosavc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_raprc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_raprc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_fkc1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_fkc2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
 
-    // Send vectors of multiple configuration values per scale
-    chunk_size = xi_block_size * configurations;
-    MPI_Send(&chunk_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_sphere_sizes, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_sphere_ref_indices, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_sphere_scs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_sphere_abs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_sphere_exs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_sphere_albs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_sphere_sqscs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_sphere_sqabs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_sphere_sqexs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_fsas, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_qschus, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_pschus, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_s0mags, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_cosavs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_raprs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_tqek1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_tqsk1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_tqek2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_tqsk2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      // Send vectors of multiple configuration values per scale
+      chunk_size = xi_block_size * configurations;
+      MPI_Send(&chunk_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_sphere_sizes, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_sphere_ref_indices, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_sphere_scs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_sphere_abs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_sphere_exs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_sphere_albs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_sphere_sqscs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_sphere_sqabs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_sphere_sqexs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_fsas, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_qschus, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_pschus, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_s0mags, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_cosavs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_raprs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_tqek1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_tqsk1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_tqek2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_tqsk2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
 
-    // Send vectors whose sizes depend on directions and configurations.
-    chunk_size = ndirs * configurations * xi_block_size;
-    MPI_Send(&chunk_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sas11, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sas21, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sas12, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sas22, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_muls, 16 * chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_mulslr, 16 * chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      // Send vectors whose sizes depend on directions and configurations.
+      chunk_size = ndirs * configurations * xi_block_size;
+      MPI_Send(&chunk_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sas11, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sas21, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sas12, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sas22, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_muls, 16 * chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_mulslr, 16 * chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
 
-    // Send vectors whose sizes depend on directions and scales.
-    chunk_size = xi_block_size * ndirs;
-    MPI_Send(&chunk_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sat11, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sat21, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sat12, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sat22, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_scc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_scc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_abc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_abc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_exc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_exc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_albedc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_albedc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_qscc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_qscc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_qabc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_qabc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_qexc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_qexc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sccrt1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sccrt2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_abcrt1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_abcrt2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_excrt1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_excrt2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fsac11, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fsac21, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fsac12, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fsac22, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sac11, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sac21, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sac12, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sac22, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_qschuc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_qschuc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_pschuc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_pschuc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_s0magc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_s0magc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_cosavc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_cosavc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_raprc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_raprc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_flc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_flc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_frc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_frc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fkc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fkc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fxc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fxc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fyc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fyc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fzc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fzc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqelc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqelc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqerc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqerc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqekc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqekc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqexc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqexc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqeyc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqeyc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqezc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqezc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqslc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqslc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqsrc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqsrc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqskc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqskc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqsxc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqsxc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqsyc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqsyc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqszc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqszc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_mulc, 16 * chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_mulclr, 16 * chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      // Send vectors whose sizes depend on directions and scales.
+      chunk_size = xi_block_size * ndirs;
+      MPI_Send(&chunk_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sat11, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sat21, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sat12, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sat22, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_scc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_scc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_abc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_abc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_exc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_exc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_albedc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_albedc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_qscc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_qscc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_qabc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_qabc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_qexc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_qexc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sccrt1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sccrt2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_abcrt1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_abcrt2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_excrt1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_excrt2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fsac11, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fsac21, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fsac12, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fsac22, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sac11, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sac21, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sac12, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sac22, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_qschuc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_qschuc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_pschuc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_pschuc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_s0magc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_s0magc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_cosavc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_cosavc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_raprc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_raprc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_flc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_flc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_frc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_frc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fkc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fkc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fxc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fxc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fyc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fyc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fzc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fzc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqelc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqelc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqerc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqerc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqekc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqekc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqexc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqexc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqeyc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqeyc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqezc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqezc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqslc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqslc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqsrc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqsrc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqskc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqskc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqsxc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqsxc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqsyc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqsyc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqszc1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqszc2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_mulc, 16 * chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_mulclr, 16 * chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+    }
   }
   return result;
 }
@@ -2758,6 +2785,7 @@ InclusionOutputInfo::InclusionOutputInfo(
   ScattererConfiguration *sc, GeometryConfiguration *gc,
   const mixMPI *mpidata, int first_xi, int xi_length
 ) {
+  _skip_flag = 0;
   nsph = gc->number_of_spheres;
   li = gc->li;
   le = gc->le;
@@ -2946,6 +2974,7 @@ InclusionOutputInfo::InclusionOutputInfo(const std::string &hdf5_name) {
   HDFFile *hdf_file = new HDFFile(hdf5_name, flags);
   herr_t status = hdf_file->get_status();
   string str_name, str_type;
+  _skip_flag = 0;
   if (status == 0) {
     status = hdf_file->read("NSPH", "INT32_(1)", &nsph);
     status = hdf_file->read("LI", "INT32_(1)", &li);
@@ -3260,127 +3289,141 @@ InclusionOutputInfo::InclusionOutputInfo(const std::string &hdf5_name) {
   }
 }
 
+InclusionOutputInfo::InclusionOutputInfo(const int flag) {
+  /*
+    create a dummy placeholder just to know I should skip MPI_Send and MPI_Recv
+  */
+  if (flag == 1) {
+    _skip_flag = 1;
+  } else {
+    UnrecognizedOutputInfo ex(flag);
+    throw ex;
+  }
+}
+
 InclusionOutputInfo::~InclusionOutputInfo() {
-  delete[] vec_x_coords;
-  delete[] vec_y_coords;
-  delete[] vec_z_coords;
-  delete[] vec_jxi;
-  delete[] vec_ier;
-  delete[] vec_vk;
-  delete[] vec_xi;
-  delete[] vec_sphere_sizes;
-  delete[] vec_sphere_ref_indices;
-  delete[] vec_scs1;
-  delete[] vec_scs2;
-  delete[] vec_abs1;
-  delete[] vec_abs2;
-  delete[] vec_exs1;
-  delete[] vec_exs2;
-  delete[] vec_albeds1;
-  delete[] vec_albeds2;
-  delete[] vec_scsrt1;
-  delete[] vec_scsrt2;
-  delete[] vec_absrt1;
-  delete[] vec_absrt2;
-  delete[] vec_exsrt1;
-  delete[] vec_exsrt2;
-  delete[] vec_qschu1;
-  delete[] vec_qschu2;
-  delete[] vec_pschu1;
-  delete[] vec_pschu2;
-  delete[] vec_s0mag1;
-  delete[] vec_s0mag2;
-  delete[] vec_cosav1;
-  delete[] vec_cosav2;
-  delete[] vec_raprs1;
-  delete[] vec_raprs2;
-  delete[] vec_fk1;
-  delete[] vec_fk2;
-  delete[] vec_fsas11;
-  delete[] vec_fsas21;
-  delete[] vec_fsas22;
-  delete[] vec_fsas12;
-  delete[] vec_dir_tidg;
-  delete[] vec_dir_pidg;
-  delete[] vec_dir_tsdg;
-  delete[] vec_dir_psdg;
-  delete[] vec_dir_scand;
-  delete[] vec_dir_cfmp;
-  delete[] vec_dir_sfmp;
-  delete[] vec_dir_cfsp;
-  delete[] vec_dir_sfsp;
-  delete[] vec_dir_un;
-  delete[] vec_dir_uns;
-  delete[] vec_dir_scs1;
-  delete[] vec_dir_scs2;
-  delete[] vec_dir_abs1;
-  delete[] vec_dir_abs2;
-  delete[] vec_dir_exs1;
-  delete[] vec_dir_exs2;
-  delete[] vec_dir_albeds1;
-  delete[] vec_dir_albeds2;
-  delete[] vec_dir_scsrt1;
-  delete[] vec_dir_scsrt2;
-  delete[] vec_dir_absrt1;
-  delete[] vec_dir_absrt2;
-  delete[] vec_dir_exsrt1;
-  delete[] vec_dir_exsrt2;
-  delete[] vec_dir_fsas11;
-  delete[] vec_dir_fsas21;
-  delete[] vec_dir_fsas12;
-  delete[] vec_dir_fsas22;
-  delete[] vec_dir_sas11;
-  delete[] vec_dir_sas21;
-  delete[] vec_dir_sas12;
-  delete[] vec_dir_sas22;
-  delete[] vec_dir_qschu1;
-  delete[] vec_dir_qschu2;
-  delete[] vec_dir_pschu1;
-  delete[] vec_dir_pschu2;
-  delete[] vec_dir_s0mag1;
-  delete[] vec_dir_s0mag2;
-  delete[] vec_dir_cosav1;
-  delete[] vec_dir_cosav2;
-  delete[] vec_dir_rapr1;
-  delete[] vec_dir_rapr2;
-  delete[] vec_dir_fl1;
-  delete[] vec_dir_fl2;
-  delete[] vec_dir_fr1;
-  delete[] vec_dir_fr2;
-  delete[] vec_dir_fk1;
-  delete[] vec_dir_fk2;
-  delete[] vec_dir_fx1;
-  delete[] vec_dir_fx2;
-  delete[] vec_dir_fy1;
-  delete[] vec_dir_fy2;
-  delete[] vec_dir_fz1;
-  delete[] vec_dir_fz2;
-  delete[] vec_dir_tqel1;
-  delete[] vec_dir_tqel2;
-  delete[] vec_dir_tqer1;
-  delete[] vec_dir_tqer2;
-  delete[] vec_dir_tqek1;
-  delete[] vec_dir_tqek2;
-  delete[] vec_dir_tqex1;
-  delete[] vec_dir_tqex2;
-  delete[] vec_dir_tqey1;
-  delete[] vec_dir_tqey2;
-  delete[] vec_dir_tqez1;
-  delete[] vec_dir_tqez2;
-  delete[] vec_dir_tqsl1;
-  delete[] vec_dir_tqsl2;
-  delete[] vec_dir_tqsr1;
-  delete[] vec_dir_tqsr2;
-  delete[] vec_dir_tqsk1;
-  delete[] vec_dir_tqsk2;
-  delete[] vec_dir_tqsx1;
-  delete[] vec_dir_tqsx2;
-  delete[] vec_dir_tqsy1;
-  delete[] vec_dir_tqsy2;
-  delete[] vec_dir_tqsz1;
-  delete[] vec_dir_tqsz2;
-  delete[] vec_dir_mull;
-  delete[] vec_dir_mulllr;
+  if (_skip_flag != 1) {
+    delete[] vec_x_coords;
+    delete[] vec_y_coords;
+    delete[] vec_z_coords;
+    delete[] vec_jxi;
+    delete[] vec_ier;
+    delete[] vec_vk;
+    delete[] vec_xi;
+    delete[] vec_sphere_sizes;
+    delete[] vec_sphere_ref_indices;
+    delete[] vec_scs1;
+    delete[] vec_scs2;
+    delete[] vec_abs1;
+    delete[] vec_abs2;
+    delete[] vec_exs1;
+    delete[] vec_exs2;
+    delete[] vec_albeds1;
+    delete[] vec_albeds2;
+    delete[] vec_scsrt1;
+    delete[] vec_scsrt2;
+    delete[] vec_absrt1;
+    delete[] vec_absrt2;
+    delete[] vec_exsrt1;
+    delete[] vec_exsrt2;
+    delete[] vec_qschu1;
+    delete[] vec_qschu2;
+    delete[] vec_pschu1;
+    delete[] vec_pschu2;
+    delete[] vec_s0mag1;
+    delete[] vec_s0mag2;
+    delete[] vec_cosav1;
+    delete[] vec_cosav2;
+    delete[] vec_raprs1;
+    delete[] vec_raprs2;
+    delete[] vec_fk1;
+    delete[] vec_fk2;
+    delete[] vec_fsas11;
+    delete[] vec_fsas21;
+    delete[] vec_fsas22;
+    delete[] vec_fsas12;
+    delete[] vec_dir_tidg;
+    delete[] vec_dir_pidg;
+    delete[] vec_dir_tsdg;
+    delete[] vec_dir_psdg;
+    delete[] vec_dir_scand;
+    delete[] vec_dir_cfmp;
+    delete[] vec_dir_sfmp;
+    delete[] vec_dir_cfsp;
+    delete[] vec_dir_sfsp;
+    delete[] vec_dir_un;
+    delete[] vec_dir_uns;
+    delete[] vec_dir_scs1;
+    delete[] vec_dir_scs2;
+    delete[] vec_dir_abs1;
+    delete[] vec_dir_abs2;
+    delete[] vec_dir_exs1;
+    delete[] vec_dir_exs2;
+    delete[] vec_dir_albeds1;
+    delete[] vec_dir_albeds2;
+    delete[] vec_dir_scsrt1;
+    delete[] vec_dir_scsrt2;
+    delete[] vec_dir_absrt1;
+    delete[] vec_dir_absrt2;
+    delete[] vec_dir_exsrt1;
+    delete[] vec_dir_exsrt2;
+    delete[] vec_dir_fsas11;
+    delete[] vec_dir_fsas21;
+    delete[] vec_dir_fsas12;
+    delete[] vec_dir_fsas22;
+    delete[] vec_dir_sas11;
+    delete[] vec_dir_sas21;
+    delete[] vec_dir_sas12;
+    delete[] vec_dir_sas22;
+    delete[] vec_dir_qschu1;
+    delete[] vec_dir_qschu2;
+    delete[] vec_dir_pschu1;
+    delete[] vec_dir_pschu2;
+    delete[] vec_dir_s0mag1;
+    delete[] vec_dir_s0mag2;
+    delete[] vec_dir_cosav1;
+    delete[] vec_dir_cosav2;
+    delete[] vec_dir_rapr1;
+    delete[] vec_dir_rapr2;
+    delete[] vec_dir_fl1;
+    delete[] vec_dir_fl2;
+    delete[] vec_dir_fr1;
+    delete[] vec_dir_fr2;
+    delete[] vec_dir_fk1;
+    delete[] vec_dir_fk2;
+    delete[] vec_dir_fx1;
+    delete[] vec_dir_fx2;
+    delete[] vec_dir_fy1;
+    delete[] vec_dir_fy2;
+    delete[] vec_dir_fz1;
+    delete[] vec_dir_fz2;
+    delete[] vec_dir_tqel1;
+    delete[] vec_dir_tqel2;
+    delete[] vec_dir_tqer1;
+    delete[] vec_dir_tqer2;
+    delete[] vec_dir_tqek1;
+    delete[] vec_dir_tqek2;
+    delete[] vec_dir_tqex1;
+    delete[] vec_dir_tqex2;
+    delete[] vec_dir_tqey1;
+    delete[] vec_dir_tqey2;
+    delete[] vec_dir_tqez1;
+    delete[] vec_dir_tqez2;
+    delete[] vec_dir_tqsl1;
+    delete[] vec_dir_tqsl2;
+    delete[] vec_dir_tqsr1;
+    delete[] vec_dir_tqsr2;
+    delete[] vec_dir_tqsk1;
+    delete[] vec_dir_tqsk2;
+    delete[] vec_dir_tqsx1;
+    delete[] vec_dir_tqsx2;
+    delete[] vec_dir_tqsy1;
+    delete[] vec_dir_tqsy2;
+    delete[] vec_dir_tqsz1;
+    delete[] vec_dir_tqsz2;
+    delete[] vec_dir_mull;
+    delete[] vec_dir_mulllr;
+  }
 }
 
 long InclusionOutputInfo::compute_size() {
@@ -3439,138 +3482,140 @@ long InclusionOutputInfo::compute_size(
 
 int InclusionOutputInfo::insert(const InclusionOutputInfo &rhs) {
   int result = 0;
-  result += (rhs.nsph == nsph) ? 0 : 1;
-  result += (rhs.inpol == inpol) ? 0 : 1;
-  result += (rhs.iavm == iavm) ? 0 : 1;
-  result += (rhs.isam == isam) ? 0 : 1;
-  result += (rhs._num_theta == _num_theta) ? 0 : 1;
-  result += (rhs._num_thetas == _num_thetas) ? 0 : 1;
-  result += (rhs._num_phi == _num_phi) ? 0 : 1;
-  result += (rhs._num_phis == _num_phis) ? 0 : 1;
-  result += (rhs.ndirs == ndirs) ? 0 : 1;
-  result += (rhs.exri == exri) ? 0 : 1;
-  result += (rhs.idfc == idfc) ? 0 : 1;
-  result += (rhs.configurations == configurations) ? 0 : 1;
-  if (result == 0) {
-    int offset, chunk_size, xi1;
-    xi1 = rhs._first_xi;
-    // Insert vectors whose size depends on wavelengths
-    offset = xi1 - _first_xi;
-    chunk_size = rhs.xi_block_size;
-    memcpy(vec_jxi + offset, rhs.vec_jxi, chunk_size * sizeof(int));
-    memcpy(vec_ier + offset, rhs.vec_ier, chunk_size * sizeof(short));
-    memcpy(vec_vk + offset, rhs.vec_vk, chunk_size * sizeof(double));
-    memcpy(vec_xi + offset, rhs.vec_xi, chunk_size * sizeof(double));
-    memcpy(vec_scs1 + offset, rhs.vec_scs1, chunk_size * sizeof(double));
-    memcpy(vec_scs2 + offset, rhs.vec_scs2, chunk_size * sizeof(double));
-    memcpy(vec_abs1 + offset, rhs.vec_abs1, chunk_size * sizeof(double));
-    memcpy(vec_abs2 + offset, rhs.vec_abs2, chunk_size * sizeof(double));
-    memcpy(vec_exs1 + offset, rhs.vec_exs1, chunk_size * sizeof(double));
-    memcpy(vec_exs2 + offset, rhs.vec_exs2, chunk_size * sizeof(double));
-    memcpy(vec_albeds1 + offset, rhs.vec_albeds1, chunk_size * sizeof(double));
-    memcpy(vec_albeds2 + offset, rhs.vec_albeds2, chunk_size * sizeof(double));
-    memcpy(vec_scsrt1 + offset, rhs.vec_scsrt1, chunk_size * sizeof(double));
-    memcpy(vec_scsrt2 + offset, rhs.vec_scsrt2, chunk_size * sizeof(double));
-    memcpy(vec_absrt1 + offset, rhs.vec_absrt1, chunk_size * sizeof(double));
-    memcpy(vec_absrt2 + offset, rhs.vec_absrt2, chunk_size * sizeof(double));
-    memcpy(vec_exsrt1 + offset, rhs.vec_exsrt1, chunk_size * sizeof(double));
-    memcpy(vec_exsrt2 + offset, rhs.vec_exsrt2, chunk_size * sizeof(double));
-    memcpy(vec_qschu1 + offset, rhs.vec_qschu1, chunk_size * sizeof(double));
-    memcpy(vec_qschu2 + offset, rhs.vec_qschu2, chunk_size * sizeof(double));
-    memcpy(vec_pschu1 + offset, rhs.vec_pschu1, chunk_size * sizeof(double));
-    memcpy(vec_pschu2 + offset, rhs.vec_pschu2, chunk_size * sizeof(double));
-    memcpy(vec_s0mag1 + offset, rhs.vec_s0mag1, chunk_size * sizeof(double));
-    memcpy(vec_s0mag2 + offset, rhs.vec_s0mag2, chunk_size * sizeof(double));
-    memcpy(vec_cosav1 + offset, rhs.vec_cosav1, chunk_size * sizeof(double));
-    memcpy(vec_cosav2 + offset, rhs.vec_cosav2, chunk_size * sizeof(double));
-    memcpy(vec_raprs1 + offset, rhs.vec_raprs1, chunk_size * sizeof(double));
-    memcpy(vec_raprs2 + offset, rhs.vec_raprs2, chunk_size * sizeof(double));
-    memcpy(vec_fk1 + offset, rhs.vec_fk1, chunk_size * sizeof(double));
-    memcpy(vec_fk2 + offset, rhs.vec_fk2, chunk_size * sizeof(double));
-    memcpy(vec_fsas11 + offset, rhs.vec_fsas11, chunk_size * sizeof(dcomplex));
-    memcpy(vec_fsas21 + offset, rhs.vec_fsas21, chunk_size * sizeof(dcomplex));
-    memcpy(vec_fsas22 + offset, rhs.vec_fsas22, chunk_size * sizeof(dcomplex));
-    memcpy(vec_fsas12 + offset, rhs.vec_fsas12, chunk_size * sizeof(dcomplex));
+  if (rhs.skip_flag != 1) {
+    result += (rhs.nsph == nsph) ? 0 : 1;
+    result += (rhs.inpol == inpol) ? 0 : 1;
+    result += (rhs.iavm == iavm) ? 0 : 1;
+    result += (rhs.isam == isam) ? 0 : 1;
+    result += (rhs._num_theta == _num_theta) ? 0 : 1;
+    result += (rhs._num_thetas == _num_thetas) ? 0 : 1;
+    result += (rhs._num_phi == _num_phi) ? 0 : 1;
+    result += (rhs._num_phis == _num_phis) ? 0 : 1;
+    result += (rhs.ndirs == ndirs) ? 0 : 1;
+    result += (rhs.exri == exri) ? 0 : 1;
+    result += (rhs.idfc == idfc) ? 0 : 1;
+    result += (rhs.configurations == configurations) ? 0 : 1;
+    if (result == 0) {
+      int offset, chunk_size, xi1;
+      xi1 = rhs._first_xi;
+      // Insert vectors whose size depends on wavelengths
+      offset = xi1 - _first_xi;
+      chunk_size = rhs.xi_block_size;
+      memcpy(vec_jxi + offset, rhs.vec_jxi, chunk_size * sizeof(int));
+      memcpy(vec_ier + offset, rhs.vec_ier, chunk_size * sizeof(short));
+      memcpy(vec_vk + offset, rhs.vec_vk, chunk_size * sizeof(double));
+      memcpy(vec_xi + offset, rhs.vec_xi, chunk_size * sizeof(double));
+      memcpy(vec_scs1 + offset, rhs.vec_scs1, chunk_size * sizeof(double));
+      memcpy(vec_scs2 + offset, rhs.vec_scs2, chunk_size * sizeof(double));
+      memcpy(vec_abs1 + offset, rhs.vec_abs1, chunk_size * sizeof(double));
+      memcpy(vec_abs2 + offset, rhs.vec_abs2, chunk_size * sizeof(double));
+      memcpy(vec_exs1 + offset, rhs.vec_exs1, chunk_size * sizeof(double));
+      memcpy(vec_exs2 + offset, rhs.vec_exs2, chunk_size * sizeof(double));
+      memcpy(vec_albeds1 + offset, rhs.vec_albeds1, chunk_size * sizeof(double));
+      memcpy(vec_albeds2 + offset, rhs.vec_albeds2, chunk_size * sizeof(double));
+      memcpy(vec_scsrt1 + offset, rhs.vec_scsrt1, chunk_size * sizeof(double));
+      memcpy(vec_scsrt2 + offset, rhs.vec_scsrt2, chunk_size * sizeof(double));
+      memcpy(vec_absrt1 + offset, rhs.vec_absrt1, chunk_size * sizeof(double));
+      memcpy(vec_absrt2 + offset, rhs.vec_absrt2, chunk_size * sizeof(double));
+      memcpy(vec_exsrt1 + offset, rhs.vec_exsrt1, chunk_size * sizeof(double));
+      memcpy(vec_exsrt2 + offset, rhs.vec_exsrt2, chunk_size * sizeof(double));
+      memcpy(vec_qschu1 + offset, rhs.vec_qschu1, chunk_size * sizeof(double));
+      memcpy(vec_qschu2 + offset, rhs.vec_qschu2, chunk_size * sizeof(double));
+      memcpy(vec_pschu1 + offset, rhs.vec_pschu1, chunk_size * sizeof(double));
+      memcpy(vec_pschu2 + offset, rhs.vec_pschu2, chunk_size * sizeof(double));
+      memcpy(vec_s0mag1 + offset, rhs.vec_s0mag1, chunk_size * sizeof(double));
+      memcpy(vec_s0mag2 + offset, rhs.vec_s0mag2, chunk_size * sizeof(double));
+      memcpy(vec_cosav1 + offset, rhs.vec_cosav1, chunk_size * sizeof(double));
+      memcpy(vec_cosav2 + offset, rhs.vec_cosav2, chunk_size * sizeof(double));
+      memcpy(vec_raprs1 + offset, rhs.vec_raprs1, chunk_size * sizeof(double));
+      memcpy(vec_raprs2 + offset, rhs.vec_raprs2, chunk_size * sizeof(double));
+      memcpy(vec_fk1 + offset, rhs.vec_fk1, chunk_size * sizeof(double));
+      memcpy(vec_fk2 + offset, rhs.vec_fk2, chunk_size * sizeof(double));
+      memcpy(vec_fsas11 + offset, rhs.vec_fsas11, chunk_size * sizeof(dcomplex));
+      memcpy(vec_fsas21 + offset, rhs.vec_fsas21, chunk_size * sizeof(dcomplex));
+      memcpy(vec_fsas22 + offset, rhs.vec_fsas22, chunk_size * sizeof(dcomplex));
+      memcpy(vec_fsas12 + offset, rhs.vec_fsas12, chunk_size * sizeof(dcomplex));
     
-    // Insert vectors whose sizes depend on configurations
-    offset = (xi1 - _first_xi) * (configurations + 1);
-    chunk_size = rhs.xi_block_size * (configurations + 1);
-    memcpy(vec_sphere_sizes + offset, rhs.vec_sphere_sizes, chunk_size * sizeof(double));
-    memcpy(vec_sphere_ref_indices + offset, rhs.vec_sphere_ref_indices, chunk_size * sizeof(dcomplex));
+      // Insert vectors whose sizes depend on configurations
+      offset = (xi1 - _first_xi) * (configurations + 1);
+      chunk_size = rhs.xi_block_size * (configurations + 1);
+      memcpy(vec_sphere_sizes + offset, rhs.vec_sphere_sizes, chunk_size * sizeof(double));
+      memcpy(vec_sphere_ref_indices + offset, rhs.vec_sphere_ref_indices, chunk_size * sizeof(dcomplex));
 
-    // Insert vectors whose sizes depend on directions and wavelengths
-    offset = (xi1 - _first_xi) * ndirs;
-    chunk_size = rhs.xi_block_size * ndirs;
-    memcpy(vec_dir_scs1 + offset, rhs.vec_dir_scs1, chunk_size * sizeof(double));
-    memcpy(vec_dir_scs2 + offset, rhs.vec_dir_scs2, chunk_size * sizeof(double));
-    memcpy(vec_dir_abs1 + offset, rhs.vec_dir_abs1, chunk_size * sizeof(double));
-    memcpy(vec_dir_abs2 + offset, rhs.vec_dir_abs2, chunk_size * sizeof(double));
-    memcpy(vec_dir_exs1 + offset, rhs.vec_dir_exs1, chunk_size * sizeof(double));
-    memcpy(vec_dir_exs2 + offset, rhs.vec_dir_exs2, chunk_size * sizeof(double));
-    memcpy(vec_dir_albeds1 + offset, rhs.vec_dir_albeds1, chunk_size * sizeof(double));
-    memcpy(vec_dir_albeds2 + offset, rhs.vec_dir_albeds2, chunk_size * sizeof(double));
-    memcpy(vec_dir_scsrt1 + offset, rhs.vec_dir_scsrt1, chunk_size * sizeof(double));
-    memcpy(vec_dir_scsrt2 + offset, rhs.vec_dir_scsrt2, chunk_size * sizeof(double));
-    memcpy(vec_dir_absrt1 + offset, rhs.vec_dir_absrt1, chunk_size * sizeof(double));
-    memcpy(vec_dir_absrt2 + offset, rhs.vec_dir_absrt2, chunk_size * sizeof(double));
-    memcpy(vec_dir_exsrt1 + offset, rhs.vec_dir_exsrt1, chunk_size * sizeof(double));
-    memcpy(vec_dir_exsrt2 + offset, rhs.vec_dir_exsrt2, chunk_size * sizeof(double));
-    memcpy(vec_dir_fsas11 + offset, rhs.vec_dir_fsas11, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_fsas21 + offset, rhs.vec_dir_fsas21, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_fsas12 + offset, rhs.vec_dir_fsas12, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_fsas22 + offset, rhs.vec_dir_fsas22, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_sas11 + offset, rhs.vec_dir_sas11, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_sas21 + offset, rhs.vec_dir_sas21, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_sas12 + offset, rhs.vec_dir_sas12, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_sas22 + offset, rhs.vec_dir_sas22, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_qschu1 + offset, rhs.vec_dir_qschu1, chunk_size * sizeof(double));
-    memcpy(vec_dir_qschu2 + offset, rhs.vec_dir_qschu2, chunk_size * sizeof(double));
-    memcpy(vec_dir_pschu1 + offset, rhs.vec_dir_pschu1, chunk_size * sizeof(double));
-    memcpy(vec_dir_pschu2 + offset, rhs.vec_dir_pschu2, chunk_size * sizeof(double));
-    memcpy(vec_dir_s0mag1 + offset, rhs.vec_dir_s0mag1, chunk_size * sizeof(double));
-    memcpy(vec_dir_s0mag2 + offset, rhs.vec_dir_s0mag2, chunk_size * sizeof(double));
-    memcpy(vec_dir_cosav1 + offset, rhs.vec_dir_cosav1, chunk_size * sizeof(double));
-    memcpy(vec_dir_cosav2 + offset, rhs.vec_dir_cosav2, chunk_size * sizeof(double));
-    memcpy(vec_dir_rapr1 + offset, rhs.vec_dir_rapr1, chunk_size * sizeof(double));
-    memcpy(vec_dir_rapr2 + offset, rhs.vec_dir_rapr2, chunk_size * sizeof(double));
-    memcpy(vec_dir_fl1 + offset, rhs.vec_dir_fl1, chunk_size * sizeof(double));
-    memcpy(vec_dir_fl2 + offset, rhs.vec_dir_fl2, chunk_size * sizeof(double));
-    memcpy(vec_dir_fr1 + offset, rhs.vec_dir_fr1, chunk_size * sizeof(double));
-    memcpy(vec_dir_fr2 + offset, rhs.vec_dir_fr2, chunk_size * sizeof(double));
-    memcpy(vec_dir_fk1 + offset, rhs.vec_dir_fk1, chunk_size * sizeof(double));
-    memcpy(vec_dir_fk2 + offset, rhs.vec_dir_fk2, chunk_size * sizeof(double));
-    memcpy(vec_dir_fx1 + offset, rhs.vec_dir_fx1, chunk_size * sizeof(double));
-    memcpy(vec_dir_fx2 + offset, rhs.vec_dir_fx2, chunk_size * sizeof(double));
-    memcpy(vec_dir_fy1 + offset, rhs.vec_dir_fy1, chunk_size * sizeof(double));
-    memcpy(vec_dir_fy2 + offset, rhs.vec_dir_fy2, chunk_size * sizeof(double));
-    memcpy(vec_dir_fz1 + offset, rhs.vec_dir_fz1, chunk_size * sizeof(double));
-    memcpy(vec_dir_fz2 + offset, rhs.vec_dir_fz2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqel1 + offset, rhs.vec_dir_tqel1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqel2 + offset, rhs.vec_dir_tqel2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqer1 + offset, rhs.vec_dir_tqer1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqer2 + offset, rhs.vec_dir_tqer2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqek1 + offset, rhs.vec_dir_tqek1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqek2 + offset, rhs.vec_dir_tqek2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqex1 + offset, rhs.vec_dir_tqex1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqex2 + offset, rhs.vec_dir_tqex2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqey1 + offset, rhs.vec_dir_tqey1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqey2 + offset, rhs.vec_dir_tqey2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqez1 + offset, rhs.vec_dir_tqez1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqez2 + offset, rhs.vec_dir_tqez2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqsl1 + offset, rhs.vec_dir_tqsl1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqsl2 + offset, rhs.vec_dir_tqsl2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqsr1 + offset, rhs.vec_dir_tqsr1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqsr2 + offset, rhs.vec_dir_tqsr2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqsk1 + offset, rhs.vec_dir_tqsk1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqsk2 + offset, rhs.vec_dir_tqsk2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqsx1 + offset, rhs.vec_dir_tqsx1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqsx2 + offset, rhs.vec_dir_tqsx2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqsy1 + offset, rhs.vec_dir_tqsy1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqsy2 + offset, rhs.vec_dir_tqsy2, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqsz1 + offset, rhs.vec_dir_tqsz1, chunk_size * sizeof(double));
-    memcpy(vec_dir_tqsz2 + offset, rhs.vec_dir_tqsz2, chunk_size * sizeof(double));
-    memcpy(vec_dir_mull + 16 * offset, rhs.vec_dir_mull, 16 * chunk_size * sizeof(double));
-    memcpy(vec_dir_mulllr + 16 * offset, rhs.vec_dir_mulllr, 16 * chunk_size * sizeof(double));
+      // Insert vectors whose sizes depend on directions and wavelengths
+      offset = (xi1 - _first_xi) * ndirs;
+      chunk_size = rhs.xi_block_size * ndirs;
+      memcpy(vec_dir_scs1 + offset, rhs.vec_dir_scs1, chunk_size * sizeof(double));
+      memcpy(vec_dir_scs2 + offset, rhs.vec_dir_scs2, chunk_size * sizeof(double));
+      memcpy(vec_dir_abs1 + offset, rhs.vec_dir_abs1, chunk_size * sizeof(double));
+      memcpy(vec_dir_abs2 + offset, rhs.vec_dir_abs2, chunk_size * sizeof(double));
+      memcpy(vec_dir_exs1 + offset, rhs.vec_dir_exs1, chunk_size * sizeof(double));
+      memcpy(vec_dir_exs2 + offset, rhs.vec_dir_exs2, chunk_size * sizeof(double));
+      memcpy(vec_dir_albeds1 + offset, rhs.vec_dir_albeds1, chunk_size * sizeof(double));
+      memcpy(vec_dir_albeds2 + offset, rhs.vec_dir_albeds2, chunk_size * sizeof(double));
+      memcpy(vec_dir_scsrt1 + offset, rhs.vec_dir_scsrt1, chunk_size * sizeof(double));
+      memcpy(vec_dir_scsrt2 + offset, rhs.vec_dir_scsrt2, chunk_size * sizeof(double));
+      memcpy(vec_dir_absrt1 + offset, rhs.vec_dir_absrt1, chunk_size * sizeof(double));
+      memcpy(vec_dir_absrt2 + offset, rhs.vec_dir_absrt2, chunk_size * sizeof(double));
+      memcpy(vec_dir_exsrt1 + offset, rhs.vec_dir_exsrt1, chunk_size * sizeof(double));
+      memcpy(vec_dir_exsrt2 + offset, rhs.vec_dir_exsrt2, chunk_size * sizeof(double));
+      memcpy(vec_dir_fsas11 + offset, rhs.vec_dir_fsas11, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_fsas21 + offset, rhs.vec_dir_fsas21, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_fsas12 + offset, rhs.vec_dir_fsas12, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_fsas22 + offset, rhs.vec_dir_fsas22, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_sas11 + offset, rhs.vec_dir_sas11, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_sas21 + offset, rhs.vec_dir_sas21, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_sas12 + offset, rhs.vec_dir_sas12, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_sas22 + offset, rhs.vec_dir_sas22, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_qschu1 + offset, rhs.vec_dir_qschu1, chunk_size * sizeof(double));
+      memcpy(vec_dir_qschu2 + offset, rhs.vec_dir_qschu2, chunk_size * sizeof(double));
+      memcpy(vec_dir_pschu1 + offset, rhs.vec_dir_pschu1, chunk_size * sizeof(double));
+      memcpy(vec_dir_pschu2 + offset, rhs.vec_dir_pschu2, chunk_size * sizeof(double));
+      memcpy(vec_dir_s0mag1 + offset, rhs.vec_dir_s0mag1, chunk_size * sizeof(double));
+      memcpy(vec_dir_s0mag2 + offset, rhs.vec_dir_s0mag2, chunk_size * sizeof(double));
+      memcpy(vec_dir_cosav1 + offset, rhs.vec_dir_cosav1, chunk_size * sizeof(double));
+      memcpy(vec_dir_cosav2 + offset, rhs.vec_dir_cosav2, chunk_size * sizeof(double));
+      memcpy(vec_dir_rapr1 + offset, rhs.vec_dir_rapr1, chunk_size * sizeof(double));
+      memcpy(vec_dir_rapr2 + offset, rhs.vec_dir_rapr2, chunk_size * sizeof(double));
+      memcpy(vec_dir_fl1 + offset, rhs.vec_dir_fl1, chunk_size * sizeof(double));
+      memcpy(vec_dir_fl2 + offset, rhs.vec_dir_fl2, chunk_size * sizeof(double));
+      memcpy(vec_dir_fr1 + offset, rhs.vec_dir_fr1, chunk_size * sizeof(double));
+      memcpy(vec_dir_fr2 + offset, rhs.vec_dir_fr2, chunk_size * sizeof(double));
+      memcpy(vec_dir_fk1 + offset, rhs.vec_dir_fk1, chunk_size * sizeof(double));
+      memcpy(vec_dir_fk2 + offset, rhs.vec_dir_fk2, chunk_size * sizeof(double));
+      memcpy(vec_dir_fx1 + offset, rhs.vec_dir_fx1, chunk_size * sizeof(double));
+      memcpy(vec_dir_fx2 + offset, rhs.vec_dir_fx2, chunk_size * sizeof(double));
+      memcpy(vec_dir_fy1 + offset, rhs.vec_dir_fy1, chunk_size * sizeof(double));
+      memcpy(vec_dir_fy2 + offset, rhs.vec_dir_fy2, chunk_size * sizeof(double));
+      memcpy(vec_dir_fz1 + offset, rhs.vec_dir_fz1, chunk_size * sizeof(double));
+      memcpy(vec_dir_fz2 + offset, rhs.vec_dir_fz2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqel1 + offset, rhs.vec_dir_tqel1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqel2 + offset, rhs.vec_dir_tqel2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqer1 + offset, rhs.vec_dir_tqer1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqer2 + offset, rhs.vec_dir_tqer2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqek1 + offset, rhs.vec_dir_tqek1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqek2 + offset, rhs.vec_dir_tqek2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqex1 + offset, rhs.vec_dir_tqex1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqex2 + offset, rhs.vec_dir_tqex2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqey1 + offset, rhs.vec_dir_tqey1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqey2 + offset, rhs.vec_dir_tqey2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqez1 + offset, rhs.vec_dir_tqez1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqez2 + offset, rhs.vec_dir_tqez2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqsl1 + offset, rhs.vec_dir_tqsl1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqsl2 + offset, rhs.vec_dir_tqsl2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqsr1 + offset, rhs.vec_dir_tqsr1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqsr2 + offset, rhs.vec_dir_tqsr2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqsk1 + offset, rhs.vec_dir_tqsk1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqsk2 + offset, rhs.vec_dir_tqsk2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqsx1 + offset, rhs.vec_dir_tqsx1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqsx2 + offset, rhs.vec_dir_tqsx2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqsy1 + offset, rhs.vec_dir_tqsy1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqsy2 + offset, rhs.vec_dir_tqsy2, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqsz1 + offset, rhs.vec_dir_tqsz1, chunk_size * sizeof(double));
+      memcpy(vec_dir_tqsz2 + offset, rhs.vec_dir_tqsz2, chunk_size * sizeof(double));
+      memcpy(vec_dir_mull + 16 * offset, rhs.vec_dir_mull, 16 * chunk_size * sizeof(double));
+      memcpy(vec_dir_mulllr + 16 * offset, rhs.vec_dir_mulllr, 16 * chunk_size * sizeof(double));
+    }
   }
   return result;
 }
@@ -4485,157 +4530,162 @@ int InclusionOutputInfo::write_legacy(const std::string &output) {
 #ifdef MPI_VERSION
 int InclusionOutputInfo::mpireceive(const mixMPI* mpidata, int pid) {
   int result = 0;
+  int flag;
   int chk_nsph, chk_inpol, chk_iavm, chk_isam, chk_num_theta, chk_num_thetas;
   int chk_num_phi, chk_num_phis, chk_ndirs, chk_idfc, chk_configs;
   double chk_exri;
-  MPI_Recv(&chk_nsph, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_inpol, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_iavm, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_isam, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_num_theta, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_num_thetas, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_num_phi, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_num_phis, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_ndirs, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_exri, 1, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_idfc, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_configs, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  result += (chk_nsph == nsph) ? 0 : 1;
-  result += (chk_inpol == inpol) ? 0 : 1;
-  result += (chk_iavm == iavm) ? 0 : 1;
-  result += (chk_isam == isam) ? 0 : 1;
-  result += (chk_num_theta == _num_theta) ? 0 : 1;
-  result += (chk_num_thetas == _num_thetas) ? 0 : 1;
-  result += (chk_num_phi == _num_phi) ? 0 : 1;
-  result += (chk_num_phis == _num_phis) ? 0 : 1;
-  result += (chk_ndirs == ndirs) ? 0 : 1;
-  result += (chk_exri == exri) ? 0 : 1;
-  result += (chk_idfc == idfc) ? 0 : 1;
-  result += (chk_configs == configurations) ? 0 : 1;
-  if (result == 0) {
-    int xi1, offset, chunk_size;
-    MPI_Send(&result, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD);
-    MPI_Recv(&xi1, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    // Receive vectors of single values per scale
-    MPI_Recv(&chunk_size, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    offset = xi1 - _first_xi;
-    MPI_Recv(vec_jxi + offset, chunk_size, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_ier + offset, chunk_size, MPI_SHORT, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_vk + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_xi + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_scs1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_scs2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_abs1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_abs2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_exs1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_exs2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_albeds1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_albeds2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_scsrt1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_scsrt2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_absrt1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_absrt2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_exsrt1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_exsrt2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_qschu1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_qschu2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_pschu1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_pschu2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_s0mag1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_s0mag2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_cosav1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_cosav2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_raprs1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_raprs2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_fk1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_fk2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_fsas11 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_fsas21 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_fsas22 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_fsas12 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+  MPI_Recv(&flag, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+  // Proceed with the rest _only if_ flag==0, else nothing is to be received
+  if (flag == 0) {
+    MPI_Recv(&chk_nsph, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_inpol, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_iavm, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_isam, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_num_theta, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_num_thetas, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_num_phi, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_num_phis, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_ndirs, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_exri, 1, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_idfc, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_configs, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    result += (chk_nsph == nsph) ? 0 : 1;
+    result += (chk_inpol == inpol) ? 0 : 1;
+    result += (chk_iavm == iavm) ? 0 : 1;
+    result += (chk_isam == isam) ? 0 : 1;
+    result += (chk_num_theta == _num_theta) ? 0 : 1;
+    result += (chk_num_thetas == _num_thetas) ? 0 : 1;
+    result += (chk_num_phi == _num_phi) ? 0 : 1;
+    result += (chk_num_phis == _num_phis) ? 0 : 1;
+    result += (chk_ndirs == ndirs) ? 0 : 1;
+    result += (chk_exri == exri) ? 0 : 1;
+    result += (chk_idfc == idfc) ? 0 : 1;
+    result += (chk_configs == configurations) ? 0 : 1;
+    if (result == 0) {
+      int xi1, offset, chunk_size;
+      MPI_Send(&result, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD);
+      MPI_Recv(&xi1, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      // Receive vectors of single values per scale
+      MPI_Recv(&chunk_size, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      offset = xi1 - _first_xi;
+      MPI_Recv(vec_jxi + offset, chunk_size, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_ier + offset, chunk_size, MPI_SHORT, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_vk + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_xi + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_scs1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_scs2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_abs1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_abs2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_exs1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_exs2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_albeds1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_albeds2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_scsrt1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_scsrt2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_absrt1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_absrt2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_exsrt1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_exsrt2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_qschu1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_qschu2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_pschu1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_pschu2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_s0mag1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_s0mag2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_cosav1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_cosav2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_raprs1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_raprs2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_fk1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_fk2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_fsas11 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_fsas21 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_fsas22 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_fsas12 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
 
-    // Receive vectors whose sizes depend on configurations
-    MPI_Recv(&chunk_size, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    offset = (xi1 - _first_xi) * (configurations + 1);
-    MPI_Recv(vec_sphere_sizes + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_sphere_ref_indices + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      // Receive vectors whose sizes depend on configurations
+      MPI_Recv(&chunk_size, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      offset = (xi1 - _first_xi) * (configurations + 1);
+      MPI_Recv(vec_sphere_sizes + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_sphere_ref_indices + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
 
-    // Receive vectors whose sizes depend on directions and wavelengths
-    MPI_Recv(&chunk_size, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    offset = (xi1 - _first_xi) * ndirs;
-    MPI_Recv(vec_dir_scs1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_scs2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_abs1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_abs2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_exs1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_exs2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_albeds1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_albeds2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_scsrt1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_scsrt2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_absrt1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_absrt2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_exsrt1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_exsrt2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_fsas11 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_fsas21 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_fsas12 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_fsas22 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_sas11 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_sas21 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_sas12 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_sas22 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_qschu1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_qschu2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_pschu1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_pschu2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_s0mag1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_s0mag2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_cosav1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_cosav2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_rapr1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_rapr2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      // Receive vectors whose sizes depend on directions and wavelengths
+      MPI_Recv(&chunk_size, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      offset = (xi1 - _first_xi) * ndirs;
+      MPI_Recv(vec_dir_scs1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_scs2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_abs1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_abs2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_exs1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_exs2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_albeds1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_albeds2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_scsrt1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_scsrt2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_absrt1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_absrt2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_exsrt1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_exsrt2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_fsas11 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_fsas21 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_fsas12 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_fsas22 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_sas11 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_sas21 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_sas12 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_sas22 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_qschu1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_qschu2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_pschu1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_pschu2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_s0mag1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_s0mag2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_cosav1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_cosav2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_rapr1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_rapr2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
 
-    MPI_Recv(vec_dir_fl1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_fl2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_fr1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_fr2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_fk1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_fk2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_fx1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_fx2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_fy1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_fy2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_fz1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_fz2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqel1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqel2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqer1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqer2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqek1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqek2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqex1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqex2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqey1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqey2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqez1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqez2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqsl1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqsl2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqsr1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqsr2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqsk1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqsk2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqsx1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqsx2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqsy1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqsy2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqsz1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_tqsz2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_mull + 16 * offset, 16 * chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_mulllr + 16 * offset, 16 * chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  }  else {
-    MPI_Send(&result, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD);
+      MPI_Recv(vec_dir_fl1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_fl2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_fr1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_fr2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_fk1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_fk2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_fx1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_fx2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_fy1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_fy2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_fz1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_fz2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqel1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqel2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqer1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqer2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqek1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqek2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqex1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqex2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqey1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqey2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqez1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqez2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqsl1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqsl2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqsr1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqsr2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqsk1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqsk2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqsx1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqsx2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqsy1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqsy2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqsz1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_tqsz2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_mull + 16 * offset, 16 * chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_mulllr + 16 * offset, 16 * chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    }  else {
+      MPI_Send(&result, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD);
+    }
   }
   return result;
 }
@@ -4643,140 +4693,150 @@ int InclusionOutputInfo::mpireceive(const mixMPI* mpidata, int pid) {
 int InclusionOutputInfo::mpisend(const mixMPI *mpidata) {
   int result = 0;
   int chunk_size;
-  // Send output metadata for configuration cross-check
-  MPI_Send(&nsph, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&inpol, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&iavm, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&isam, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&_num_theta, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&_num_thetas, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&_num_phi, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&_num_phis, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&ndirs, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&exri, 1, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&idfc, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&configurations, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  // Wait for process 0 to cross-check the configuration
-  MPI_Recv(&result, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  if (result == 0) {
-    // Process 0 confirmed the consistency of configuration. Send the data.
-    // Send vectors of single values per scale
-    MPI_Send(&_first_xi, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(&xi_block_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_jxi, xi_block_size, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_ier, xi_block_size, MPI_SHORT, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_vk, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_xi, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_scs1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_scs2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_abs1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_abs2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_exs1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_exs2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_albeds1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_albeds2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_scsrt1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_scsrt2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_absrt1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_absrt2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_exsrt1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_exsrt2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_qschu1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_qschu2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_pschu1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_pschu2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_s0mag1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_s0mag2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_cosav1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_cosav2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_raprs1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_raprs2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_fk1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_fk2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_fsas11, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_fsas21, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_fsas22, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_fsas12, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+  if (_skip_flag == 1) {
+    // tell the receiver we are not sending anything
+    int flag = 1;
+    MPI_Send(&flag, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+  }
+  else {
+    // tell the receiver we are sending actual stuff
+    int flag = 0;
+    MPI_Send(&flag, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    // Send output metadata for configuration cross-check
+    MPI_Send(&nsph, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&inpol, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&iavm, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&isam, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&_num_theta, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&_num_thetas, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&_num_phi, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&_num_phis, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&ndirs, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&exri, 1, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&idfc, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&configurations, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    // Wait for process 0 to cross-check the configuration
+    MPI_Recv(&result, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    if (result == 0) {
+      // Process 0 confirmed the consistency of configuration. Send the data.
+      // Send vectors of single values per scale
+      MPI_Send(&_first_xi, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(&xi_block_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_jxi, xi_block_size, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_ier, xi_block_size, MPI_SHORT, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_vk, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_xi, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_scs1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_scs2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_abs1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_abs2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_exs1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_exs2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_albeds1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_albeds2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_scsrt1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_scsrt2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_absrt1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_absrt2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_exsrt1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_exsrt2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_qschu1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_qschu2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_pschu1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_pschu2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_s0mag1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_s0mag2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_cosav1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_cosav2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_raprs1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_raprs2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_fk1, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_fk2, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_fsas11, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_fsas21, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_fsas22, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_fsas12, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
 
-    // Send vectors whose sizes depend on configurations
-    chunk_size = xi_block_size * (configurations + 1);
-    MPI_Send(&chunk_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_sphere_sizes, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_sphere_ref_indices, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      // Send vectors whose sizes depend on configurations
+      chunk_size = xi_block_size * (configurations + 1);
+      MPI_Send(&chunk_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_sphere_sizes, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_sphere_ref_indices, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
 
-    // Send vectors whose sizes depend on directions and wavelengths
-    chunk_size = xi_block_size * ndirs;
-    MPI_Send(&chunk_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_scs1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_scs2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_abs1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_abs2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_exs1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_exs2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_albeds1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_albeds2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_scsrt1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_scsrt2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_absrt1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_absrt2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_exsrt1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_exsrt2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fsas11, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fsas21, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fsas12, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fsas22, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sas11, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sas21, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sas12, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sas22, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_qschu1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_qschu2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_pschu1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_pschu2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_s0mag1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_s0mag2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_cosav1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_cosav2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_rapr1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_rapr2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fl1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fl2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fr1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fr2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fk1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fk2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fx1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fx2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fy1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fy2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fz1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fz2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqel1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqel2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqer1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqer2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqek1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqek2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqex1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqex2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqey1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqey2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqez1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqez2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqsl1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqsl2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqsr1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqsr2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqsk1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqsk2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqsx1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqsx2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqsy1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqsy2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqsz1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_tqsz2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_mull, 16 * chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_mulllr, 16 * chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      // Send vectors whose sizes depend on directions and wavelengths
+      chunk_size = xi_block_size * ndirs;
+      MPI_Send(&chunk_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_scs1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_scs2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_abs1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_abs2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_exs1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_exs2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_albeds1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_albeds2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_scsrt1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_scsrt2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_absrt1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_absrt2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_exsrt1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_exsrt2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fsas11, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fsas21, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fsas12, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fsas22, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sas11, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sas21, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sas12, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sas22, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_qschu1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_qschu2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_pschu1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_pschu2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_s0mag1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_s0mag2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_cosav1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_cosav2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_rapr1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_rapr2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fl1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fl2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fr1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fr2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fk1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fk2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fx1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fx2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fy1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fy2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fz1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fz2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqel1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqel2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqer1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqer2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqek1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqek2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqex1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqex2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqey1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqey2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqez1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqez2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqsl1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqsl2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqsr1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqsr2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqsk1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqsk2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqsx1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqsx2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqsy1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqsy2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqsz1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_tqsz2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_mull, 16 * chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_mulllr, 16 * chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+    }
   }
   return result;
 }
@@ -4788,6 +4848,7 @@ SphereOutputInfo::SphereOutputInfo(
   ScattererConfiguration *sc, GeometryConfiguration *gc,
   const mixMPI *mpidata, int first_xi, int xi_length
 ) {
+  _skip_flag = 0;
   _first_xi = first_xi;
   nsph = gc->number_of_spheres;
   lm = gc->l_max;
@@ -4900,6 +4961,7 @@ SphereOutputInfo::SphereOutputInfo(const std::string &hdf5_name) {
   HDFFile *hdf_file = new HDFFile(hdf5_name, flags);
   herr_t status = hdf_file->get_status();
   string str_name, str_type;
+  _skip_flag = 0;
   if (status == 0) {
     status = hdf_file->read("NSPH", "INT32_(1)", &nsph);
     status = hdf_file->read("LM", "INT32_(1)", &lm);
@@ -5072,56 +5134,70 @@ SphereOutputInfo::SphereOutputInfo(const std::string &hdf5_name) {
   }
 }
 
+SphereOutputInfo::SphereOutputInfo(const int flag) {
+  /*
+    create a dummy placeholder just to know I should skip MPI_Send and MPI_Recv
+  */
+  if (flag == 1) {
+    _skip_flag = 1;
+  } else {
+    UnrecognizedOutputInfo ex(flag);
+    throw ex;
+  }
+}
+
 SphereOutputInfo::~SphereOutputInfo() {
-  delete[] vec_jxi;
-  delete[] vec_ier;
-  delete[] vec_vk;
-  delete[] vec_xi;
-  delete[] vec_sphere_sizes;
-  delete[] vec_sphere_ref_indices;
-  delete[] vec_scs;
-  delete[] vec_abs;
-  delete[] vec_exs;
-  delete[] vec_albeds;
-  delete[] vec_scsrt;
-  delete[] vec_absrt;
-  delete[] vec_exsrt;
-  delete[] vec_fsas;
-  delete[] vec_qschu;
-  delete[] vec_pschu;
-  delete[] vec_s0mag;
-  delete[] vec_cosav;
-  delete[] vec_raprs;
-  delete[] vec_tqek1;
-  delete[] vec_tqek2;
-  delete[] vec_tqsk1;
-  delete[] vec_tqsk2;
-  if (nsph != 1) {
-    delete[] vec_fsat;
-    delete[] vec_qschut;
-    delete[] vec_pschut;
-    delete[] vec_s0magt;
+  if (_skip_flag != 1) {
+    delete[] vec_jxi;
+    delete[] vec_ier;
+    delete[] vec_vk;
+    delete[] vec_xi;
+    delete[] vec_sphere_sizes;
+    delete[] vec_sphere_ref_indices;
+    delete[] vec_scs;
+    delete[] vec_abs;
+    delete[] vec_exs;
+    delete[] vec_albeds;
+    delete[] vec_scsrt;
+    delete[] vec_absrt;
+    delete[] vec_exsrt;
+    delete[] vec_fsas;
+    delete[] vec_qschu;
+    delete[] vec_pschu;
+    delete[] vec_s0mag;
+    delete[] vec_cosav;
+    delete[] vec_raprs;
+    delete[] vec_tqek1;
+    delete[] vec_tqek2;
+    delete[] vec_tqsk1;
+    delete[] vec_tqsk2;
+    if (nsph != 1) {
+      delete[] vec_fsat;
+      delete[] vec_qschut;
+      delete[] vec_pschut;
+      delete[] vec_s0magt;
+    }
+    delete[] vec_dir_tidg;
+    delete[] vec_dir_pidg;
+    delete[] vec_dir_tsdg;
+    delete[] vec_dir_psdg;
+    delete[] vec_dir_scand;
+    delete[] vec_dir_cfmp;
+    delete[] vec_dir_cfsp;
+    delete[] vec_dir_sfmp;
+    delete[] vec_dir_sfsp;
+    delete[] vec_dir_un;
+    delete[] vec_dir_uns;
+    delete[] vec_dir_sas11;
+    delete[] vec_dir_sas21;
+    delete[] vec_dir_sas12;
+    delete[] vec_dir_sas22;
+    delete[] vec_dir_fx;
+    delete[] vec_dir_fy;
+    delete[] vec_dir_fz;
+    delete[] vec_dir_muls;
+    delete[] vec_dir_mulslr;
   }
-  delete[] vec_dir_tidg;
-  delete[] vec_dir_pidg;
-  delete[] vec_dir_tsdg;
-  delete[] vec_dir_psdg;
-  delete[] vec_dir_scand;
-  delete[] vec_dir_cfmp;
-  delete[] vec_dir_cfsp;
-  delete[] vec_dir_sfmp;
-  delete[] vec_dir_sfsp;
-  delete[] vec_dir_un;
-  delete[] vec_dir_uns;
-  delete[] vec_dir_sas11;
-  delete[] vec_dir_sas21;
-  delete[] vec_dir_sas12;
-  delete[] vec_dir_sas22;
-  delete[] vec_dir_fx;
-  delete[] vec_dir_fy;
-  delete[] vec_dir_fz;
-  delete[] vec_dir_muls;
-  delete[] vec_dir_mulslr;
 }
 
 long SphereOutputInfo::compute_size(
@@ -5197,74 +5273,76 @@ long SphereOutputInfo::compute_size() {
 
 int SphereOutputInfo::insert(const SphereOutputInfo &rhs) {
   int result = 0;
-  result += (rhs.nsph == nsph) ? 0 : 1;
-  result += (rhs.inpol == inpol) ? 0 : 1;
-  result += (rhs.isam == isam) ? 0 : 1;
-  result += (rhs._num_theta == _num_theta) ? 0 : 1;
-  result += (rhs._num_thetas == _num_thetas) ? 0 : 1;
-  result += (rhs._num_phi == _num_phi) ? 0 : 1;
-  result += (rhs._num_phis == _num_phis) ? 0 : 1;
-  result += (rhs.ndirs == ndirs) ? 0 : 1;
-  result += (rhs.exri == exri) ? 0 : 1;
-  result += (rhs.idfc == idfc) ? 0 : 1;
-  result += (rhs.configurations == configurations) ? 0 : 1;
-  if (result == 0) {
-    int offset, chunk_size, xi1;
-    xi1 = rhs._first_xi;
-    // Insert vectors whose sizes depend on wavelengths
-    offset = xi1 - _first_xi;
-    chunk_size = rhs.xi_block_size;
-    memcpy(vec_jxi + offset, rhs.vec_jxi, chunk_size * sizeof(int));
-    memcpy(vec_ier + offset, rhs.vec_ier, chunk_size * sizeof(short));
-    memcpy(vec_vk + offset, rhs.vec_vk, chunk_size * sizeof(double));
-    memcpy(vec_xi + offset, rhs.vec_xi, chunk_size * sizeof(double));
-    if (nsph != 1) {
-      memcpy(vec_fsat + offset, rhs.vec_fsat, chunk_size * sizeof(dcomplex));
-      memcpy(vec_qschut + offset, rhs.vec_qschut, chunk_size * sizeof(double));
-      memcpy(vec_pschut + offset, rhs.vec_pschut, chunk_size * sizeof(double));
-      memcpy(vec_s0magt + offset, rhs.vec_s0magt, chunk_size * sizeof(double));
-    }
+  if (rhs.skip_flag != 1) {
+    result += (rhs.nsph == nsph) ? 0 : 1;
+    result += (rhs.inpol == inpol) ? 0 : 1;
+    result += (rhs.isam == isam) ? 0 : 1;
+    result += (rhs._num_theta == _num_theta) ? 0 : 1;
+    result += (rhs._num_thetas == _num_thetas) ? 0 : 1;
+    result += (rhs._num_phi == _num_phi) ? 0 : 1;
+    result += (rhs._num_phis == _num_phis) ? 0 : 1;
+    result += (rhs.ndirs == ndirs) ? 0 : 1;
+    result += (rhs.exri == exri) ? 0 : 1;
+    result += (rhs.idfc == idfc) ? 0 : 1;
+    result += (rhs.configurations == configurations) ? 0 : 1;
+    if (result == 0) {
+      int offset, chunk_size, xi1;
+      xi1 = rhs._first_xi;
+      // Insert vectors whose sizes depend on wavelengths
+      offset = xi1 - _first_xi;
+      chunk_size = rhs.xi_block_size;
+      memcpy(vec_jxi + offset, rhs.vec_jxi, chunk_size * sizeof(int));
+      memcpy(vec_ier + offset, rhs.vec_ier, chunk_size * sizeof(short));
+      memcpy(vec_vk + offset, rhs.vec_vk, chunk_size * sizeof(double));
+      memcpy(vec_xi + offset, rhs.vec_xi, chunk_size * sizeof(double));
+      if (nsph != 1) {
+	memcpy(vec_fsat + offset, rhs.vec_fsat, chunk_size * sizeof(dcomplex));
+	memcpy(vec_qschut + offset, rhs.vec_qschut, chunk_size * sizeof(double));
+	memcpy(vec_pschut + offset, rhs.vec_pschut, chunk_size * sizeof(double));
+	memcpy(vec_s0magt + offset, rhs.vec_s0magt, chunk_size * sizeof(double));
+      }
 
-    // Insert vectors whose sizes depend on configurations and wavelengths
-    offset = (xi1 - _first_xi) * configurations;
-    chunk_size = rhs.xi_block_size * configurations;
-    memcpy(vec_sphere_sizes + offset, rhs.vec_sphere_sizes, chunk_size * sizeof(double));
-    memcpy(vec_sphere_ref_indices + offset, rhs.vec_sphere_ref_indices, chunk_size * sizeof(dcomplex));
-    memcpy(vec_scs + offset, rhs.vec_scs, chunk_size * sizeof(double));
-    memcpy(vec_abs + offset, rhs.vec_abs, chunk_size * sizeof(double));
-    memcpy(vec_exs + offset, rhs.vec_exs, chunk_size * sizeof(double));
-    memcpy(vec_albeds + offset, rhs.vec_albeds, chunk_size * sizeof(double));
-    memcpy(vec_scsrt + offset, rhs.vec_scsrt, chunk_size * sizeof(double));
-    memcpy(vec_absrt + offset, rhs.vec_absrt, chunk_size * sizeof(double));
-    memcpy(vec_exsrt + offset, rhs.vec_exsrt, chunk_size * sizeof(double));
-    memcpy(vec_fsas + offset, rhs.vec_fsas, chunk_size * sizeof(dcomplex));
-    memcpy(vec_qschu + offset, rhs.vec_qschu, chunk_size * sizeof(double));
-    memcpy(vec_pschu + offset, rhs.vec_pschu, chunk_size * sizeof(double));
-    memcpy(vec_s0mag + offset, rhs.vec_s0mag, chunk_size * sizeof(double));
-    memcpy(vec_cosav + offset, rhs.vec_cosav, chunk_size * sizeof(double));
-    memcpy(vec_raprs + offset, rhs.vec_raprs, chunk_size * sizeof(double));
-    memcpy(vec_tqek1 + offset, rhs.vec_tqek1, chunk_size * sizeof(double));
-    memcpy(vec_tqek2 + offset, rhs.vec_tqek2, chunk_size * sizeof(double));
-    memcpy(vec_tqsk1 + offset, rhs.vec_tqsk1, chunk_size * sizeof(double));
-    memcpy(vec_tqsk2 + offset, rhs.vec_tqsk2, chunk_size * sizeof(double));
+      // Insert vectors whose sizes depend on configurations and wavelengths
+      offset = (xi1 - _first_xi) * configurations;
+      chunk_size = rhs.xi_block_size * configurations;
+      memcpy(vec_sphere_sizes + offset, rhs.vec_sphere_sizes, chunk_size * sizeof(double));
+      memcpy(vec_sphere_ref_indices + offset, rhs.vec_sphere_ref_indices, chunk_size * sizeof(dcomplex));
+      memcpy(vec_scs + offset, rhs.vec_scs, chunk_size * sizeof(double));
+      memcpy(vec_abs + offset, rhs.vec_abs, chunk_size * sizeof(double));
+      memcpy(vec_exs + offset, rhs.vec_exs, chunk_size * sizeof(double));
+      memcpy(vec_albeds + offset, rhs.vec_albeds, chunk_size * sizeof(double));
+      memcpy(vec_scsrt + offset, rhs.vec_scsrt, chunk_size * sizeof(double));
+      memcpy(vec_absrt + offset, rhs.vec_absrt, chunk_size * sizeof(double));
+      memcpy(vec_exsrt + offset, rhs.vec_exsrt, chunk_size * sizeof(double));
+      memcpy(vec_fsas + offset, rhs.vec_fsas, chunk_size * sizeof(dcomplex));
+      memcpy(vec_qschu + offset, rhs.vec_qschu, chunk_size * sizeof(double));
+      memcpy(vec_pschu + offset, rhs.vec_pschu, chunk_size * sizeof(double));
+      memcpy(vec_s0mag + offset, rhs.vec_s0mag, chunk_size * sizeof(double));
+      memcpy(vec_cosav + offset, rhs.vec_cosav, chunk_size * sizeof(double));
+      memcpy(vec_raprs + offset, rhs.vec_raprs, chunk_size * sizeof(double));
+      memcpy(vec_tqek1 + offset, rhs.vec_tqek1, chunk_size * sizeof(double));
+      memcpy(vec_tqek2 + offset, rhs.vec_tqek2, chunk_size * sizeof(double));
+      memcpy(vec_tqsk1 + offset, rhs.vec_tqsk1, chunk_size * sizeof(double));
+      memcpy(vec_tqsk2 + offset, rhs.vec_tqsk2, chunk_size * sizeof(double));
     
-    // Insert vectors whose sizes depend on NSPH, directions and wavelengths
-    offset = (xi1 - _first_xi) * nsph * ndirs;
-    chunk_size = rhs.xi_block_size * nsph * ndirs;
-    memcpy(vec_dir_sas11 + offset, rhs.vec_dir_sas11, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_sas21 + offset, rhs.vec_dir_sas21, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_sas12 + offset, rhs.vec_dir_sas12, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_sas22 + offset, rhs.vec_dir_sas22, chunk_size * sizeof(dcomplex));
-    memcpy(vec_dir_muls + 16 * offset, rhs.vec_dir_muls, 16 * chunk_size * sizeof(double));
-    memcpy(vec_dir_mulslr + 16 * offset, rhs.vec_dir_mulslr, 16 * chunk_size * sizeof(double));
+      // Insert vectors whose sizes depend on NSPH, directions and wavelengths
+      offset = (xi1 - _first_xi) * nsph * ndirs;
+      chunk_size = rhs.xi_block_size * nsph * ndirs;
+      memcpy(vec_dir_sas11 + offset, rhs.vec_dir_sas11, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_sas21 + offset, rhs.vec_dir_sas21, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_sas12 + offset, rhs.vec_dir_sas12, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_sas22 + offset, rhs.vec_dir_sas22, chunk_size * sizeof(dcomplex));
+      memcpy(vec_dir_muls + 16 * offset, rhs.vec_dir_muls, 16 * chunk_size * sizeof(double));
+      memcpy(vec_dir_mulslr + 16 * offset, rhs.vec_dir_mulslr, 16 * chunk_size * sizeof(double));
 
-    // Insert vectors whose sizes depend on NSPH, incidence directions and wavelengths
-    offset = (xi1 - _first_xi) * nsph * _num_theta * _num_phi;
-    chunk_size = rhs.xi_block_size  * nsph * _num_theta * _num_phi;
-    memcpy(vec_dir_fx + offset, rhs.vec_dir_fx, chunk_size * sizeof(double));
-    memcpy(vec_dir_fy + offset, rhs.vec_dir_fy, chunk_size * sizeof(double));
-    memcpy(vec_dir_fz + offset, rhs.vec_dir_fz, chunk_size * sizeof(double));
-    // TODO: fix the vector sizes in HDF5 writer and MPI communicators
+      // Insert vectors whose sizes depend on NSPH, incidence directions and wavelengths
+      offset = (xi1 - _first_xi) * nsph * _num_theta * _num_phi;
+      chunk_size = rhs.xi_block_size  * nsph * _num_theta * _num_phi;
+      memcpy(vec_dir_fx + offset, rhs.vec_dir_fx, chunk_size * sizeof(double));
+      memcpy(vec_dir_fy + offset, rhs.vec_dir_fy, chunk_size * sizeof(double));
+      memcpy(vec_dir_fz + offset, rhs.vec_dir_fz, chunk_size * sizeof(double));
+      // TODO: fix the vector sizes in HDF5 writer and MPI communicators
+    }
   }
   return result;
 }
@@ -5741,90 +5819,95 @@ int SphereOutputInfo::write_legacy(const std::string &file_name) {
 #ifdef MPI_VERSION
 int SphereOutputInfo::mpireceive(const mixMPI *mpidata, int pid) {
   int result = 0;
+  int flag;
   int chk_nsph, chk_inpol, chk_isam, chk_num_theta, chk_num_thetas;
   int chk_num_phi, chk_num_phis, chk_ndirs, chk_idfc, chk_configs;
   double chk_exri;
-  MPI_Recv(&chk_nsph, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_inpol, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_isam, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_num_theta, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_num_thetas, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_num_phi, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_num_phis, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_ndirs, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_exri, 1, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_idfc, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  MPI_Recv(&chk_configs, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  result += (chk_nsph == nsph) ? 0 : 1;
-  result += (chk_inpol == inpol) ? 0 : 1;
-  result += (chk_isam == isam) ? 0 : 1;
-  result += (chk_num_theta == _num_theta) ? 0 : 1;
-  result += (chk_num_thetas == _num_thetas) ? 0 : 1;
-  result += (chk_num_phi == _num_phi) ? 0 : 1;
-  result += (chk_num_phis == _num_phis) ? 0 : 1;
-  result += (chk_ndirs == ndirs) ? 0 : 1;
-  result += (chk_exri == exri) ? 0 : 1;
-  result += (chk_idfc == idfc) ? 0 : 1;
-  result += (chk_configs == configurations) ? 0 : 1;
-  if (result == 0) {
-    int xi1, offset, chunk_size;
-    MPI_Send(&result, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD);
-    MPI_Recv(&xi1, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    // Receive vectors of single values per scale
-    MPI_Recv(&chunk_size, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    offset = xi1 - _first_xi;
-    MPI_Recv(vec_jxi + offset, chunk_size, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_ier + offset, chunk_size, MPI_SHORT, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_vk + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_xi + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    if (nsph != 1) {
-      MPI_Recv(vec_fsat + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE); 
-      MPI_Recv(vec_qschut + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-      MPI_Recv(vec_pschut + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-      MPI_Recv(vec_s0magt + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    }
+  MPI_Recv(&flag, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+  // Proceed with the rest _only if_ flag==0, else nothing is to be received
+  if (flag == 0) {
+    MPI_Recv(&chk_nsph, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_inpol, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_isam, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_num_theta, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_num_thetas, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_num_phi, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_num_phis, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_ndirs, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_exri, 1, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_idfc, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    MPI_Recv(&chk_configs, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    result += (chk_nsph == nsph) ? 0 : 1;
+    result += (chk_inpol == inpol) ? 0 : 1;
+    result += (chk_isam == isam) ? 0 : 1;
+    result += (chk_num_theta == _num_theta) ? 0 : 1;
+    result += (chk_num_thetas == _num_thetas) ? 0 : 1;
+    result += (chk_num_phi == _num_phi) ? 0 : 1;
+    result += (chk_num_phis == _num_phis) ? 0 : 1;
+    result += (chk_ndirs == ndirs) ? 0 : 1;
+    result += (chk_exri == exri) ? 0 : 1;
+    result += (chk_idfc == idfc) ? 0 : 1;
+    result += (chk_configs == configurations) ? 0 : 1;
+    if (result == 0) {
+      int xi1, offset, chunk_size;
+      MPI_Send(&result, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD);
+      MPI_Recv(&xi1, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      // Receive vectors of single values per scale
+      MPI_Recv(&chunk_size, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      offset = xi1 - _first_xi;
+      MPI_Recv(vec_jxi + offset, chunk_size, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_ier + offset, chunk_size, MPI_SHORT, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_vk + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_xi + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      if (nsph != 1) {
+	MPI_Recv(vec_fsat + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE); 
+	MPI_Recv(vec_qschut + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+	MPI_Recv(vec_pschut + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+	MPI_Recv(vec_s0magt + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      }
 
-    // Receive vectors whose sizes depend on configurations and wavelengths
-    MPI_Recv(&chunk_size, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    offset = (xi1 - _first_xi) * configurations;
-    MPI_Recv(vec_sphere_sizes + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_sphere_ref_indices + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_scs + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_abs + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_exs + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_albeds + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_scsrt + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_absrt + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_exsrt + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_fsas + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_qschu + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_pschu + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_s0mag + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_cosav + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_raprs + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_tqek1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_tqek2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_tqsk1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_tqsk2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-      
-    // Receive vectors whose sizes depend on NSPH, directions and wavelengths
-    MPI_Recv(&chunk_size, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    offset = (xi1 - _first_xi) * nsph * ndirs;
-    MPI_Recv(vec_dir_sas11 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_sas21 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_sas12 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_sas22 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_muls + 16 * offset, 16 * chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_mulslr + 16 * offset, 16 * chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      // Receive vectors whose sizes depend on configurations and wavelengths
+      MPI_Recv(&chunk_size, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      offset = (xi1 - _first_xi) * configurations;
+      MPI_Recv(vec_sphere_sizes + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_sphere_ref_indices + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_scs + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_abs + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_exs + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_albeds + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_scsrt + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_absrt + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_exsrt + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_fsas + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_qschu + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_pschu + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_s0mag + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_cosav + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_raprs + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_tqek1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_tqek2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_tqsk1 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_tqsk2 + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
 
-    // Receive vectors whose sizes depend on NSPH, incidence directions and wavelengths
-    MPI_Recv(&chunk_size, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    offset = (xi1 - _first_xi) * nsph * _num_theta * _num_phi;
-    MPI_Recv(vec_dir_fx + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_fy + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-    MPI_Recv(vec_dir_fz + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  }  else {
-    MPI_Send(&result, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD);
+      // Receive vectors whose sizes depend on NSPH, directions and wavelengths
+      MPI_Recv(&chunk_size, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      offset = (xi1 - _first_xi) * nsph * ndirs;
+      MPI_Recv(vec_dir_sas11 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_sas21 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_sas12 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_sas22 + offset, chunk_size, MPI_C_DOUBLE_COMPLEX, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_muls + 16 * offset, 16 * chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_mulslr + 16 * offset, 16 * chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+
+      // Receive vectors whose sizes depend on NSPH, incidence directions and wavelengths
+      MPI_Recv(&chunk_size, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      offset = (xi1 - _first_xi) * nsph * _num_theta * _num_phi;
+      MPI_Recv(vec_dir_fx + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_fy + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+      MPI_Recv(vec_dir_fz + offset, chunk_size, MPI_DOUBLE, pid, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    }  else {
+      MPI_Send(&result, 1, MPI_INT32_T, pid, 10, MPI_COMM_WORLD);
+    }
   }
   return result;
 }
@@ -5832,74 +5915,84 @@ int SphereOutputInfo::mpireceive(const mixMPI *mpidata, int pid) {
 int SphereOutputInfo::mpisend(const mixMPI *mpidata) {
   int result = 0;
   int chunk_size;
-  // Send output metadata for configuration cross-check
-  MPI_Send(&nsph, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&inpol, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&isam, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&_num_theta, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&_num_thetas, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&_num_phi, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&_num_phis, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&ndirs, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&exri, 1, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&idfc, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  MPI_Send(&configurations, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-  // Wait for process 0 to cross-check the configuration
-  MPI_Recv(&result, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-  if (result == 0) {
-    // Process 0 confirmed the consistency of configuration. Send the data.
-    // Send vectors of single values per scale
-    MPI_Send(&_first_xi, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(&xi_block_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_jxi, xi_block_size, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_ier, xi_block_size, MPI_SHORT, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_vk, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_xi, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    if (nsph != 1) {
-      MPI_Send(vec_fsat, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-      MPI_Send(vec_qschut, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-      MPI_Send(vec_pschut, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-      MPI_Send(vec_s0magt, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    }
+  if (_skip_flag == 1) {
+    // tell the receiver we are not sending anything
+    int flag = 1;
+    MPI_Send(&flag, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+  }
+  else {
+    // tell the receiver we are sending actual stuff
+    int flag = 0;
+    MPI_Send(&flag, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    // Send output metadata for configuration cross-check
+    MPI_Send(&nsph, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&inpol, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&isam, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&_num_theta, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&_num_thetas, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&_num_phi, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&_num_phis, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&ndirs, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&exri, 1, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&idfc, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    MPI_Send(&configurations, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+    // Wait for process 0 to cross-check the configuration
+    MPI_Recv(&result, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    if (result == 0) {
+      // Process 0 confirmed the consistency of configuration. Send the data.
+      // Send vectors of single values per scale
+      MPI_Send(&_first_xi, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(&xi_block_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_jxi, xi_block_size, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_ier, xi_block_size, MPI_SHORT, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_vk, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_xi, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      if (nsph != 1) {
+	MPI_Send(vec_fsat, xi_block_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+	MPI_Send(vec_qschut, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+	MPI_Send(vec_pschut, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+	MPI_Send(vec_s0magt, xi_block_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      }
 
-    // Send vectors whose sizes depend on configurations and scales
-    chunk_size = xi_block_size * configurations;
-    MPI_Send(&chunk_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_sphere_sizes, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_sphere_ref_indices, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_scs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_abs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_exs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_albeds, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_scsrt, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_absrt, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_exsrt, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_fsas, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_qschu, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_pschu, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_s0mag, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_cosav, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_raprs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_tqek1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_tqek2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_tqsk1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_tqsk2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      // Send vectors whose sizes depend on configurations and scales
+      chunk_size = xi_block_size * configurations;
+      MPI_Send(&chunk_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_sphere_sizes, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_sphere_ref_indices, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_scs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_abs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_exs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_albeds, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_scsrt, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_absrt, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_exsrt, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_fsas, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_qschu, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_pschu, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_s0mag, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_cosav, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_raprs, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_tqek1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_tqek2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_tqsk1, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_tqsk2, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
 
-    // Send vectors whose sizes depend on NSPH, directions and wavelengths
-    chunk_size = xi_block_size * nsph * ndirs;
-    MPI_Send(&chunk_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sas11, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sas21, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sas12, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_sas22, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_muls, 16 * chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_mulslr, 16 * chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      // Send vectors whose sizes depend on NSPH, directions and wavelengths
+      chunk_size = xi_block_size * nsph * ndirs;
+      MPI_Send(&chunk_size, 1, MPI_INT32_T, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sas11, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sas21, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sas12, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_sas22, chunk_size, MPI_C_DOUBLE_COMPLEX, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_muls, 16 * chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_mulslr, 16 * chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
 
-    // Send vectors whose sizes depend on NSPH, incidence directions and wavelengths
-    chunk_size = xi_block_size * nsph * _num_theta * _num_phi;
-    MPI_Send(vec_dir_fx, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fy, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
-    MPI_Send(vec_dir_fz, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      // Send vectors whose sizes depend on NSPH, incidence directions and wavelengths
+      chunk_size = xi_block_size * nsph * _num_theta * _num_phi;
+      MPI_Send(vec_dir_fx, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fy, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+      MPI_Send(vec_dir_fz, chunk_size, MPI_DOUBLE, 0, 10, MPI_COMM_WORLD);
+    }
   }
   return result;
 }
diff --git a/src/scripts/README.md b/src/scripts/README.md
index 678a73f88168ae15514cc49121fb9ad384f083e9..906c8647a41c1c3c63a772366d62d199329b54c5 100644
--- a/src/scripts/README.md
+++ b/src/scripts/README.md
@@ -37,7 +37,7 @@ where `LOG_FILE` must be the name of a file containing the output that would nor
 
 # License
 
-   Copyright (C) 2024   INAF - Osservatorio Astronomico di Cagliari
+   Copyright (C) 2025   INAF - Osservatorio Astronomico di Cagliari
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/src/sphere/sphere.cpp b/src/sphere/sphere.cpp
index a2d5228ec09e24aa32772daf739bf0785791e836..288c259f4aee6b48efe3b6980af1e87f01e6dbd8 100644
--- a/src/sphere/sphere.cpp
+++ b/src/sphere/sphere.cpp
@@ -330,19 +330,17 @@ void sphere(const string& config_file, const string& data_file, const string& ou
 	    int jer = sphere_jxi488_cycle(myjxi488 - 1, sconf, gconf, p_sa, sid_2, p_output_2, output_path, vtppoanp_2);
 	  } else {
 	    if (myompthread > 0) {
-	      // If there is no input for this thread, set output pointer to NULL.
-	      p_outarray[myompthread] = NULL;
+	      // If there is no input for this thread, mark to skip.
+	      p_outarray[myompthread] = new SphereOutputInfo(1);
 	    }
 	  }
 #pragma omp barrier
 	  // threads different from 0 append their virtual files to the one of thread 0, and delete them
 	  if (myompthread == 0) {
 	    for (int ti=1; ti<ompnumthreads; ti++) {
-	      if (p_outarray[ti] != NULL) {
-		p_outarray[0]->insert(*(p_outarray[ti]));
-		delete p_outarray[ti];
-		p_outarray[ti] = NULL;
-	      }
+	      p_outarray[0]->insert(*(p_outarray[ti]));
+	      delete p_outarray[ti];
+	      p_outarray[ti] = NULL;
 	      vtppoanarray[0]->append(*(vtppoanarray[ti]));
 	      delete vtppoanarray[ti];
 	    }
@@ -484,27 +482,24 @@ void sphere(const string& config_file, const string& data_file, const string& ou
 	    p_outarray[myompthread] = p_output_2;
 	  } else {
 	    // Thread 0 of non-zero MPI processes needs to allocate memory for the
-	    // output of all threads.
-	    p_output_2 = new SphereOutputInfo(sconf, gconf, mpidata, myjxi488, ompnumthreads);
+	    // output of all threads _doing something_.
+	    int iterstodo = sid_2->number_of_scales - myjxi488 + 1;
+	    if (iterstodo > ompnumthreads) iterstodo = ompnumthreads;
+	    p_output_2 = new SphereOutputInfo(sconf, gconf, mpidata, myjxi488, iterstodo);
 	    p_outarray[0] = p_output_2;
 	  }
 	  int jer = sphere_jxi488_cycle(myjxi488 - 1, sconf, gconf, p_sa, sid_2, p_output_2, output_path, vtppoanp_2);
 	} else {
-	  if (myompthread > 0) {
-	    // If there is no input for this thread, set the output pointer to NULL.
-	    p_outarray[myompthread] = NULL;
-	  }	  
+	  p_outarray[myompthread] = new SphereOutputInfo(1);
 	}
 
 #pragma omp barrier
 	// threads different from 0 append their virtual files to the one of thread 0, and delete them
 	if (myompthread == 0) {
 	  for (int ti=1; ti<ompnumthreads; ti++) {
-	    if (p_outarray[ti] != NULL) {
-	      p_outarray[0]->insert(*(p_outarray[ti]));
-	      delete p_outarray[ti];
-	      p_outarray[ti] = NULL;
-	    }
+	    p_outarray[0]->insert(*(p_outarray[ti]));
+	    delete p_outarray[ti];
+	    p_outarray[ti] = NULL;
 	    vtppoanarray[0]->append(*(vtppoanarray[ti]));
 	    delete vtppoanarray[ti];
 	  }
@@ -513,6 +508,7 @@ void sphere(const string& config_file, const string& data_file, const string& ou
 	    if (rr == mpidata->rank) {
 	      p_outarray[0]->mpisend(mpidata);
 	      delete p_outarray[0];
+	      p_outarray[0] = NULL;
 	      vtppoanarray[0]->mpisend(mpidata);
 	      delete vtppoanarray[0];
 	    }
diff --git a/test_data/README.md b/test_data/README.md
index a2e4d676a07abf12fd1eadb2f21cf8dcd69994e3..9000b13addcff20ed91be31883cbc838dc1a501e 100644
--- a/test_data/README.md
+++ b/test_data/README.md
@@ -16,7 +16,7 @@ In general, input data files are identified by names that start with the `D` cha
 
 # License
 
-   Copyright (C) 2024   INAF - Osservatorio Astronomico di Cagliari
+   Copyright (C) 2025   INAF - Osservatorio Astronomico di Cagliari
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/test_data/cluster/README.md b/test_data/cluster/README.md
index d93b52044281e4b639019e2b489593c4792c2da6..f9c4e337d59b9f2b829ebe0507e13e0e52ec7231 100644
--- a/test_data/cluster/README.md
+++ b/test_data/cluster/README.md
@@ -65,7 +65,7 @@ where the different lines have the following roles:
 
 # License
 
-   Copyright (C) 2024   INAF - Osservatorio Astronomico di Cagliari
+   Copyright (C) 2025   INAF - Osservatorio Astronomico di Cagliari
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/test_data/inclusion/README.md b/test_data/inclusion/README.md
index 8da761c37ea89e7c523c68a2d7738f465cb5a023..0210fe4c1c1588bc88f19376adfd25d0af8c6da2 100644
--- a/test_data/inclusion/README.md
+++ b/test_data/inclusion/README.md
@@ -4,7 +4,7 @@ This directory contains test data for models made up by a sphere with inclusions
 
 # License
 
-   Copyright (C) 2024   INAF - Osservatorio Astronomico di Cagliari
+   Copyright (C) 2025   INAF - Osservatorio Astronomico di Cagliari
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/test_data/sphere/README.md b/test_data/sphere/README.md
index baff04bce0dd69504435e4d9929191bea110176d..a797828b7ade5824887548c436b194ba0a2133b5 100644
--- a/test_data/sphere/README.md
+++ b/test_data/sphere/README.md
@@ -50,7 +50,7 @@ where the different lines have the following roles:
 
 # License
 
-   Copyright (C) 2024   INAF - Osservatorio Astronomico di Cagliari
+   Copyright (C) 2025   INAF - Osservatorio Astronomico di Cagliari
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
diff --git a/test_data/trapping/README.md b/test_data/trapping/README.md
index 91ebe5cd461baa9357628f5600b42170c25e7996..ef66b8798adb4fb55c395a19950653cee3789f00 100644
--- a/test_data/trapping/README.md
+++ b/test_data/trapping/README.md
@@ -8,7 +8,7 @@ As of M9, `trapping` has only been ported to _C++_ and not yet parallelized. Ins
 
 # License
 
-   Copyright (C) 2024   INAF - Osservatorio Astronomico di Cagliari
+   Copyright (C) 2025   INAF - Osservatorio Astronomico di Cagliari
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by