Define parameter(s) to restrict some of the possible module pairs when setting the detection efficiencies - make the set-up of detection efficiencies optional

[nkarakatsanis]

I would suggest we add a restiction parameter definition (in JSON files as well).
For example to restrict coincidences in xy planes:
scannerGeometry.min_rsec_xy_diff=2 //minimum rsector index difference allowed in coincidence in xy (unsigned int)
Then when we calculate num_SGIDs, we could define:
assert (min_rsec_xy_diff>=0 && min_rsec_xy_diff<n_rsec_xy);
unsigned int n_rsec_xy_fan; //total number of modules allowed in coincidence with a given module in xy at a given angle
if scannerGeometry.min_rsec_xy_diff==1 n_rsec_xy_fan=scannerGeometry.n_rsec_xy-1
else n_rsec_xy_fan=scannerGeometry.n_rsec_xy-2*scannerGeometry.min_rsec_xy_diff;
const unsigned int num_SGIDs = scannerGeometry.n_rsec_z * scannerGeometry.n_rsec_z * n_rsec_xy_fan;

I find more intuitive to ask a user for the parameter "min_rsec_xy_diff" and then calculate "n_rsec_xy_fan" as opposed to directly asking for "n_rsec_xy_fan".

We also need to consider a method to also restrict the size of the SGID LUT accordingly as it is determined by the number of possible module pairs.

Furthermore, we may need to make optional the set of detection efficiencies given the relatively large size of the header file if not enough symmetries are considered. This could be implemeted as a cmd option.

[nkarakatsanis]

Reagrding taking into accoun the "min_rsec_xy_diff" or "fan_size" when building the module_pair_SGID_LUT @KrisThielemans suggested the following piece of code:

constexpr petsird::TypeOfModule type_of_module{0};
  const auto NZ = NUM_MODULES_ALONG_AXIS;
  auto& module_pair_SGID_LUT = (*scanner.detection_efficiencies.module_pair_sgidlut)[type_of_module][type_of_module];
  module_pair_SGID_LUT = yardl::NDArray<int, 2>({ num_modules, num_modules });

  int num_SGIDs = 0;
  {
    for (unsigned int mod1 = 0; mod1 < num_modules; ++mod1)
      {
        for (unsigned int mod2 = 0; mod2 < num_modules; ++mod2)
          {
            // const auto z1 = mod1 % NZ;
            const auto a1 = mod1 / NZ;
            // const auto z2 = mod2 % NZ;
            const auto a2 = mod2 / NZ;
            if (std::abs(2 * std::abs(int(a1) - int(a2)) - NUM_MODULES_ALONG_RING) > fan_size)
              {
                module_pair_SGID_LUT(mod1, mod2) = -1;
              }
            else
              {
                module_pair_SGID_LUT(mod1, mod2) = num_SGIDs++;
              }
          }
      }
  }