From 13eb6a9e4c20c75e0a8c26d2d2c3bde547326766 Mon Sep 17 00:00:00 2001
From: "Mulas, Giacomo" <gmulas@oa-cagliari.inaf.it>
Date: Wed, 26 Mar 2025 18:15:47 +0100
Subject: [PATCH] move checks on skip_flag into *OutputInfo::insert() methods
---
src/cluster/cluster.cpp | 8 +-
src/inclusion/inclusion.cpp | 8 +-
src/libnptm/outputs.cpp | 748 ++++++++++++++++++------------------
src/sphere/sphere.cpp | 8 +-
4 files changed, 383 insertions(+), 389 deletions(-)
diff --git a/src/cluster/cluster.cpp b/src/cluster/cluster.cpp
index be7e5957..f3e9141d 100644
--- a/src/cluster/cluster.cpp
+++ b/src/cluster/cluster.cpp
@@ -453,9 +453,7 @@ 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]->skip_flag != 1) {
- p_outarray[0]->insert(*(p_outarray[ti]));
- }
+ p_outarray[0]->insert(*(p_outarray[ti]));
delete p_outarray[ti];
p_outarray[ti] = NULL;
vtppoanarray[0]->append(*(vtppoanarray[ti]));
@@ -635,9 +633,7 @@ 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]->skip_flag != 1) {
- p_outarray[0]->insert(*(p_outarray[ti]));
- }
+ p_outarray[0]->insert(*(p_outarray[ti]));
delete p_outarray[ti];
p_outarray[ti] = NULL;
vtppoanarray[0]->append(*(vtppoanarray[ti]));
diff --git a/src/inclusion/inclusion.cpp b/src/inclusion/inclusion.cpp
index dac08211..0b0033c4 100644
--- a/src/inclusion/inclusion.cpp
+++ b/src/inclusion/inclusion.cpp
@@ -449,9 +449,7 @@ 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]->skip_flag != 1) {
- p_outarray[0]->insert(*(p_outarray[ti]));
- }
+ p_outarray[0]->insert(*(p_outarray[ti]));
delete p_outarray[ti];
p_outarray[ti] = NULL;
vtppoanarray[0]->append(*(vtppoanarray[ti]));
@@ -631,9 +629,7 @@ 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]->skip_flag != 1) {
- p_outarray[0]->insert(*(p_outarray[ti]));
- }
+ p_outarray[0]->insert(*(p_outarray[ti]));
delete p_outarray[ti];
p_outarray[ti] = NULL;
vtppoanarray[0]->append(*(vtppoanarray[ti]));
diff --git a/src/libnptm/outputs.cpp b/src/libnptm/outputs.cpp
index 18276268..48791dc9 100644
--- a/src/libnptm/outputs.cpp
+++ b/src/libnptm/outputs.cpp
@@ -977,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;
}
@@ -3480,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;
}
@@ -5269,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;
}
diff --git a/src/sphere/sphere.cpp b/src/sphere/sphere.cpp
index 44c2a24c..288c259f 100644
--- a/src/sphere/sphere.cpp
+++ b/src/sphere/sphere.cpp
@@ -338,9 +338,7 @@ void sphere(const string& config_file, const string& data_file, const string& ou
// 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]->skip_flag != 1) {
- p_outarray[0]->insert(*(p_outarray[ti]));
- }
+ p_outarray[0]->insert(*(p_outarray[ti]));
delete p_outarray[ti];
p_outarray[ti] = NULL;
vtppoanarray[0]->append(*(vtppoanarray[ti]));
@@ -499,9 +497,7 @@ void sphere(const string& config_file, const string& data_file, const string& ou
// 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]->skip_flag != 1) {
- p_outarray[0]->insert(*(p_outarray[ti]));
- }
+ p_outarray[0]->insert(*(p_outarray[ti]));
delete p_outarray[ti];
p_outarray[ti] = NULL;
vtppoanarray[0]->append(*(vtppoanarray[ti]));
--
GitLab