_GTestDigiEventSelector.cxx

Go to the documentation of this file.

/* Copyright (C) 2022 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Dominik Smith [committer] */
 
#include "MicrosliceDescriptor.hpp"
#include "algo/evselector/DigiEventSelector.h"
#include "algo/evselector/DigiEventSelectorConfig.h"
#include "algo/global/ParFiles.h"
#include "algo/global/RecoParFiles.h"
#include "gtest/gtest-spi.h"
#include "gtest/gtest.h"
 
#include <unordered_set>
 
#include <yaml-cpp/yaml.h>
 
using namespace cbm::algo;
 
// FIXME: This test should be rewritten for main CBM
 
TEST(_GTestDigiEventSelector, CheckDigiEventSelectorAlgorithmSimple)
{
  SCOPED_TRACE("CheckDigiEventSelectorAlgorithSimple");
 
 
  // --- Test number of digis per system
  size_t nBmon  = 1;
  size_t nSts   = 2;
  size_t nMuch  = 3;
  size_t nRich  = 4;
  size_t nTrd   = 5;
  size_t nTrd2d = 6;
  size_t nTof   = 7;
  size_t nPsd   = 8;
  size_t nFsd   = 9;
 
  DigiEvent event;
  for (size_t i = 0; i < nBmon; i++)
    event.fBmon.push_back(CbmBmonDigi());
  for (size_t i = 0; i < nSts; i++)
    event.fSts.push_back(CbmStsDigi());
  for (size_t i = 0; i < nMuch; i++)
    event.fMuch.push_back(CbmMuchDigi());
  for (size_t i = 0; i < nRich; i++)
    event.fRich.push_back(CbmRichDigi());
  for (size_t i = 0; i < nTrd; i++)
    event.fTrd.push_back(CbmTrdDigi());
  for (size_t i = 0; i < nTrd2d; i++)
    event.fTrd2d.push_back(CbmTrdDigi());
  for (size_t i = 0; i < nTof; i++)
    event.fTof.push_back(CbmTofDigi());
  for (size_t i = 0; i < nPsd; i++)
    event.fPsd.push_back(CbmPsdDigi());
  for (size_t i = 0; i < nFsd; i++)
    event.fFsd.push_back(CbmFsdDigi());
 
  // Create a reco setup, which contains mTOF versions for nickel-2022 (but for some reason with 8 STS stations)
  // NOTE: in this test, the setup does not contain information on the full and active volumes,
  //       only tracking station ID mappings
  // FIXME: Provide a path to the file
  auto recoSetup = std::make_shared<RecoSetup>();
  {
    {
      std::pair<std::vector<GeoVolume>, std::vector<GeoVolume>> dummyStationVols;
      std::vector<std::pair<uint32_t, int>> trkStationId = {
        {std::numeric_limits<uint32_t>::max(), 0},  // unit 0
        {std::numeric_limits<uint32_t>::max(), 1},  // unit 1
        {std::numeric_limits<uint32_t>::max(), 2},  // unit 2
        {std::numeric_limits<uint32_t>::max(), 3},  // unit 3
        {std::numeric_limits<uint32_t>::max(), 4},  // unit 4
        {std::numeric_limits<uint32_t>::max(), 5},  // unit 5
        {std::numeric_limits<uint32_t>::max(), 6},  // unit 6
        {std::numeric_limits<uint32_t>::max(), 7},  // unit 7
        {std::numeric_limits<uint32_t>::max(), 8}   // unit 8
      };
      recoSetup->SetSts(std::move(sts::RecoSetupUnit(std::move(dummyStationVols), std::move(trkStationId))));
    }
    {  // TOF
      using SmTypeInfo_t = tof::TrkStationIdMap::SmTypeInfo;
      std::pair<std::vector<GeoVolume>, std::vector<GeoVolume>> dummyStationVols;
      std::vector<SmTypeInfo_t> smTypeRpcMap = {
        SmTypeInfo_t{.offset = 0, .nSm = 5, .nRpc = 5},   // iSmType 0:  N = 25
        SmTypeInfo_t{.offset = 25, .nSm = 0, .nRpc = 3},  // iSmType 1:  N = 0
        SmTypeInfo_t{.offset = 25, .nSm = 1, .nRpc = 5},  // iSmType 2:  N = 5
        SmTypeInfo_t{.offset = 30, .nSm = 0, .nRpc = 1},  // iSmType 3:  N = 0
        SmTypeInfo_t{.offset = 30, .nSm = 0, .nRpc = 1},  // iSmType 4:  N = 0
        SmTypeInfo_t{.offset = 30, .nSm = 1, .nRpc = 1},  // iSmType 5:  N = 1
        SmTypeInfo_t{.offset = 31, .nSm = 1, .nRpc = 2},  // iSmType 6:  N = 2
        SmTypeInfo_t{.offset = 33, .nSm = 1, .nRpc = 2},  // iSmType 7:  N = 2
        SmTypeInfo_t{.offset = 35, .nSm = 0, .nRpc = 1},  // iSmType 8:  N = 0
        SmTypeInfo_t{.offset = 35, .nSm = 1, .nRpc = 2}   // iSmType 9:  N = 2
      };
      std::vector<int> trkStationIdMap = {
        0,  0, 0, 0, 0, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3,  // iSmType 0
        2,  2, 2, 2, 2,                                                              // iSmType 2
        -1,                                                                          // iSmType 5
        1,  1,                                                                       // iSmType 6
        1,  1,                                                                       // iSmType 7
        1,  2                                                                        // iSmType 9
      };
      tof::TrkStationIdMap stationIdMap(std::move(smTypeRpcMap), std::move(trkStationIdMap));
      recoSetup->SetTof(std::move(tof::RecoSetupUnit(std::move(dummyStationVols), std::move(stationIdMap))));
    }
  }
 
  YAML::Node node;
  node["minDigis"][std::string(cbm::util::ToString(ECbmModuleId::kBmon))]  = nBmon;
  node["minDigis"][std::string(cbm::util::ToString(ECbmModuleId::kSts))]   = nSts;
  node["minDigis"][std::string(cbm::util::ToString(ECbmModuleId::kMuch))]  = nMuch;
  node["minDigis"][std::string(cbm::util::ToString(ECbmModuleId::kRich))]  = nRich;
  node["minDigis"][std::string(cbm::util::ToString(ECbmModuleId::kTrd))]   = nTrd;
  node["minDigis"][std::string(cbm::util::ToString(ECbmModuleId::kTrd2d))] = nTrd2d;
  node["minDigis"][std::string(cbm::util::ToString(ECbmModuleId::kTof))]   = nTof;
  node["minDigis"][std::string(cbm::util::ToString(ECbmModuleId::kPsd))]   = nPsd;
  node["minDigis"][std::string(cbm::util::ToString(ECbmModuleId::kFsd))]   = nFsd;
 
  {
    // --- Check with created numbers of digis - should pass
    cbm::algo::evbuild::DigiEventSelectorConfig config(node);
    cbm::algo::evbuild::DigiEventSelector select(config);
    select.RegisterSetup(recoSetup);
    EXPECT_EQ(select(event), true);
  }
 
  {
    // --- Increment Bmon - should fail
    node["minDigis"][std::string(cbm::util::ToString(ECbmModuleId::kBmon))] = nBmon + 1;
    cbm::algo::evbuild::DigiEventSelectorConfig config(node);
    cbm::algo::evbuild::DigiEventSelector select(config);
    select.RegisterSetup(recoSetup);
    EXPECT_EQ(select(event), false);
  }
 
  {
    // --- Increment STS - should fail
    node["minDigis"][std::string(cbm::util::ToString(ECbmModuleId::kSts))] = nSts + 1;
    cbm::algo::evbuild::DigiEventSelectorConfig config(node);
    cbm::algo::evbuild::DigiEventSelector select(config);
    select.RegisterSetup(recoSetup);
    EXPECT_EQ(select(event), false);
  }
 
  {
    // --- Increment MUCH - should fail
    node["minDigis"][std::string(cbm::util::ToString(ECbmModuleId::kMuch))] = nMuch + 1;
    cbm::algo::evbuild::DigiEventSelectorConfig config(node);
    cbm::algo::evbuild::DigiEventSelector select(config);
    select.RegisterSetup(recoSetup);
    EXPECT_EQ(select(event), false);
  }
 
  {
    // --- Increment RICH - should fail
    node["minDigis"][std::string(cbm::util::ToString(ECbmModuleId::kRich))] = nRich + 1;
    cbm::algo::evbuild::DigiEventSelectorConfig config(node);
    cbm::algo::evbuild::DigiEventSelector select(config);
    select.RegisterSetup(recoSetup);
    EXPECT_EQ(select(event), false);
  }
 
  {
    // --- Increment TRD - should fail
    node["minDigis"][std::string(cbm::util::ToString(ECbmModuleId::kTrd))] = nTrd + 1;
    cbm::algo::evbuild::DigiEventSelectorConfig config(node);
    cbm::algo::evbuild::DigiEventSelector select(config);
    select.RegisterSetup(recoSetup);
    EXPECT_EQ(select(event), false);
  }
 
  {
    // --- Increment TRD2D - should fail
    node["minDigis"][std::string(cbm::util::ToString(ECbmModuleId::kTrd2d))] = nTrd2d + 1;
    cbm::algo::evbuild::DigiEventSelectorConfig config(node);
    cbm::algo::evbuild::DigiEventSelector select(config);
    select.RegisterSetup(recoSetup);
    EXPECT_EQ(select(event), false);
  }
 
  {
    // --- Increment TOF - should fail
    node["minDigis"][std::string(cbm::util::ToString(ECbmModuleId::kTof))] = nTof + 1;
    cbm::algo::evbuild::DigiEventSelectorConfig config(node);
    cbm::algo::evbuild::DigiEventSelector select(config);
    select.RegisterSetup(recoSetup);
    EXPECT_EQ(select(event), false);
  }
 
  {
    // --- Increment PSD - should fail
    node["minDigis"][std::string(cbm::util::ToString(ECbmModuleId::kPsd))] = nPsd + 1;
    cbm::algo::evbuild::DigiEventSelectorConfig config(node);
    cbm::algo::evbuild::DigiEventSelector select(config);
    select.RegisterSetup(recoSetup);
    EXPECT_EQ(select(event), false);
  }
 
  {
    // --- Increment FSD - should fail
    node["minDigis"][std::string(cbm::util::ToString(ECbmModuleId::kFsd))] = nFsd + 1;
    cbm::algo::evbuild::DigiEventSelectorConfig config(node);
    cbm::algo::evbuild::DigiEventSelector select(config);
    select.RegisterSetup(recoSetup);
    EXPECT_EQ(select(event), false);
  }
 
  {
    // --- Test number of STS stations
    {
      const uint maxStsStations = 8;  // FIXME: it is a unit, not a station
      const uint maxStsModules  = 12;
      const uint maxStsLadders  = 4;
 
      for (uint numStations = 1; numStations < maxStsStations; numStations++) {
        //Prepare input
        DigiEvent eventIn;
        //Produce digi pairs with valid addresses
        for (uint station = 0; station < numStations; station++) {
          for (uint module = 0; module < maxStsModules; module++) {
            for (uint ladder = 0; ladder < maxStsLadders; ladder++) {
              for (uint halfladder = 0; halfladder <= 1; halfladder++) {
                //add digis pairs
                int32_t address = CbmStsAddress::GetAddress(station, ladder, halfladder, module);
                eventIn.fSts.push_back(CbmStsDigi(address, 0, 0.0, 0.0));
                eventIn.fSts.push_back(CbmStsDigi(address, 1024, 0.0, 0.0));  //other side channel
 
                //add digis from next station without partner for intentionally failed test
                int32_t nextAddress = CbmStsAddress::GetAddress(numStations, ladder, 0, module);
                eventIn.fSts.push_back(CbmStsDigi(nextAddress, 1024, 0.0, 0.0));
              }
            }
          }
        }
 
        YAML::Node node2;
        //L_(info) << "tof min layers: " << numStations;
        {  // Test correct number of stations - should pass
          node2["minLayers"][std::string(cbm::util::ToString(ECbmModuleId::kSts))] = numStations;
          cbm::algo::evbuild::DigiEventSelectorConfig config(node2);
          cbm::algo::evbuild::DigiEventSelector select(config);
          select.RegisterSetup(recoSetup);
          EXPECT_EQ(select(eventIn), true);
        }
 
        {
          //  Test if digi without partner is properly disregarded
          node2["minLayers"][std::string(cbm::util::ToString(ECbmModuleId::kSts))] = numStations + 1;
          cbm::algo::evbuild::DigiEventSelectorConfig config(node2);
          cbm::algo::evbuild::DigiEventSelector select(config);
          select.RegisterSetup(recoSetup);
          EXPECT_EQ(select(eventIn), false);
        }
      }
    }
 
 
    // --- Test number of TOF layers
    {
      //Prepare input
      DigiEvent eventIn;
      std::unordered_set<int32_t> setTofStation;
      const auto* tofUnit{recoSetup->GetTof()};
      assert(tofUnit);
      const auto& stationIdMap{tofUnit->GetTrkStationIdMap()};
 
      for (uint16_t smType = 0; smType < stationIdMap.GetNofSmTypes(); smType++) {
        for (uint16_t sm = 0; sm < stationIdMap.GetNofSm(smType); sm++) {
          for (uint16_t rpc = 0; rpc < stationIdMap.GetNofRpc(smType); rpc++) {
 
            uint32_t addrFront = CbmTofAddress::GetUniqueAddress(sm, rpc, 0, 0, smType, 0);
            uint32_t addrBack  = CbmTofAddress::GetUniqueAddress(sm, rpc, 0, 1, smType, 0);
            eventIn.fTof.push_back(CbmTofDigi(addrFront, 0.0, 0.0));
            eventIn.fTof.push_back(CbmTofDigi(addrBack, 0.0, 0.0));
            int iTrkStation = stationIdMap.GetTrackingStationIndex(smType, sm, rpc);
            if (iTrkStation > -1) {
              // Some of RPCs are disabled in tracking: => don't count it (e.g. smType=5 is BMON, its address
              // gives iTrkStation = -1 by definition)
              setTofStation.insert(iTrkStation);
            }
 
            YAML::Node node2;
 
            {  // Test actual number of layers -- should pass
              node2["minLayers"][std::string(cbm::util::ToString(ECbmModuleId::kTof))] = setTofStation.size();
              cbm::algo::evbuild::DigiEventSelectorConfig config(node2);
              cbm::algo::evbuild::DigiEventSelector select(config);
              select.RegisterSetup(recoSetup);
              EXPECT_EQ(select(eventIn), true);
            }
 
            {  // Test with one more station - should fail
              node2["minLayers"][std::string(cbm::util::ToString(ECbmModuleId::kTof))] = setTofStation.size() + 1;
              cbm::algo::evbuild::DigiEventSelectorConfig config(node2);
              cbm::algo::evbuild::DigiEventSelector select(config);
              select.RegisterSetup(recoSetup);
              EXPECT_EQ(select(eventIn), false);
            }
          }
        }
      }
    }
  }
}