storing module type combos / module number combos in dictionary is 2 int keys

[gschramm]

Currently, the ModulePairSGID LUT is a 2D (always symmetric?) array, whereas the module type combinations are encoded as list of lists.
The latter leaves ambiguity whether for a scanner with two module types, to take into account module type combinations:

0,0
1,0
0,1
1,1

or

0,0
1,0
1,1

The latter makes most sense to me because of symmetry.

To avoid ambiguities, the possible combinations could be stored as a dict with two int keys instead of using lists of lists or 2D arrays.

[MaxTousss]

I agree that duplicating that information is a source of errors since some could only write "upper" triangle while one read without checking the order. However, a dictionary seems wasteful for that :( Could we make it a 2D list, albeit the length of the second dimension changes depending on the position in the first list? A little more complex to manipulate, but the complexity is mainly in filling it. Access would be as simple as

if mod1 > mod2: 
    ModulePairSGIDLUT[mod2][mod1 - mod2]
else:
    ModulePairSGIDLUT[mod1][mod2 - mod1]

Or something like that.

[KrisThielemans]

Easiest would be

if mod_type1 > mod_type2: 
    ModulePairSGIDLUT[mod_type2][mod_type1]
else:
    ModulePairSGIDLUT[mod_type1][mod_type2]

However, I doubt this would be correct, as I think we also then need to swap the module_index (see also #52)

There's different issues here:

• can we use dictionaries in yardl? Looks like we can https://microsoft.github.io/yardl/python/language.html#maps
• where should we use dictionaries? (I think @gschramm likes them because it becomes easier to iterate: for key in mydict:... and similar in C++)
• How should we handle the symmetries? That's one for Symmetry in module-pair efficiencies/alive-time #138

[MaxTousss]

Just to make sure: things like ModulePairSGIDLUT and modulePairEfficienciesVectors should be symmetric, right? Looking at the link, it seems like it is unclear XD

For the following, I assume that they should be. In that case, I would again suggest using 2D list, with the nested-list varying in length such that it only encode the diagonal and upper-triangle. Compact and straight-forward, if helper for access is provided.

However, I would see interest in a dict. if we use the ordered-and-flatten ID of pairs and that the -1 are not stored. Then, the key have a use in my mind. If we do that, we could store the data as a 3D array (id1, id2, value) and provide an helper function that get the value of interest. Like:

get_the_thing(id1, id2):
    if id1 > id2:
      id = id2 + id1 * id_max
    else:
      id = id1 + id2 * id_max
    
    if id in  ModulePairSGIDLUT:
      return ModulePairSGIDLUT[id]
    else:
      return -1

[KrisThielemans]

Just to make sure: things like ModulePairSGIDLUT and modulePairEfficienciesVectors should be symmetric, right? Looking at the link, it seems like it is unclear XD

@gschramm and I talked about this, and came to the conclusion it isn't, but we didn't make any notes. sorry. I strongly suggest we discuss further in #138.

[KrisThielemans]

Symmetry is not obvious, and actually incorrect. See #138 (comment). Comments/corrections there please.