Corrector magnet calibration error

[SebastienJoly]

I would like to have the possibility of adding calibration errors to the corrector magnets (CM). That way, the strength of a CM would be modulated by a factor (1 - CM_error), where CM_error is a relative error sampled randomly.
It is equivalent to the attribute "CalError" in the BPM objects.

We can add an attribute to the register_magnets() function, but we need to make sure it is only being used when at least one of the HCM/VCM attributes is supplied.

If anyone has an idea on how to implement this elegantly, I am interested!

[kparasch]

This is already there, see the attached example (using at.Corrector). With at.Corrector the way to do this is slightly dirty because you have to define PolynomB and PolynomA in the corrector object. These are unused by at, but also shows a number that is actually incosistent with PolynomB/A of an equivalent at.Multipole. It will also show the integrated strength even for thick elements.

import at
import numpy as np
from pySC.core.simulated_commissioning import SimulatedCommissioning
from pySC.utils import logging_tools

LOGGER = logging_tools.get_logger(__name__)

length = 0.1

cthick = at.elements.Corrector('cthick', length, [0., 0.])
ring = at.lattice.Lattice([cthick], energy=1)

cthick.PolynomB = np.zeros(2)
cthick.PolynomA = np.zeros(2)
cm_id = 0
cm_ids = [cm_id]
cm_limit = 2
CalError = 1e-2

SC = SimulatedCommissioning(ring)

SC.register_magnets(cm_ids,
                    HCM=cm_limit,
                    VCM=cm_limit,
                    CalErrorB=np.array([CalError]),
                    CalErrorA=np.array([CalError]),
                    )

SC.apply_errors()
print(SC.RING[cm_id].CalErrorB[0], SC.RING[cm_id].CalErrorA[0])
print(SC.RING[cm_id].KickAngle[0], SC.RING[cm_id].KickAngle[1])

setpoint = 1

SC.set_cm_setpoints(cm_ids, setpoint, skewness=False)
SC.set_cm_setpoints(cm_ids, setpoint, skewness=True)
print(SC.RING[cm_id].KickAngle[0] - setpoint, SC.RING[cm_id].KickAngle[1] - setpoint)

print('Now trying to cross cm limit')
SC.set_cm_setpoints(cm_ids, cm_limit*1.1, skewness=False)

[SebastienJoly]

I see what you have done there. You took advantage of the CalErrorA/B to add a calibration error. However, this may work for stand alone but not always for embedded correctors.
Especially if a Dipole also has CM. Then, we should be able to define CalErrorA/B and CMCalErrorA/B which are different, yet correctly applied to the element.

[kparasch]

Can you give me an example of an embedded corrector?

[SebastienJoly]

Yes, I tried to implement the CMCalError through this example. Here, I assume a sextupole (with zero PolynomA/B), horizontal and vertical CM and a calibration error (not currently in pySC):

import numpy as np
import at
from pySC.core.simulated_commissioning import SimulatedCommissioning
from pySC.utils import sc_tools, at_wrapper

toy = at.Multipole('toy', length=0.5, poly_a=np.zeros(3), poly_b=np.zeros(3))
toy_ring = at.Lattice([toy], energy=2.5e9)

sc = SimulatedCommissioning(toy_ring)

sc.register_magnets(sc_tools.ords_from_regex(sc.RING, 'toy'),
                    HCM=1,
                    VCM=1,
                    CMCalError=np.array([5e-2, 5e-2]),
                   )
                    
sc.apply_errors()
sc.verify_structure()

sc.set_cm_setpoints(sc.ORD.VCM, 1e-5, skewness=True)
sc.set_cm_setpoints(sc.ORD.HCM, 1e-5, skewness=False)

My goal is to change the CM setpoints with the last two lines and obtain the setpoints with the corresponding calibration error. I can create a draft PR to show you what I have.

[kparasch]

In that case you could also just do:

SC.register_magnets(sc_tools.ords_from_regex(sc.RING, 'toy'),
                    HCM=1,
                    VCM=1,
                    CalErrorB=np.array([5e-2, 0, 0]),
                    CalErrorA=np.array([5e-2, 0, 0]),
                    )

[SebastienJoly]

Yes, and now how do you do if the magnet is a Dipole with embedded CM, with both field and CM calibration errors?
We would need different attributes acting in parallel on the final SetPointA/B.