CbmStsUtils.cxx

Go to the documentation of this file.

/* Copyright (C) 2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Dario Ramirez [committer] */
 
#include "CbmStsUtils.h"
 
#include "CbmStsAddress.h"
#include "CbmStsCluster.h"
#include "CbmStsParSetModule.h"
 
#include <cassert>
 
int32_t cbm_sts_utils::GetHitCluSizeF(CbmStsHit* hit, TClonesArray* sts_clu_array)
{
  if (hit == nullptr || sts_clu_array == nullptr) {
    return -1;
  }
  return ((CbmStsCluster*) sts_clu_array->UncheckedAt(hit->GetFrontClusterId()))->GetSize();
}
int32_t cbm_sts_utils::GetHitCluSizeB(CbmStsHit* hit, TClonesArray* sts_clu_array)
{
  if (hit == nullptr || sts_clu_array == nullptr) {
    return -1;
  }
  return ((CbmStsCluster*) sts_clu_array->UncheckedAt(hit->GetBackClusterId()))->GetSize();
}
/* Get StsHit charge as average of front and back cluster charges */
double cbm_sts_utils::GetHitChargeF(CbmStsHit* hit, TClonesArray* sts_clu_array)
{
  if (hit == nullptr || sts_clu_array == nullptr) {
    return -1;
  }
  return ((CbmStsCluster*) sts_clu_array->UncheckedAt(hit->GetFrontClusterId()))->GetCharge();
}
 
double cbm_sts_utils::GetHitChargeB(CbmStsHit* hit, TClonesArray* sts_clu_array)
{
  if (hit == nullptr || sts_clu_array == nullptr) {
    return -1;
  }
  return ((CbmStsCluster*) sts_clu_array->UncheckedAt(hit->GetBackClusterId()))->GetCharge();
}
 
/* Get StsHit cluster time */
double cbm_sts_utils::GetHitTimeF(CbmStsHit* hit, TClonesArray* sts_clu_array)
{
  if (hit == nullptr || sts_clu_array == nullptr) {
    return -1;
  }
  return ((CbmStsCluster*) sts_clu_array->UncheckedAt(hit->GetFrontClusterId()))->GetTime();
}
 
double cbm_sts_utils::GetHitTimeB(CbmStsHit* hit, TClonesArray* sts_clu_array)
{
  if (hit == nullptr || sts_clu_array == nullptr) {
    return -1;
  }
  return ((CbmStsCluster*) sts_clu_array->UncheckedAt(hit->GetBackClusterId()))->GetTime();
}
/* ---- ------------- ---- */
 
double cbm_sts_utils::GetHitCharge(CbmStsHit* hit, TClonesArray* sts_clu_array)
{
  if (hit == nullptr || sts_clu_array == nullptr) {
    return -1;
  }
  double cluster_charge_f = GetHitChargeF(hit, sts_clu_array);
  double cluster_charge_b = GetHitChargeB(hit, sts_clu_array);
  return 0.5 * (cluster_charge_f + cluster_charge_b);
}
 
/* Get charge asymmetry */
double cbm_sts_utils::GetHitChargeAsy(CbmStsHit* hit, TClonesArray* sts_clu_array)
{
  if (hit == nullptr || sts_clu_array == nullptr) {
    return -1;
  }
  double cluster_charge_f = GetHitChargeF(hit, sts_clu_array);
  double cluster_charge_b = GetHitChargeB(hit, sts_clu_array);
  return (cluster_charge_f - cluster_charge_b) / (cluster_charge_f + cluster_charge_b);
}

std::pair<cbm_sts_utils::HBinning, cbm_sts_utils::HBinning>
cbm_sts_utils::ChargeBinning(const CbmStsParModule& par_module, const uint32_t max_clu_size)
{
  assert((max_clu_size > 0) && "Maximum cluster size must be greater than 0");
 
  auto par_asic = par_module.GetAsicParams();
 
  double n_side_q_thr = par_asic[0].GetThreshold();
  double n_side_q_dyn = par_asic[0].GetDynRange();
  double p_side_q_thr = par_asic[8].GetThreshold();
  double p_side_q_dyn = par_asic[8].GetDynRange();
 
  for (int asic_idx = 0; asic_idx < 16; asic_idx++) {
    auto asic = par_asic[asic_idx];
    if (asic_idx < 7) {  // n-side
      n_side_q_thr = std::min(n_side_q_thr, asic.GetThreshold());
      n_side_q_dyn = std::max(n_side_q_dyn, asic.GetDynRange());
    }
    else {  // p-side
      p_side_q_thr = std::min(p_side_q_thr, asic.GetThreshold());
      p_side_q_dyn = std::max(p_side_q_dyn, asic.GetDynRange());
    }
  }
 
  double n_side_q_bin = n_side_q_dyn / 31;
  double p_side_q_bin = p_side_q_dyn / 31;
 
  double n_side_q_min = n_side_q_thr;
  double p_side_q_min = p_side_q_thr;
 
  double n_side_q_max = (n_side_q_dyn * (31.5 / 31) + 0.5 * n_side_q_bin) * max_clu_size + n_side_q_min;
  double p_side_q_max = (p_side_q_dyn * (31.5 / 31) + 0.5 * p_side_q_bin) * max_clu_size + p_side_q_min;
 
  uint32_t n_side_n_bin = 32 * max_clu_size;
  uint32_t p_side_n_bin = 32 * max_clu_size;
 
  return std::make_pair(cbm_sts_utils::HBinning{n_side_n_bin, n_side_q_min, n_side_q_max},
                        cbm_sts_utils::HBinning{p_side_n_bin, p_side_q_min, p_side_q_max});
}
 
 
std::set<int> cbm_sts_utils::GetUnits(const std::vector<int32_t> addresses)
{
  std::set<int> units;
  for (int32_t address : addresses) {
    units.insert(CbmStsAddress::GetElementId(address, kStsUnit));
  }
  return units;
}
 
std::vector<int32_t> cbm_sts_utils::GetUnitModules(const std::vector<int32_t> addresses, const uint32_t unit)
{
  std::vector<int32_t> unit_modules;
  for (int32_t address : addresses) {
    if (CbmStsAddress::GetElementId(address, kStsUnit) == unit) {
      unit_modules.push_back(address);
    }
  }
  return unit_modules;
}