`cross_section` is slow 🐌

[StFroese]

Calling cross_section is much slower than accessing the inel_or_prod_cross_section since cross_sections uses the temporary_kinematics context manager which resets the kinematic to the initial one. For all models the reset to the old kinematics also recalculates the cross section of the old kinematics, hence its way faster to set the kinematics by hand and access the already computed once.

In [2]: from chromo.kinematics import FixedTarget
   ...: from chromo.models import Sibyll23e

In [3]: kin_init = FixedTarget(100, 2212, 'O16')
   ...: kin = FixedTarget(80, 2212, 'O16')
   ...:
   ...:
   ...: sib = Sibyll23e(kin_init)

In [4]: def cs(mod, kin):
   ...:     return mod.cross_section(kin).prod
   ...:
   ...: def cs_fast(mod, kin):
   ...:     mod.kinematics = kin
   ...:     return mod._inel_or_prod_cross_section
   ...:
In [5]: %timeit cs(sib, kin)
992 μs ± 252 ns per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

In [6]: %timeit cs_fast(sib, kin)
332 μs ± 219 ns per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

In [8]: cs(sib, kin) == cs_fast(sib, kin)
Out[8]: True

[StFroese]

Which means we should reset to the cached kinematics here in the last rather than running the whole setter
https://github.com/impy-project/chromo/blob/e9310e838772ed95c848541fc34a23ac679eda21/src/chromo/common.py#L1012-L1015C13

[StFroese]

Ok it's actually worse than I thought haha.

So when calling cross_section the _temporary_kinematics context manager is used:

        with self._temporary_kinematics(kin):
            kin2 = self.kinematics
            if isinstance(kin2.p2, CompositeTarget):
                cross_section = CrossSectionData(0, 0, 0, 0, 0, 0, 0)
                kin3 = copy.copy(kin2)
                for component, fraction in zip(kin2.p2.components, kin2.p2.fractions):
                    kin3.p2 = component
                    # this calls cross_section recursively, which is fine
                    cross_section._mul_radd(
                        fraction, self._cross_section(kin3, max_info=max_info)
                    )
                return cross_section
            return self._cross_section(kin, max_info=max_info)

When entering the context the new kinematics are set:

    def _temporary_kinematics(self, kin):
        if kin is None:
            yield
        else:
            prev = copy.copy(self.kinematics)
            self.kinematics = kin # <------- this line here
            yield
            self.kinematics = prev

If we check out the setter of this we see that each time the cross_section is called again!

    @kinematics.setter
    def kinematics(self, kin):
        self._check_kinematics(kin)
        self._kinematics = kin
        self._set_kinematics(kin)


        if (kin.p1.is_nucleus and kin.p1.A > 1) or (kin.p2.is_nucleus and kin.p2.A > 1):
            self._inel_or_prod_cross_section = self.cross_section().prod
        else:
            self._inel_or_prod_cross_section = self.cross_section().inelastic

same is happening when the context is exited.
So the cross section is actually calculated three times!!!!