updateVoxelBoundarySegments() profiling

[cgyurgyik]

This is called during each iteration when a radial step occurs. It updates the boundary segments for the azimuthal and angular boundaries.

Location in the traversal phase:

The function:

Profiling Call Tree:

As shown, it is taking a large chunk of time.
Some potential fixes:

• Replace grid.sphereCenter().x() with const double sphere_center_x (and similar for y, z) this MIGHT avoid extra lookups.
• Raw for loops require the use of vector::size() and [] operator No single algorithm will be able to conduct what we're doing here, but I may be able to write an algorithm that does the following:
  Given two vectors A,B transform A, B while also using components from both itself and the other.

These are just micro-optimizations at the end of the day. Thinking about changes to the implementation may be necessary to truly reduce the footprint.

Maybe some kind of table look up to reduce calculations, or since voxel sizes are the same for each radial section other than orientation, we can use that information to minimize calculations.

[cgyurgyik]

   std::transform(
            Px_angular.begin(),
            Px_angular.end(),
            Py_angular.begin(),
            Px_angular.begin(),
            [grid, new_r](double& x, double& y)->double{
                const double old_angular_x = grid.sphereCenter().x() - x;
                const double old_angular_y = grid.sphereCenter().y() - y;
                const double delta = new_r / std::sqrt(old_angular_x * old_angular_x + old_angular_y * old_angular_y);
                x = [grid, delta, old_angular_x](double e){ return grid.sphereCenter().x() - old_angular_x * delta;}(x);
                y = [grid, delta, old_angular_y](double e){ return grid.sphereCenter().y() - old_angular_y * delta;}(y);
                return x;
            });
    std::transform(
            Px_azimuthal.begin(),
            Px_azimuthal.end(),
            Pz_azimuthal.begin(),
            Px_azimuthal.begin(),
            [grid, new_r](double& x, double& z)->double{
                const double old_azimuthal_x = grid.sphereCenter().x() - x;
                const double old_azimuthal_z = grid.sphereCenter().z() - z;
                const double delta = new_r / std::sqrt(old_azimuthal_x * old_azimuthal_x +
                                                       old_azimuthal_z * old_azimuthal_z);
                x = [grid, delta, old_azimuthal_x](double e){
                    return grid.sphereCenter().x() - old_azimuthal_x * delta ;}(x);
                z = [grid, delta, old_azimuthal_z](double e){
                    return grid.sphereCenter().z() - old_azimuthal_z * delta ;}(z);
                return x;
            });

Here I've ridden the code above from raw for loops, std::vector::size(), and [] operator. Unfortunately, it only got slower. And arguably less readable :-)

Edit: I should probably be using a reference to the grid, and this may be part of the issue.