RingParameters default

[simoneliuzzo]

I am looping several ouputs of envelope_parameters() in order to extract data for an historgram.

For the cases where the function envelope_parameters() failed I have set to None the output.

This choice was rather inconvenient. I would make much better use of a RingParameters() class instance with None or np.nan for every field that was not computed.

Is this possible?

I tried to simply instantiate rp = RingParameters() but this gives a class instance with only the private property _props

An example of my desired output:

rp = RingParameters(default=np.nan)
rp.tunes = [nan nan nan]
rp.emittances = [nan nan nan]

... for all parameters that may be computed by envelope_parameters() or radiation_parameters()

I would need no change of envelope_parameters() or radiation_parameters(). Simply a way to instantiate an empty parameters structure.

[simoneliuzzo]

the same would be useful for the output of linopt

[simoneliuzzo]

nan_envelope = at.RingParameters()
 nan_envelope.__dict__ = {'E0': np.nan,
                          'U0': np.nan,
                          'tunes6': [np.nan]*3,
                          'emittances': [np.nan]*3,
                          'J': [np.nan]*3,
                          'Tau': [np.nan]*3,
                          'sigma_e': np.nan,
                          'sigma_l': np.nan,
                          'voltage': np.nan,
                          'phi_s': np.nan,
                          'fs': np.nan
                          }

 nan_ringdata = np.recarray((1,),
                            dtype=[('tunes', '<f8', (3, )),
                                   ('chromaticity', '<f8', (3, ))])

 nan_linopt6 = np.recarray(indexes['bpms'].shape,
                              dtype=[('alpha', '<f8', (2,)),
                                      ('beta', '<f8', (2,)),
                                      ('mu', '<f8', (3,)),
                                      ('R', '<f8', (3, 6, 6)),
                                      ('A', '<f8', (6, 6)),
                                      ('dispersion', '<f8', (4,)),
                                      ('closed_orbit', '<f8', (6,)),
                                      ('M', '<f8', (6, 6)),
                                      ('s_pos', '<f8')])
 for el in nan_linopt6:
     el.s_pos = np.nan * el.s_pos
     el.M = np.nan * el.M
     el.alpha = np.nan * el.alpha
     el.beta = np.nan * el.beta
     el.mu = np.nan * el.mu
     el.closed_orbit = np.nan * el.closed_orbit
     el.dispersion = np.nan * el.dispersion
     el.A = np.nan * el.A
     el.R = np.nan * el.R

[lfarv]

Not sure it's the best way to deal with the problem. I would rather through an exception in case of failure and deal with the exception in the calling function…

[simoneliuzzo]

Dear @lfarv,

this is exactly what I do.

The dealing of the exception is to assign nan parameters structures as above.

I build them myself, but I think it could be useful in other contexts.

[lfarv]

OK, but then in the exception handler, why forcing nan's rather that simply ignoring the result ? Do nan's have any use ?

Anyway, I don't know any simple way to populate the objects, other than what you do (though it may exist !)

[lfarv]

Also, note that there is no exhaustive list of RingParameter attributes: radiation_parameters sets some, envelope_parameters adds another set, and future functions may add more…
Initially, a RingParameter instance has no instance attribute (only the private _props class attribute).

SIde remark: rather that using the __dict__ special attribute of an object, use the built-in vars() function.

[lfarv]

Example:

nan_envelope = at.RingParameters()
vars(nan_envelope).update({'E0': np.nan,
                          'U0': np.nan,
                          'tunes6': [np.nan]*3,
                          'emittances': [np.nan]*3,
                          'J': [np.nan]*3,
                          'Tau': [np.nan]*3,
                          'sigma_e': np.nan,
                          'sigma_l': np.nan,
                          'voltage': np.nan,
                          'phi_s': np.nan,
                          'fs': np.nan
                          })

[simoneliuzzo]

below an example of code to compute betabeating and do not stop but continue with nan output

def get_optics_vs_reference(r0, r, ind_bpms):
    """
    computes optics parameters and print them
    """

    nan_envelope = at.RingParameters()
    vars(nan_envelope).update({'E0': np.nan,
                             'U0': np.nan,
                             'tunes6': [np.nan]*3,
                             'emittances': [np.nan]*3,
                             'J': [np.nan]*3,
                             'Tau': [np.nan]*3,
                             'sigma_e': np.nan,
                             'sigma_l': np.nan,
                             'voltage': np.nan,
                             'phi_s': np.nan,
                             'fs': np.nan
                             })

    nan_ringdata = np.recarray((1,),
                               dtype=[('tunes', '<f8', (3, )),
                                      ('chromaticity', '<f8', (3, ))])

    nan_linopt6 = np.recarray(ind_bpms.shape,
                                 dtype=[('alpha', '<f8', (2,)),
                                         ('beta', '<f8', (2,)),
                                         ('mu', '<f8', (3,)),
                                         ('R', '<f8', (3, 6, 6)),
                                         ('A', '<f8', (6, 6)),
                                         ('dispersion', '<f8', (4,)),
                                         ('closed_orbit', '<f8', (6,)),
                                         ('M', '<f8', (6, 6)),
                                         ('s_pos', '<f8')])
    try:
        _, _, opt0 = r0.linopt6(ind_bpms)
    except Exception:
        opt0 = nan_linopt6

    radstate = r0.radiation
    r0.radiation_on()
    try:
        params = r0.envelope_parameters()
    except Exception:
        params = nan_envelope

    if not radstate:
        r0.radiation_off()

    bh0 = np.array([l.beta[0] for l in opt0])
    bv0 = np.array([l.beta[1] for l in opt0])
    dh0 = np.array([l.dispersion[0] for l in opt0])
    dv0 = np.array([l.dispersion[2] for l in opt0])
    eh0 = params.emittances[0]
    ev0 = params.emittances[1]

    try:
        _, _, opt = r.linopt6(ind_bpms)
    except Exception:
        opt = nan_linopt6

    radstate = r.radiation
    r.radiation_on()
    try:
        params = r.envelope_parameters()
    except Exception:
        params = nan_envelope

    if not radstate:
        r.radiation_off()

    bh = np.array([l.beta[0] for l in opt])
    bv = np.array([l.beta[1] for l in opt])
    dh = np.array([l.dispersion[0] for l in opt])
    dv = np.array([l.dispersion[2] for l in opt])
    eh = params.emittances[0]
    ev = params.emittances[1]

    bbh = (bh - bh0) / bh0
    bbv = (bv - bv0) / bv0
    ddh = (dh - dh0)
    ddv = (dv - dv0)
    deh = (eh - eh0)
    dev = (ev - ev0)

    print(f'beta-beating:     H {np.std(bbh)*100:.2f}%      V {np.std(bbv)*100:.2f}% ')
    print(f'delta dispersion: H {np.std(ddh)*1000:.2f}mm     V {np.std(ddv)*1000:.2f}mm ')
    print(f'emittance:  H {eh * 1e12:.2f}pmrad  V {ev * 1e12:.2f}pmrad ')

    return bbh, bbv, ddh, ddv, eh, ev