Elements Indices

[elafmusa]

If i have list of elements for example:
['qf4.1',
'qf4.2',
'qf4.3',
'qf4.4',
'qf4.5',
'qf4.6']
And i want to measure the linear optics functions at these elements, Is there a method that can give me back the Indices of these elements by knowing its names without the need of using the loop, as i did here?
[[for i in used_quads_list:
element_index = get_refpts(ring, i)
lindata0, tune, chrom, lindata = ring.linopt(get_chrom=True, refpts=element_index)
s_pos_ = lindata['s_pos']
s_pos1.append(np.squeeze(s_pos_))]]

[simoneliuzzo]

Dear Elaf,

I think that just:

inds = at.get_refpts(ring, 'qf4.*')
_, _, lo = ring.linopt6(inds)
bx = [el.beta[0] for el in lo]

should work.

note that the pattern is matched using fnmatch (not regexp).

you would have to do some np.concatenate to get the correct inds if your input is a list of elements names

fam_names = ['qf4.1', 'qf4.4', 'qf4.6']
inds = np.concatenate([at.get_refpts(ring,fn) for fn in fam_names])
inds.sort()
_, _, lo = ring.linopt6(inds)
bx = [el.beta[0] for el in lo]

best regards
Simone

[lfarv]

Hello @elafmusa and @simoneliuzzo:

To complement Simone's answer, I'll add that:

• Use get_cells rather that get_refpts: boolean indexing allows unions ("|" operator) and intersections ("&" operator):

  inds  = ring.get_cells(at.checkname('qf4.1') | ring.get_cells(at.checkname('qf4.4') | ...
  _, _, lo = ring.linopt6(inds)
  

  no concatenate, no sort, it's much faster. In your particular case, that should also work:

  inds  = ring.get_cells(at.checkname('qf4.[12456]')
  

  but you can think of things like:

  inds =  ring.get_cells(at.checktype(at.Quadrupole) & ring.get_cells(at.checkname('*ab')
  

  to get all quadrupoles with a name ending in "ab". Boolean indices are really very convenient !

  More generally, get_cells is faster that get_refpts: get_refpts calls get_cells, and then makes a search for True elements, which has usually no interest.
  And later, for indexing into an array, boolean indexing is faster that integer indexing. So you should almost never use get_refpts.

• You can directly extract values without a loop:

  betax = lo.beta[:, 0]
  

[simoneliuzzo]

Dear @lfarv,

thank you for your advise! For the case of @elafmusa it is indeed a better option.

I have tried several times however to use this boolean masking. After making the effort, I constantly revert to indexes. It is very frequent for me to ask myself if the indexes I am using are the correct ones, and with masks this is not trivial to understand.

An example may be printing results. A very frequent check that what I do is correct is: ring[inds[0]].PolynomB[1]
if inds is a mask this is not really working as I want.

Also counting does not work. I want to verify that my indexes are 192. I do inds.shape or len(inds) and I will get always len(ring) as answer.

So, since my daily use of AT is slow by definition (computing DA/MA, etc..) I almost never use masks.

[simoneliuzzo]

* You can directly extract values without a loop:
  ```
  betax = lo.beta[:, 0]
  ```

Thanks! This is an interesting feature of pyAT. In matlab AT it is not the case.

[simoneliuzzo]

  but you can think of things like:
  ```
  inds =  ring.get_cells(at.checktype(at.Quadrupole) & ring.get_cells(at.checkname('*ab')
  ```

Dear @lfarv ,

how would you get for example all elements with field MaxOrder, or with PolynomB > 0

thank you!

best regards
Simone

[elafmusa]

@simoneliuzzo @lfarv Thank you for the useful note!

I am working in a code like this simple example:

quads_families = [['qf4.1', 'qf4.2', ], ['qf4.3', 'qf4.4', ], ['qd4.1', 'qd4.2', ], ['qfd.3', 'qfd.4', ]]

In order to measure the Indices of these elements in quads_families only, should i use a loop instead of " inds = ring.get_cells(at.checktype(at.Quadrupole) & ring.get_cells(at.checkname('*ab')" which will look at the full ring. "

I am thinking about something like, if i am using both inds and full_inds:
For family in quads_families:
inds = ring.get_cells(at.checkname(family[0]) | ring.get_cells(at.checkname(family[1]) | ...
full_inds.append( inds)

[simoneliuzzo]

Dear @elafmusa,

if you organize your family name patterns in a 2D array, I guess there is a good reason. Your issue seams to make an or of all the get_cells. May be one additional loop will do?

quads_families = [['qf4.1', 'qf4.2', ], ['qf4.3', 'qf4.4', ], ['qd4.1', 'qd4.2', ], ['qfd.3', 'qfd.4', ]]

import numpy as np
mask = [False]*(len(ring)+1)
for families in quads_families:
    for fam in families:
        # search for a single family
        mfam = ring.get_cells(at.checkname(fam))
        print(f'mask for familiy {fam} contains {sum(mfam)} elements')
        # add to the global mask
        mask = mask | mfam
        print(f'elements in mask: {sum(mask)}')
        
[print(el.FamName) for el in ring[mask]]

May be @lfarv has better solution?

[lfarv]

Just a comment: operations on masks requires the masks to be numpy arrays of bools. So at line 4 you need:

mask = np.zeros(len(ring)+1, dtype=bool)

[lfarv]

@simoneliuzzo:

Also counting does not work. I want to verify that my indexes are 192. I do inds.shape or len(inds) and I will get always len(ring) as answer.

In python, you have ring.refcount(refpts) with works for any kind of refpts ! But there is no equivalent in Matlab…

[lfarv]

how would you get for example all elements with field MaxOrder

ring.get_cells('MaxOrder') # or
ring.get_cells(at.checkattr('MaxOrder'))

how would you get for example all elements with PolynomB > 0

ring.get_cells(lambda el: hasattr(el,'PolynomB') and el.PolynomB[1] > 0)

or better:

def check_strength(el):
    try:
        strength=el.PolynomB[1]
    except Exception:
        return False
    else:
        return strength > 0

ring.get_cells(check_strength)

[simoneliuzzo]

Nice! thank you @lfarv !
These examples are already part of the docs? I have seldom come across lambda and at.checkattr().
May be this two examples could be added to the help of get_cells?

[lfarv]

An example may be printing results. A very frequent check that what I do is correct is: ring[inds[0]].PolynomB[1]
if inds is a mask this is not really working as I want.

print(ring[inds][0].PolynomB)

Works for any kind of refpts: get all elements, take the 1st one, take PolynomB

[simoneliuzzo]

The parenthesis in the correct place works for both cases! Got it.
I'll give it a try again. I'll keep posted here if I have other cases where I wish to revert to indexes.