Flow Integration

The FRG flow is integrated by successive calls to diverge_flow_step_euler(). Before carrying out this integration, users must allocate a diverge_flow_step_t object using diverge_flow_step_init(). We explicitly leave the construction of the (Euler) integration loop to the users, in order to adjust step sizes etc. by hand.

struct diverge_euler_t

simple structure to support user-driven Euler integration with adaptive step size. The step size is chosen as \(d\Lambda = \max[ \min(B_\mathrm{fac}, B_\mathrm{fac-sc}), d\Lambda_\mathrm{min} ]\).

double Lambda

current scale \(\Lambda\)

double dLambda

current differential scale \(d\Lambda\)

double Lambda_min

minimal scale \(\Lambda_\mathrm{min}\)

double dLambda_min

absolute minimal differentail scale \(d\Lambda_\mathrm{min}\)

double dLambda_fac

\(d\Lambda_\mathrm{fac}\) defines an upper bound \(B\) for the step width as \(B_\mathrm{fac} = d\Lambda_\mathrm{fac} \cdot \Lambda\).

double dLambda_fac_scale

\(d\Lambda_{\mathrm{fac-sc}}\) additional scaling factor for the calculation of the width of the next step, used as an upper bound \(B\) for the step-width: \(B_\mathrm{fac-sc} = d\Lambda_\mathrm{fac-sc} / V_\mathrm{max} \cdot \Lambda\)

double maxvert

maximum vertex value

double maxvert_hard_limit

hard limit for maximum vertex value

index_t niter

number of iterations

index_t maxiter

maximum number of iterations

index_t consider_maxvert_iter_start

consider diverge_euler_t.maxvert only after this iteration

double consider_maxvert_lambda

consider diverge_euler_t.maxvert only after passing this value of \(\Lambda\)

diverge_euler_t diverge_euler_defaults_CPP(void)

returns default values for the Euler integrator in C/C++/Python, see diverge_euler_defaults for values.

bool diverge_euler_next(diverge_euler_t *de, double Vmax)

performs adaptive step, without calling any diverge_flow_step_t related routines. example usage:

// diverge_flow_step_t* st = ...;
diverge_euler_t eu = diverge_euler_defaults_CPP();
double vertmax = 0.0;
do {
    diverge_flow_step_euler( st, eu.Lambda, eu.dLambda );
    diverge_flow_step_vertmax( st, &vertmax );
} while (diverge_euler_next(&eu, vertmax));

index_t diverge_euler_nsteps_anticip(diverge_euler_t eu)

returns the anticipated number of steps for the settings eu

static const diverge_euler_t diverge_euler_defaults

defaults struct accessible only in C, because C++ does not allow named member initialization. Look the values up in the source (linked!).