CbmStsParSetModule.cxx

Go to the documentation of this file.

/* Copyright (C) 2020 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Volker Friese [committer] */

#include "CbmStsParSetModule.h"
 
#include "CbmStsParModule.h"  // for CbmStsParModule
 
#include <Logger.h>  // for LOG, Logger
 
#include <cassert>  // for assert
#include <fstream>  // for reading parameters from ASCII file
#include <sstream>  // for operator<<, basic_ostream, stringstream
#include <string>   // for char_traits
 
 
ClassImp(CbmStsParSetModule)
 
  // -----   Constructor   ----------------------------------------------------
  CbmStsParSetModule::CbmStsParSetModule(const char* name, const char* title, const char* context)
  : FairParGenericSet(name, title, context)
{
}
// --------------------------------------------------------------------------
 
 
// -----   Destructor   -----------------------------------------------------
CbmStsParSetModule::~CbmStsParSetModule() {}
// --------------------------------------------------------------------------
 
 
// -----   Reset   ----------------------------------------------------------
void CbmStsParSetModule::clear()
{
  fUseGlobal = kFALSE;
  fParams.clear();
  status = kFALSE;
  resetInputVersions();
}
// --------------------------------------------------------------------------
 
 
// -----   Randomly deactivate channels   -----------------------------------
UInt_t CbmStsParSetModule::DeactivateRandomChannels(Double_t fraction)
{
  if (fraction <= 0.) return 0;
  UInt_t nDeactivated = 0;
  for (auto& entry : fParams) {
    nDeactivated += entry.second.DeactivateRandomChannels(fraction);
  }
  return nDeactivated;
}
// --------------------------------------------------------------------------
 
 
// -----   Read parameters from ASCII file   --------------------------------
Bool_t CbmStsParSetModule::getParams(FairParamList*)
{
  LOG(fatal) << GetName() << ": ASCII input is not defined!";
  return kFALSE;
}
// --------------------------------------------------------------------------
 
// -----   Read parameters from ASCII file   --------------------------------
Bool_t CbmStsParSetModule::LoadParASCII(std::string file_name)
{
  std::ifstream input(file_name);
  if (!input.is_open()) {
    LOG(error) << Form("[STS Charge Calibration] Error opening file: %s", file_name.c_str());
    ;
    return kFALSE;
  }
 
  LOG(info) << Form("[STS Charge Calibration] Loading configuration from file: %s", file_name.c_str());
 
  int32_t address, side, asic_idx, nb_channels, nb_adc;
  double dyn_range, threshold, time_res, dead_time, noise, znr;
 
  // Default ASIC values
  std::unique_ptr<CbmStsParAsic> default_asic =
    std::make_unique<CbmStsParAsic>(128, 31, 75000., 3000., 5., 800., 1000., 3.9789e-3);
 
  // Default module configuration
  std::unique_ptr<CbmStsParModule> default_module = std::make_unique<CbmStsParModule>(2048, 128);
  default_module->SetAllAsics(*default_asic);
 
  std::string line;
  while (std::getline(input, line)) {
 
    // Skip commented lines
    if (line[0] == '#') {
      continue;
    }
    std::istringstream str_stream(line);
    str_stream >> std::hex >> address >> std::dec >> side >> asic_idx >> nb_channels >> nb_adc >> dyn_range >> threshold
      >> time_res >> dead_time >> noise >> znr;
 
    if (address == -1) {
      LOG(info) << "[STS Charge Calibration] Using same configuration for all modules";
      SetGlobalPar(*default_module);
      break;
    }
 
    // Initialize map entry with default configuration
    if (!fParams.count(address)) {
      fParams[address] = *default_module;
    }
 
    // Custom ASIC loaded from file
    std::unique_ptr<CbmStsParAsic> custom_asic =
      std::make_unique<CbmStsParAsic>(nb_channels, nb_adc, dyn_range, threshold, time_res, dead_time, noise, znr);
 
    if (asic_idx == -1) {  // Same configuration for all ASIC in the given side
      if (side == -1) {    // Same configuration for both sides
        LOG(info) << Form("[STS Charge Calibration] Using same configuration for all ASICs in module 0x%x", address);
        fParams[address].SetAllAsics(*custom_asic);
      }
      else {
        // Configure ASIC all for given side
        LOG(info) << Form("[STS Charge Calibration] Using same configuration for all ASICs in module 0x%x, side %u",
                          address, side);
        for (int idx = 0; idx < 8; idx++) {
          fParams[address].SetAsic(idx + 8 * side, *custom_asic);
        }
      }
    }
    else {
      if (side == -1) {
        fParams[address].SetAsic(asic_idx, *custom_asic);
        fParams[address].SetAsic(asic_idx + 8, *custom_asic);
      }
      else {
        fParams[address].SetAsic(asic_idx + 8 * side, *custom_asic);
      }
    }
  }
 
 
  return kTRUE;
}
// --------------------------------------------------------------------------
 
// -----   Get condition parameters of a module   ---------------------------
const CbmStsParModule& CbmStsParSetModule::GetParModule(UInt_t address)
{
  if (fUseGlobal) return fGlobalParams;
  assert(fParams.count(address));
  return fParams[address];
}
// --------------------------------------------------------------------------
 
 
// -----   Write parameters from ASCII file   -------------------------------
void CbmStsParSetModule::putParams(FairParamList*) { LOG(fatal) << GetName() << ": ASCII output is not defined!"; }
// --------------------------------------------------------------------------
 
 
// -----   Set module parameters   ------------------------------------------
void CbmStsParSetModule::SetParModule(UInt_t address, const CbmStsParModule& par)
{
  if (fParams.count(address)) LOG(fatal) << GetName() << ": Replacing parameters for sensor address " << address;
  fParams[address] = par;
}
// --------------------------------------------------------------------------
 
 
// -----   Info to string   ------------------------------------------------
std::string CbmStsParSetModule::ToString() const
{
  std::stringstream ss;
  if (fUseGlobal) ss << "(Global) " << fGlobalParams.ToString();
  else {
    if (fParams.empty()) ss << "Empty";
    else
      ss << "Parameters for " << fParams.size() << " sensors";
  }
  return ss.str();
}
// -------------------------------------------------------------------------