From d80c2524dfc1f955c0d8eba06fe47eca0d5b161a Mon Sep 17 00:00:00 2001 From: willGraham01 <1willgraham@gmail.com> Date: Thu, 11 May 2023 13:40:38 +0100 Subject: [PATCH] Rely on call() operator only --- tdms/src/fields/base.cpp | 6 +- tdms/src/fields/electric.cpp | 14 ++--- tdms/src/fields/magnetic.cpp | 20 +++---- tdms/src/fields/split.cpp | 6 +- tdms/src/fields/td_field_exporter_2d.cpp | 2 +- .../execute_detector_subfunctions.cpp | 12 ++-- .../field_tests/test_Field_interpolation.cpp | 60 +++++++++---------- 7 files changed, 60 insertions(+), 60 deletions(-) diff --git a/tdms/src/fields/base.cpp b/tdms/src/fields/base.cpp index 0aa866e45..e6b3f2810 100644 --- a/tdms/src/fields/base.cpp +++ b/tdms/src/fields/base.cpp @@ -212,9 +212,9 @@ void Field::set_phasors(SplitField &F, int n, double omega, double dt, int Nt) { for (int j = jl; j <= ju; j++) for (int i = il; i <= iu; i++) { - x_m = F.xy[{i, j, k}] + F.xz[{i, j, k}]; - y_m = F.yx[{i, j, k}] + F.yz[{i, j, k}]; - z_m = F.zx[{i, j, k}] + F.zy[{i, j, k}]; + x_m = F.xy(i, j, k) + F.xz(i, j, k); + y_m = F.yx(i, j, k) + F.yz(i, j, k); + z_m = F.zx(i, j, k) + F.zy(i, j, k); int di = i - il; int dj = j - jl; diff --git a/tdms/src/fields/electric.cpp b/tdms/src/fields/electric.cpp index 35e056655..3186254c3 100644 --- a/tdms/src/fields/electric.cpp +++ b/tdms/src/fields/electric.cpp @@ -113,8 +113,8 @@ double ElectricSplitField::interpolate_to_centre_of(AxialDirection d, for (int ind = scheme->first_nonzero_coeff; ind <= scheme->last_nonzero_coeff; ind++) { interp_data[ind] = - xy[{i - scheme->number_of_datapoints_to_left + ind, j, k}] + - xz[{i - scheme->number_of_datapoints_to_left + ind, j, k}]; + xy(i - scheme->number_of_datapoints_to_left + ind, j, k) + + xz(i - scheme->number_of_datapoints_to_left + ind, j, k); } // now run the interpolation scheme and place the result into the output return scheme->interpolate(interp_data); @@ -123,7 +123,7 @@ double ElectricSplitField::interpolate_to_centre_of(AxialDirection d, // if we are in a 2D simulation, we just return the field value at cell // (i, 0, k) since there is no y-dimension to interpolate in. if (tot.j <= 1) { - return yx[{i, 0, k}] + yz[{i, 0, k}]; + return yx(i, 0, k) + yz(i, 0, k); } else {// 3D simulation, interpolation is as normal scheme = &(best_scheme(tot.j, j, pim)); // now fill the interpolation data @@ -132,8 +132,8 @@ double ElectricSplitField::interpolate_to_centre_of(AxialDirection d, for (int ind = scheme->first_nonzero_coeff; ind <= scheme->last_nonzero_coeff; ind++) { interp_data[ind] = - yx[{i, j - scheme->number_of_datapoints_to_left + ind, k}] + - yz[{i, j - scheme->number_of_datapoints_to_left + ind, k}]; + yx(i, j - scheme->number_of_datapoints_to_left + ind, k) + + yz(i, j - scheme->number_of_datapoints_to_left + ind, k); } // now run the interpolation scheme and place the result into the output return scheme->interpolate(interp_data); @@ -146,8 +146,8 @@ double ElectricSplitField::interpolate_to_centre_of(AxialDirection d, for (int ind = scheme->first_nonzero_coeff; ind <= scheme->last_nonzero_coeff; ind++) { interp_data[ind] = - zx[{i, j, k - scheme->number_of_datapoints_to_left + ind}] + - zy[{i, j, k - scheme->number_of_datapoints_to_left + ind}]; + zx(i, j, k - scheme->number_of_datapoints_to_left + ind) + + zy(i, j, k - scheme->number_of_datapoints_to_left + ind); } // now run the interpolation scheme and place the result into the // output diff --git a/tdms/src/fields/magnetic.cpp b/tdms/src/fields/magnetic.cpp index f3f210946..28c85ca74 100644 --- a/tdms/src/fields/magnetic.cpp +++ b/tdms/src/fields/magnetic.cpp @@ -341,8 +341,8 @@ double MagneticSplitField::interpolate_to_centre_of(AxialDirection d, for (int ind = b_scheme->first_nonzero_coeff; ind <= b_scheme->last_nonzero_coeff; ind++) { data_for_first_scheme[ind] = - xy[{i, j, k - b_scheme->number_of_datapoints_to_left + ind}] + - xz[{i, j, k - b_scheme->number_of_datapoints_to_left + ind}]; + xy(i, j, k - b_scheme->number_of_datapoints_to_left + ind) + + xz(i, j, k - b_scheme->number_of_datapoints_to_left + ind); } // now run the interpolation scheme and place the result into the output @@ -368,7 +368,7 @@ double MagneticSplitField::interpolate_to_centre_of(AxialDirection d, int cell_k = k - c_scheme->number_of_datapoints_to_left + kk; // gather the data for interpolating in the z dimension data_for_first_scheme[kk] = - xy[{i, cell_j, cell_k}] + xz[{i, cell_j, cell_k}]; + xy(i, cell_j, cell_k) + xz(i, cell_j, cell_k); } // interpolate in z to obtain a value for the Hx field at position // (i, cell_j+Dy, k) place this into the appropriate index in the @@ -395,7 +395,7 @@ double MagneticSplitField::interpolate_to_centre_of(AxialDirection d, int cell_j = j - b_scheme->number_of_datapoints_to_left + jj; // gather the data for interpolating in the y dimension data_for_first_scheme[jj] = - xy[{i, cell_j, cell_k}] + xz[{i, cell_j, cell_k}]; + xy(i, cell_j, cell_k) + xz(i, cell_j, cell_k); } // interpolate in y to obtain a value for the Hx field at position // (i, j, cell_k+Dz) place this into the appropriate index in the @@ -432,7 +432,7 @@ double MagneticSplitField::interpolate_to_centre_of(AxialDirection d, int cell_k = k - b_scheme->number_of_datapoints_to_left + kk; // gather the data for interpolating in the z dimension data_for_first_scheme[kk] = - yx[{cell_i, j, cell_k}] + yz[{cell_i, j, cell_k}]; + yx(cell_i, j, cell_k) + yz(cell_i, j, cell_k); } // interpolate in z to obtain a value for the Hy field at position // (cell_i+Dx, j, k) place this into the appropriate index in the data @@ -458,7 +458,7 @@ double MagneticSplitField::interpolate_to_centre_of(AxialDirection d, int cell_i = i - c_scheme->number_of_datapoints_to_left + ii; // gather the data for interpolating in the x dimension data_for_first_scheme[ii] = - yx[{cell_i, j, cell_k}] + yz[{cell_i, j, cell_k}]; + yx(cell_i, j, cell_k) + yz(cell_i, j, cell_k); } // interpolate in x to obtain a value for the Hy field at position (i, // j, cell_k+Dz) place this into the appropriate index in the data @@ -481,8 +481,8 @@ double MagneticSplitField::interpolate_to_centre_of(AxialDirection d, for (int ind = b_scheme->first_nonzero_coeff; ind <= b_scheme->last_nonzero_coeff; ind++) { data_for_first_scheme[ind] = - zx[{i - b_scheme->number_of_datapoints_to_left + ind, j, k}] + - zy[{i - b_scheme->number_of_datapoints_to_left + ind, j, k}]; + zx(i - b_scheme->number_of_datapoints_to_left + ind, j, k) + + zy(i - b_scheme->number_of_datapoints_to_left + ind, j, k); } // now run the interpolation scheme and place the result into the output @@ -508,7 +508,7 @@ double MagneticSplitField::interpolate_to_centre_of(AxialDirection d, int cell_j = j - c_scheme->number_of_datapoints_to_left + jj; // gather the data for interpolating in the y dimension data_for_first_scheme[jj] = - zx[{cell_i, cell_j, k}] + zy[{cell_i, cell_j, k}]; + zx(cell_i, cell_j, k) + zy(cell_i, cell_j, k); } // interpolate in y to obtain a value for the Hz field at position // (cell_i+Dx, j, k) place this into the appropriate index in the @@ -535,7 +535,7 @@ double MagneticSplitField::interpolate_to_centre_of(AxialDirection d, int cell_i = i - b_scheme->number_of_datapoints_to_left + ii; // gather the data for interpolating in the x dimension data_for_first_scheme[ii] = - zx[{cell_i, cell_j, k}] + zy[{cell_i, cell_j, k}]; + zx(cell_i, cell_j, k) + zy(cell_i, cell_j, k); } // interpolate in x to obtain a value for the Hz field at position // (i, j, cell_k+Dz) place this into the appropriate index in the diff --git a/tdms/src/fields/split.cpp b/tdms/src/fields/split.cpp index 94ecba1a3..409ac2fb8 100644 --- a/tdms/src/fields/split.cpp +++ b/tdms/src/fields/split.cpp @@ -75,9 +75,9 @@ double SplitField::largest_field_value() { for (int k = 0; k < (tot.k + 1); k++) { for (int j = 0; j < (tot.j + 1); j++) { for (int i = 0; i < (tot.i + 1); i++) { - double x_field = fabs(xy[{i, j, k}] + xz[{i, j, k}]); - double y_field = fabs(yx[{i, j, k}] + yz[{i, j, k}]); - double z_field = fabs(zx[{i, j, k}] + zy[{i, j, k}]); + double x_field = fabs(xy(i, j, k) + xz(i, j, k)); + double y_field = fabs(yx(i, j, k) + yz(i, j, k)); + double z_field = fabs(zx(i, j, k) + zy(i, j, k)); if (largest_value < x_field) { largest_value = x_field; } if (largest_value < y_field) { largest_value = y_field; } if (largest_value < z_field) { largest_value = z_field; } diff --git a/tdms/src/fields/td_field_exporter_2d.cpp b/tdms/src/fields/td_field_exporter_2d.cpp index e6f747125..77ea842b0 100644 --- a/tdms/src/fields/td_field_exporter_2d.cpp +++ b/tdms/src/fields/td_field_exporter_2d.cpp @@ -35,7 +35,7 @@ void TDFieldExporter2D::export_field(SplitField &F, int stride, while (i < F.tot.i) { int k = 0; while (k < F.tot.k) { - array[k][i] = F.xy[{i, 0, k}] + F.xz[{i, 0, k}]; + array[k][i] = F.xy(i, 0, k) + F.xz(i, 0, k); k += stride; } i += stride; diff --git a/tdms/src/simulation_manager/execute_detector_subfunctions.cpp b/tdms/src/simulation_manager/execute_detector_subfunctions.cpp index 5c97e8e00..851f6a3b3 100644 --- a/tdms/src/simulation_manager/execute_detector_subfunctions.cpp +++ b/tdms/src/simulation_manager/execute_detector_subfunctions.cpp @@ -41,11 +41,11 @@ void SimulationManager::compute_detector_functions(unsigned int tind, int m = j - inputs.params.pml.Dyl + (i - inputs.params.pml.Dxl) * (J_tot - inputs.params.pml.Dyu - inputs.params.pml.Dyl); - lv.Ex_t.v[m][0] = inputs.E_s.xy[{i, j, inputs.params.k_det_obs}] + - inputs.E_s.xz[{i, j, inputs.params.k_det_obs}]; + lv.Ex_t.v[m][0] = inputs.E_s.xy(i, j, inputs.params.k_det_obs) + + inputs.E_s.xz(i, j, inputs.params.k_det_obs); lv.Ex_t.v[m][1] = 0.; - lv.Ey_t.v[m][0] = inputs.E_s.yx[{i, j, inputs.params.k_det_obs}] + - inputs.E_s.yz[{i, j, inputs.params.k_det_obs}]; + lv.Ey_t.v[m][0] = inputs.E_s.yx(i, j, inputs.params.k_det_obs) + + inputs.E_s.yz(i, j, inputs.params.k_det_obs); lv.Ey_t.v[m][1] = 0.; } @@ -71,8 +71,8 @@ void SimulationManager::compute_detector_functions(unsigned int tind, j++) for (int i = 0; i < (I_tot - inputs.params.pml.Dxu - inputs.params.pml.Dxl); i++) { - lv.Ex_t.cm[j][i] *= inputs.pupil[j][i] * inputs.D_tilde.x[{im, i, j}]; - lv.Ey_t.cm[j][i] *= inputs.pupil[j][i] * inputs.D_tilde.y[{im, i, j}]; + lv.Ex_t.cm[j][i] *= inputs.pupil[j][i] * inputs.D_tilde.x(im, i, j); + lv.Ey_t.cm[j][i] *= inputs.pupil[j][i] * inputs.D_tilde.y(im, i, j); } /* Now iterate over each frequency we are extracting phasors at. diff --git a/tdms/tests/unit/field_tests/test_Field_interpolation.cpp b/tdms/tests/unit/field_tests/test_Field_interpolation.cpp index e281ad105..d94f956fb 100644 --- a/tdms/tests/unit/field_tests/test_Field_interpolation.cpp +++ b/tdms/tests/unit/field_tests/test_Field_interpolation.cpp @@ -108,12 +108,12 @@ TEST_CASE("E-field interpolation check") { E.imag.z[kk][jj][ii] = 0.; // assign to "time domain" ElectricSplitField - use weighting that sums // to 1 to check addition is behaving as planned - E_split.xy[{ii, jj, kk}] = x_comp_value; - E_split.xz[{ii, jj, kk}] = 0.; - E_split.yx[{ii, jj, kk}] = y_comp_value * .5; - E_split.yz[{ii, jj, kk}] = y_comp_value * .5; - E_split.zx[{ii, jj, kk}] = z_comp_value * .25; - E_split.zy[{ii, jj, kk}] = z_comp_value * .75; + E_split.xy(ii, jj, kk) = x_comp_value; + E_split.xz(ii, jj, kk) = 0.; + E_split.yx(ii, jj, kk) = y_comp_value * .5; + E_split.yz(ii, jj, kk) = y_comp_value * .5; + E_split.zx(ii, jj, kk) = z_comp_value * .25; + E_split.zy(ii, jj, kk) = z_comp_value * .75; } } } @@ -156,8 +156,8 @@ TEST_CASE("E-field interpolation check") { double Ex_interp = E.interpolate_to_centre_of(AxialDirection::X, current_cell) .real(); - Ex_error[{ii - 1, jj, kk}] = Ex_interp - Ex_exact; - Ex_split_error[{ii - 1, jj, kk}] = Ex_split_interp - Ex_exact; + Ex_error(ii - 1, jj, kk) = Ex_interp - Ex_exact; + Ex_split_error(ii - 1, jj, kk) = Ex_split_interp - Ex_exact; } // Ey interpolation @@ -168,8 +168,8 @@ TEST_CASE("E-field interpolation check") { double Ey_interp = E.interpolate_to_centre_of(AxialDirection::Y, current_cell) .real(); - Ey_error[{ii, jj - 1, kk}] = Ey_interp - Ey_exact; - Ey_split_error[{ii, jj - 1, kk}] = Ey_split_interp - Ey_exact; + Ey_error(ii, jj - 1, kk) = Ey_interp - Ey_exact; + Ey_split_error(ii, jj - 1, kk) = Ey_split_interp - Ey_exact; } // Ez interpolation @@ -180,8 +180,8 @@ TEST_CASE("E-field interpolation check") { double Ez_interp = E.interpolate_to_centre_of(AxialDirection::Z, current_cell) .real(); - Ez_error[{kk - 1, jj, ii}] = Ez_interp - Ez_exact; - Ez_split_error[{kk - 1, jj, ii}] = Ez_split_interp - Ez_exact; + Ez_error(kk - 1, jj, ii) = Ez_interp - Ez_exact; + Ez_split_error(kk - 1, jj, ii) = Ez_split_interp - Ez_exact; } } } @@ -203,8 +203,8 @@ TEST_CASE("E-field interpolation check") { // as such, make a new array for safety double jk_errors[Nx - 1], jk_split_errors[Nx - 1]; for (int ii = 0; ii < Nx - 1; ii++) { - jk_errors[ii] = Ex_error[{ii, jj, kk}]; - jk_split_errors[ii] = Ex_split_error[{ii, jj, kk}]; + jk_errors[ii] = Ex_error(ii, jj, kk); + jk_split_errors[ii] = Ex_split_error(ii, jj, kk); } // compute norm-error of this slice double jk_slice_error = euclidean(jk_errors, Nx - 1), @@ -221,8 +221,8 @@ TEST_CASE("E-field interpolation check") { for (int kk = 0; kk < Nz; kk++) { double ik_errors[Ny - 1], ik_split_errors[Ny - 1]; for (int jj = 0; jj < Ny - 1; jj++) { - ik_errors[jj] = Ey_error[{ii, jj, kk}]; - ik_split_errors[jj] = Ey_split_error[{ii, jj, kk}]; + ik_errors[jj] = Ey_error(ii, jj, kk); + ik_split_errors[jj] = Ey_split_error(ii, jj, kk); } double ik_slice_error = euclidean(ik_errors, Ny - 1), ik_split_slice_error = euclidean(ik_split_errors, Ny - 1); @@ -237,8 +237,8 @@ TEST_CASE("E-field interpolation check") { for (int jj = 0; jj < Ny; jj++) { double ij_errors[Nz - 1], ij_split_errors[Nz - 1]; for (int kk = 0; kk < Nz - 1; kk++) { - ij_errors[kk] = Ez_error[{ii, jj, kk}]; - ij_split_errors[kk] = Ez_split_error[{ii, jj, kk}]; + ij_errors[kk] = Ez_error(ii, jj, kk); + ij_split_errors[kk] = Ez_split_error(ii, jj, kk); } double ij_slice_error = euclidean(ij_errors, Nz - 1), ij_split_slice_error = euclidean(ij_split_errors, Nz - 1); @@ -349,12 +349,12 @@ TEST_CASE("H-field interpolation check") { H.real.z[kk][jj][ii] = 0.; // assign to "time domain" ElectricSplitField - use weighting that sums // to 1 to check addition is behaving as planned - H_split.xy[{ii, jj, kk}] = x_comp_value; - H_split.xz[{ii, jj, kk}] = 0.; - H_split.yx[{ii, jj, kk}] = y_comp_value * .25; - H_split.yz[{ii, jj, kk}] = y_comp_value * .75; - H_split.zx[{ii, jj, kk}] = z_comp_value * .125; - H_split.zy[{ii, jj, kk}] = z_comp_value * .875; + H_split.xy(ii, jj, kk) = x_comp_value; + H_split.xz(ii, jj, kk) = 0.; + H_split.yx(ii, jj, kk) = y_comp_value * .25; + H_split.yz(ii, jj, kk) = y_comp_value * .75; + H_split.zx(ii, jj, kk) = z_comp_value * .125; + H_split.zy(ii, jj, kk) = z_comp_value * .875; } } } @@ -398,8 +398,8 @@ TEST_CASE("H-field interpolation check") { double Hx_interp = H.interpolate_to_centre_of(AxialDirection::X, current_cell) .imag(); - Hx_error[{ii, jj - 1, kk - 1}] = Hx_interp - Hx_exact; - Hx_split_error[{ii, jj - 1, kk - 1}] = Hx_split_interp - Hx_exact; + Hx_error(ii, jj - 1, kk - 1) = Hx_interp - Hx_exact; + Hx_split_error(ii, jj - 1, kk - 1) = Hx_split_interp - Hx_exact; } // Hy interpolation @@ -410,8 +410,8 @@ TEST_CASE("H-field interpolation check") { double Hy_interp = H.interpolate_to_centre_of(AxialDirection::Y, current_cell) .imag(); - Hy_error[{ii - 1, jj, kk - 1}] = Hy_interp - Hy_exact; - Hy_split_error[{ii - 1, jj, kk - 1}] = Hy_split_interp - Hy_exact; + Hy_error(ii - 1, jj, kk - 1) = Hy_interp - Hy_exact; + Hy_split_error(ii - 1, jj, kk - 1) = Hy_split_interp - Hy_exact; } // Hz interpolation @@ -422,8 +422,8 @@ TEST_CASE("H-field interpolation check") { double Hz_interp = H.interpolate_to_centre_of(AxialDirection::Z, current_cell) .imag(); - Hz_error[{ii - 1, jj - 1, kk}] = Hz_interp - Hz_exact; - Hz_split_error[{ii - 1, jj - 1, kk}] = Hz_split_interp - Hz_exact; + Hz_error(ii - 1, jj - 1, kk) = Hz_interp - Hz_exact; + Hz_split_error(ii - 1, jj - 1, kk) = Hz_split_interp - Hz_exact; } } }