During collaboration with @T-Fuchs, we found some issues/ideas that should be addressed to improve the automatic fractionation.

c_min

A minimum concentration c_min is used for calculating local purity profiles which in turn are used for determining the initial values of the optimization problem.
The attribute has a default value of $1\cdot 10^{-3}~mM$ and lives within the SolutionIO class. While this is works for most cases, it would be useful to allow users to specify a custom c_min, specifically for fractionation. Especially for large molecules such as proteins, it might make sense to chose different values. This should be handled by the FractionationOptimization class.

Fractionation Window

Mostly, it's hard to predict, when the elution starts. However, sometimes there are some pre-peaks (e.g. from overloading the column) that we always want to avoid. Since the Fractionator would also try to handle these peaks, this makes the optimization problem unnecessarily complicated. By adding a fractionation window (e.g. start, and end, similar to the Comparator), this could be avoided.

Normalization

Normalization is currently not supported for fractionation, but can be advantageous for concentration profiles with values >> 1 or << 1.

Currently, when calling SolutionIO.normalize(), each component profile is normalized to $1$ using its own maximum value. While this is useful for situations such as shape comparison with reference data, it's problematic when determining the mass/purity of components.
There should be options to:

• Normalize all of the profiles to the max of all components (proportional scaling), or
• Continue normalizing each profile to 1 but keeping track of normalization factors to correct mass

Optimizer Options and Failure Handling

I tried to find reasonable values for optimizer parameters (e.g. Cobyla.rhobeg) that work for most situations. However, it's almost impossible to find parameters that fit all situations.
It is already possible to modify these options in place; this should be made clearer in the docs.
Moreover, when an optimizer fails (e.g. fails to converge), this should be properly handled, e.g. raise a CADETProcessError that could be handled by either taking the best point so far, the initial values or, if ignore_failed=False simply raise an exception. Currently, this failure is silent which is not good practice.