Using a boost::numeric::odeint stepper inside a complicated class - c++

Question

I have an extremely convoluted system of numerical rate equations, which are to be solved by the class ElectronSolver. The electron state is handled by a separate class state_type, not shown here.
A simplified template of the problem class appears as
ElectronSolver.h
class ElectronSolver {
public:
ElectronSolver(const char* filename, ofstream& log);
void solve();
void print(const std::string& fname);
std::vector<double> T; // Times, in fs
std::vector<state_type> Y; // stores the state_t's
private:
// steps, State, value, Derivative, Time, Algebra
adams_bashforth_moulton< 5, state_type, double, state_type, double, vector_space_algebra > abm;
void set_initial_conditions();
// Model parameters
PhotonFlux pf;
void sys(const state_type& s, state_type& sdot, const double t);
};
ElectronSolver.cpp
void ElectronSolver::set_initial_conditions(){
// Set the initial T such that pulse peak occurs at T=0
T[0] = -timespan/2;
Y[0] = state_type(Store, num_elec_points);
abm.initialize( sys, Y[0], T[0], dt ); // This line produces an error
}
void ElectronSolver::sys(const state_type& s, state_type& sdot, const double t){
// complicated system modifying sdot
sdot.flux += pf(t)*s.flux;
}
However, some research revealed why the marked line throws a compile error.
As far as I can understand sys as declared here must be called "on a class", so cannot simply be passed as a reference. This question got around that by declaring sys as static, but that won't work here since I'm relying on calling other members of ElectronSolver in sys.
There is little concievable reason that I would need multiple instances of ElectronSolver, but I would like to leave the option there in case any code maintainers want to have two different electron models.
As far as I can tell, I have four options:
make everything sys needs static (less than desirable due to ElectronSolver inheriting from other classes, but doable)
Construct some kind of a wrapper for the sys function (possibly has a performance hit, and more to the point, I don't know how to do this)
Implement the ODE stepper myself to avoid the headaches of using boost.
????
Which solution strikes the best bargain between
- Performance (though the largest performance bottleneck is probably the time it takes sys to execute)
- Code elegance
- Modularity
?

Answer 1

Whether or not you want to continue using boost is a decision only you can make, but it's easy to create a wrapper with no performance hit.
You'll want to wrap sys in a lambda that captures this. This should not have a performance hit, as the lambda will be inlined when optimizations are turned on.
You would call it like this:
abm.initialize(
[this](const state_type& s, state_type& sdot, const double t) {
this->sys(s, sdot, t);
},
Y[0],
T[0],
dt
);
The lambda is basically an implicit wrapper struct that holds a reference to this and defines an operator()(const state_type& s, state_type& sdot, const double t).
I created an example in godbolt that shows this, simplifying and filling in your code where necessary for the example. If you change the optimization between -O0 and -O3 you can see the lambda code is stripped away and the inner method is fully inlined.
Another option is use std::bind to create a bare function out of the member function:
abm.initialize(
std::bind(&ElectronSolver::sys, std::ref(*this), _1, _2, _3),
Y[0],
T[0],
dt
);
along with this elsewhere:
#include <functional>
using namespace std::placeholders;
to get all the symbols into scope. std::bind creates a new function where the some arguments are already filled in. In this case the implicit first argument, the object itself, is filled in with a reference to this. The rest of the arguments are given special placeholders to indicate the new function will fill them in with its arguments. The std::ref, forces taking this by reference rather than by copy. This method will also have zero overhead.