diff --git a/core/detectors/sts/CbmStsParAsic.cxx b/core/detectors/sts/CbmStsParAsic.cxx
index 75e07c4945d40f4bd789eb010c1702e534acada2..69f16b1c12a152723305624cc291558aebb434de 100644
--- a/core/detectors/sts/CbmStsParAsic.cxx
+++ b/core/detectors/sts/CbmStsParAsic.cxx
@@ -8,63 +8,51 @@
#include <TMath.h> // for Exp
#include <TRandom.h>
+#include <sstream> // for operator<<, basic_ostream, stringstream
+
#include <assert.h> // for assert
-#include <sstream> // for operator<<, basic_ostream, stringstream
ClassImp(CbmStsParAsic)
-// ----- Constructor ---------------------------------------------------
-CbmStsParAsic::CbmStsParAsic(UShort_t nChannels,
- UShort_t nAdc,
- Double_t dynRange,
- Double_t threshold,
- Double_t timeResol,
- Double_t deadTime,
- Double_t noise,
- Double_t znr) {
+ // ----- Constructor ---------------------------------------------------
+ CbmStsParAsic::CbmStsParAsic(UShort_t nChannels, UShort_t nAdc, Double_t dynRange, Double_t threshold,
+ Double_t timeResol, Double_t deadTime, Double_t noise, Double_t znr)
+{
Set(nChannels, nAdc, dynRange, threshold, timeResol, deadTime, noise, znr);
}
// -------------------------------------------------------------------------
// ----- Copy constructor ----------------------------------------------
-CbmStsParAsic::CbmStsParAsic(const CbmStsParAsic& other) {
- Set(other.fNofChannels,
- other.fNofAdc,
- other.fDynRange,
- other.fThreshold,
- other.fTimeResolution,
- other.fDeadTime,
- other.fNoise,
- other.fZeroNoiseRate);
+CbmStsParAsic::CbmStsParAsic(const CbmStsParAsic& other)
+{
+ Set(other.fNofChannels, other.fNofAdc, other.fDynRange, other.fThreshold, other.fTimeResolution, other.fDeadTime,
+ other.fNoise, other.fZeroNoiseRate);
}
// -------------------------------------------------------------------------
// ----- Copy assignment operator --------------------------------------
-CbmStsParAsic& CbmStsParAsic::operator=(const CbmStsParAsic& other) {
- Set(other.fNofChannels,
- other.fNofAdc,
- other.fDynRange,
- other.fThreshold,
- other.fTimeResolution,
- other.fDeadTime,
- other.fNoise,
- other.fZeroNoiseRate);
+CbmStsParAsic& CbmStsParAsic::operator=(const CbmStsParAsic& other)
+{
+ Set(other.fNofChannels, other.fNofAdc, other.fDynRange, other.fThreshold, other.fTimeResolution, other.fDeadTime,
+ other.fNoise, other.fZeroNoiseRate);
return *this;
}
// -------------------------------------------------------------------------
// ----- Destructor ----------------------------------------------------
-CbmStsParAsic::~CbmStsParAsic() {
+CbmStsParAsic::~CbmStsParAsic()
+{
if (fNoiseCharge) delete fNoiseCharge;
}
// -------------------------------------------------------------------------
// ----- ADC channel from charge ----------------------------------------
-Short_t CbmStsParAsic::ChargeToAdc(Double_t charge) const {
+Short_t CbmStsParAsic::ChargeToAdc(Double_t charge) const
+{
if (charge < fThreshold) return -1; // Underflow
if (charge >= fThreshold + fDynRange) return fNofAdc - 1; // Overflow
return Short_t((charge - fThreshold) / fDynRange * Double_t(fNofAdc));
@@ -73,26 +61,27 @@ Short_t CbmStsParAsic::ChargeToAdc(Double_t charge) const {
// ----- Deactivate channels -------------------------------------------
-UInt_t CbmStsParAsic::DeactivateRandomChannels(Double_t fraction) {
+UInt_t CbmStsParAsic::DeactivateRandomChannels(Double_t fraction)
+{
- if ( fraction < 0. ) return 0;
+ if (fraction < 0.) return 0;
// --- Average number of dead channels
Double_t meanDead = fraction * Double_t(fNofChannels);
- if ( meanDead > fNofChannels) meanDead = fNofChannels;
+ if (meanDead > fNofChannels) meanDead = fNofChannels;
// --- Sample actual number of dead channels from Poissonian
Int_t nDead = gRandom->Poisson(meanDead);
// --- Deactivate the given number of channels
Int_t nDeactivated = 0;
- while(nDeactivated < nDead) {
+ while (nDeactivated < nDead) {
Int_t channel = Int_t(gRandom->Uniform(0, fNofChannels));
- if ( IsChannelActive(channel) ) {
+ if (IsChannelActive(channel)) {
fDeadChannels.insert(channel);
nDeactivated++;
- } //? Channel was active
- } //# Deactivated channels
+ } //? Channel was active
+ } //# Deactivated channels
assert(nDeactivated == nDead);
return nDead;
@@ -101,7 +90,8 @@ UInt_t CbmStsParAsic::DeactivateRandomChannels(Double_t fraction) {
// ----- Single-channel noise rate -------------------------------------
-Double_t CbmStsParAsic::GetNoiseRate() const {
+Double_t CbmStsParAsic::GetNoiseRate() const
+{
if (fNoise == 0.) return 0.;
Double_t ratio = fThreshold / fNoise;
return 0.5 * fZeroNoiseRate * TMath::Exp(-0.5 * ratio * ratio);
@@ -110,7 +100,8 @@ Double_t CbmStsParAsic::GetNoiseRate() const {
// ----- Random charge of a noise signal -------------------------------
-Double_t CbmStsParAsic::GetRandomNoiseCharge() const {
+Double_t CbmStsParAsic::GetRandomNoiseCharge() const
+{
assert(fIsInit);
return fNoiseCharge->GetRandom();
}
@@ -118,10 +109,10 @@ Double_t CbmStsParAsic::GetRandomNoiseCharge() const {
// ----- Intialise the noise charge distribution -----------------------
-void CbmStsParAsic::Init() {
+void CbmStsParAsic::Init()
+{
if (fNoiseCharge) delete fNoiseCharge;
- fNoiseCharge = new TF1(
- "Noise Charge", "TMath::Gaus(x, [0], [1])", fThreshold, 10. * fNoise);
+ fNoiseCharge = new TF1("Noise Charge", "TMath::Gaus(x, [0], [1])", fThreshold, 10. * fNoise);
fNoiseCharge->SetParameters(0., fNoise);
fIsInit = kTRUE;
}
@@ -129,15 +120,9 @@ void CbmStsParAsic::Init() {
// ----- Set the parameters ---------------------------------------------
-void CbmStsParAsic::Set(UShort_t nChannels,
- UShort_t nAdc,
- Double_t dynRange,
- Double_t threshold,
- Double_t timeResol,
- Double_t deadTime,
- Double_t noise,
- Double_t zeroNoiseRate,
- std::set<UShort_t> deadChannels) {
+void CbmStsParAsic::Set(UShort_t nChannels, UShort_t nAdc, Double_t dynRange, Double_t threshold, Double_t timeResol,
+ Double_t deadTime, Double_t noise, Double_t zeroNoiseRate, std::set<UShort_t> deadChannels)
+{
// Assert validity of parameters
assert(dynRange > 0.);
@@ -163,11 +148,11 @@ void CbmStsParAsic::Set(UShort_t nChannels,
// ----- String output ----------------------------------------------------
-std::string CbmStsParAsic::ToString() const {
+std::string CbmStsParAsic::ToString() const
+{
std::stringstream ss;
- ss << "nAdc " << fNofAdc << " | dynRange " << fDynRange << " e | thresh. "
- << fThreshold << " e | tResol " << fTimeResolution << " ns | deadTime "
- << fDeadTime << " ns | noise " << fNoise << " e | ZNR " << fZeroNoiseRate
+ ss << "nAdc " << fNofAdc << " | dynRange " << fDynRange << " e | thresh. " << fThreshold << " e | tResol "
+ << fTimeResolution << " ns | deadTime " << fDeadTime << " ns | noise " << fNoise << " e | ZNR " << fZeroNoiseRate
<< "/ns | SCNR " << GetNoiseRate() << "/ns";
return ss.str();
}
diff --git a/core/detectors/sts/CbmStsParAsic.h b/core/detectors/sts/CbmStsParAsic.h
index 79977e6eb545e595919f5c4f5a73b96db108a675..d8e8d228953a71b83b180b9dfee58325e2650aed 100644
--- a/core/detectors/sts/CbmStsParAsic.h
+++ b/core/detectors/sts/CbmStsParAsic.h
@@ -39,14 +39,8 @@ public:
** @param noise Noise RMS [e]
** @param znr Zero-crossing noise rate [1/ns]
**/
- CbmStsParAsic(UShort_t nChannels,
- UShort_t nAdc,
- Double_t dynRange,
- Double_t threshold,
- Double_t timeResol,
- Double_t deadTime,
- Double_t noise,
- Double_t znr);
+ CbmStsParAsic(UShort_t nChannels, UShort_t nAdc, Double_t dynRange, Double_t threshold, Double_t timeResol,
+ Double_t deadTime, Double_t noise, Double_t znr);
/** @brief Copy constructor (disabled) **/
@@ -73,7 +67,8 @@ public:
** @param adc ADC channel
** @return Mean charge in ADC channel [e]
*/
- Double_t AdcToCharge(UShort_t adc) const {
+ Double_t AdcToCharge(UShort_t adc) const
+ {
return fThreshold + fDynRange / Double_t(fNofAdc) * (Double_t(adc) + 0.5);
}
@@ -169,9 +164,7 @@ public:
** @param channel Channel number within ASIC
** @return True if the channel is active
**/
- Bool_t IsChannelActive(UShort_t channel) const {
- return fDeadChannels.find(channel) == fDeadChannels.end();
- }
+ Bool_t IsChannelActive(UShort_t channel) const { return fDeadChannels.find(channel) == fDeadChannels.end(); }
/** @brief Set parameters
@@ -185,15 +178,8 @@ public:
** @param zeroNoiseRate Zero-crossing noise rate
** @param deadChannels Set of dead channels
**/
- void Set(UShort_t nChannels,
- UShort_t nAdc,
- Double_t dynRange,
- Double_t threshold,
- Double_t timeResol,
- Double_t deadTime,
- Double_t noise,
- Double_t zeroNoiseRate,
- std::set<UShort_t> deadChannels = {});
+ void Set(UShort_t nChannels, UShort_t nAdc, Double_t dynRange, Double_t threshold, Double_t timeResol,
+ Double_t deadTime, Double_t noise, Double_t zeroNoiseRate, std::set<UShort_t> deadChannels = {});
/** @brief Info to string **/
diff --git a/core/detectors/sts/CbmStsParModule.cxx b/core/detectors/sts/CbmStsParModule.cxx
index 03340beebfa77510b25eeecb5577bdd4bb93ad62..50ce55ac7b3ae49484b96f424c971bebd9ce1671 100644
--- a/core/detectors/sts/CbmStsParModule.cxx
+++ b/core/detectors/sts/CbmStsParModule.cxx
@@ -17,19 +17,21 @@ ClassImp(CbmStsParModule)
// ----- Constructor ---------------------------------------------------
CbmStsParModule::CbmStsParModule(UInt_t nChannels, UInt_t nAsicChannels)
- : fNofChannels(nChannels), fNofAsicChannels(nAsicChannels) {
- UInt_t nAsics = (nChannels % nAsicChannels ? nChannels / nAsicChannels + 1
- : nChannels / nAsicChannels);
+ : fNofChannels(nChannels)
+ , fNofAsicChannels(nAsicChannels)
+{
+ UInt_t nAsics = (nChannels % nAsicChannels ? nChannels / nAsicChannels + 1 : nChannels / nAsicChannels);
fAsicPars.resize(nAsics);
}
// -------------------------------------------------------------------------
// ----- Randomly deactivate channels ----------------------------------
-UInt_t CbmStsParModule::DeactivateRandomChannels(Double_t fraction) {
- if ( fraction <= 0. ) return 0;
+UInt_t CbmStsParModule::DeactivateRandomChannels(Double_t fraction)
+{
+ if (fraction <= 0.) return 0;
UInt_t nDeactivated = 0;
- for ( auto& asic : fAsicPars ) {
+ for (auto& asic : fAsicPars) {
nDeactivated += asic.DeactivateRandomChannels(fraction);
}
return nDeactivated;
@@ -38,7 +40,8 @@ UInt_t CbmStsParModule::DeactivateRandomChannels(Double_t fraction) {
// ----- Get ASIC parameters -------------------------------------------
-const CbmStsParAsic& CbmStsParModule::GetParAsic(UInt_t channel) const {
+const CbmStsParAsic& CbmStsParModule::GetParAsic(UInt_t channel) const
+{
assert(!fAsicPars.empty());
assert(channel < fNofChannels);
UInt_t nAsic = channel / fNofAsicChannels;
@@ -49,7 +52,8 @@ const CbmStsParAsic& CbmStsParModule::GetParAsic(UInt_t channel) const {
// ----- Check for a channel being active ------------------------------
-Bool_t CbmStsParModule::IsChannelActive(UInt_t channel) const {
+Bool_t CbmStsParModule::IsChannelActive(UInt_t channel) const
+{
const CbmStsParAsic& parAsic = GetParAsic(channel);
UShort_t asicChannel = channel % fNofAsicChannels;
return parAsic.IsChannelActive(asicChannel);
@@ -58,7 +62,8 @@ Bool_t CbmStsParModule::IsChannelActive(UInt_t channel) const {
// ----- Set parameters for all ASICs ----------------------------------
-void CbmStsParModule::SetAllAsics(const CbmStsParAsic& asicPar) {
+void CbmStsParModule::SetAllAsics(const CbmStsParAsic& asicPar)
+{
assert(asicPar.GetNofChannels() == fNofAsicChannels);
for (auto& par : fAsicPars) {
par = asicPar;
@@ -69,10 +74,10 @@ void CbmStsParModule::SetAllAsics(const CbmStsParAsic& asicPar) {
// ----- String output -------------------------------------------------
-string CbmStsParModule::ToString() const {
+string CbmStsParModule::ToString() const
+{
stringstream ss;
- ss << "Channels " << fNofChannels << " | ASICS " << GetNofAsics()
- << " | Channels per ASIC " << fNofAsicChannels;
+ ss << "Channels " << fNofChannels << " | ASICS " << GetNofAsics() << " | Channels per ASIC " << fNofAsicChannels;
return ss.str();
}
// -------------------------------------------------------------------------
diff --git a/core/detectors/sts/CbmStsParModule.h b/core/detectors/sts/CbmStsParModule.h
index 29a666e1f1bfd72e83fa4440a902164640b4e1cb..4876d561d6c602878af9a8d68dec51f3cce22d70 100644
--- a/core/detectors/sts/CbmStsParModule.h
+++ b/core/detectors/sts/CbmStsParModule.h
@@ -6,14 +6,14 @@
#ifndef CBMSTSPARMODULE_H
#define CBMSTSPARMODULE_H 1
+#include "CbmStsParAsic.h" // for CbmStsParAsic
+
#include <Rtypes.h> // for THashConsistencyHolder, ClassDefNV
#include <RtypesCore.h> // for UInt_t
#include <string> // for string
#include <vector> // for vector
-#include "CbmStsParAsic.h" // for CbmStsParAsic
-
/** @class CbmStsParModule
** @brief Parameters for one STS module
** @author Volker Friese <v.friese@gsi.de>
diff --git a/core/detectors/sts/CbmStsParSetModule.cxx b/core/detectors/sts/CbmStsParSetModule.cxx
index d370dfd31ef25e03c72be48b79f955385c9651a5..df72b0c9363135f411ce00999ab912c02d0c9bb6 100644
--- a/core/detectors/sts/CbmStsParSetModule.cxx
+++ b/core/detectors/sts/CbmStsParSetModule.cxx
@@ -16,10 +16,10 @@
ClassImp(CbmStsParSetModule)
// ----- Constructor ----------------------------------------------------
- CbmStsParSetModule::CbmStsParSetModule(const char* name,
- const char* title,
- const char* context)
- : FairParGenericSet(name, title, context) {}
+ CbmStsParSetModule::CbmStsParSetModule(const char* name, const char* title, const char* context)
+ : FairParGenericSet(name, title, context)
+{
+}
// --------------------------------------------------------------------------
@@ -29,7 +29,8 @@ CbmStsParSetModule::~CbmStsParSetModule() {}
// ----- Reset ----------------------------------------------------------
-void CbmStsParSetModule::clear() {
+void CbmStsParSetModule::clear()
+{
fUseGlobal = kFALSE;
fParams.clear();
status = kFALSE;
@@ -39,10 +40,11 @@ void CbmStsParSetModule::clear() {
// ----- Randomly deactivate channels -----------------------------------
-UInt_t CbmStsParSetModule::DeactivateRandomChannels(Double_t fraction) {
- if ( fraction <= 0. ) return 0;
+UInt_t CbmStsParSetModule::DeactivateRandomChannels(Double_t fraction)
+{
+ if (fraction <= 0.) return 0;
UInt_t nDeactivated = 0;
- for ( auto& entry : fParams ) {
+ for (auto& entry : fParams) {
nDeactivated += entry.second.DeactivateRandomChannels(fraction);
}
return nDeactivated;
@@ -51,7 +53,8 @@ UInt_t CbmStsParSetModule::DeactivateRandomChannels(Double_t fraction) {
// ----- Read parameters from ASCII file --------------------------------
-Bool_t CbmStsParSetModule::getParams(FairParamList*) {
+Bool_t CbmStsParSetModule::getParams(FairParamList*)
+{
LOG(fatal) << GetName() << ": ASCII input is not defined!";
return kFALSE;
}
@@ -59,7 +62,8 @@ Bool_t CbmStsParSetModule::getParams(FairParamList*) {
// ----- Get condition parameters of a module ---------------------------
-const CbmStsParModule& CbmStsParSetModule::GetParModule(UInt_t address) {
+const CbmStsParModule& CbmStsParSetModule::GetParModule(UInt_t address)
+{
if (fUseGlobal) return fGlobalParams;
assert(fParams.count(address));
return fParams[address];
@@ -68,31 +72,26 @@ const CbmStsParModule& CbmStsParSetModule::GetParModule(UInt_t address) {
// ----- Write parameters from ASCII file -------------------------------
-void CbmStsParSetModule::putParams(FairParamList*) {
- LOG(fatal) << GetName() << ": ASCII output is not defined!";
-}
+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;
+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::string CbmStsParSetModule::ToString() const
+{
std::stringstream ss;
- if (fUseGlobal)
- ss << "(Global) " << fGlobalParams.ToString();
+ if (fUseGlobal) ss << "(Global) " << fGlobalParams.ToString();
else {
- if (fParams.empty())
- ss << "Empty";
+ if (fParams.empty()) ss << "Empty";
else
ss << "Parameters for " << fParams.size() << " sensors";
}
diff --git a/core/detectors/sts/CbmStsParSetModule.h b/core/detectors/sts/CbmStsParSetModule.h
index 47054ec4f07816ccd3cf8e4f3523715b851df621..1662986f559a9975a2419f200d658053ab378142 100644
--- a/core/detectors/sts/CbmStsParSetModule.h
+++ b/core/detectors/sts/CbmStsParSetModule.h
@@ -7,16 +7,16 @@
#ifndef CBMSTSPARSETMODULE_H
#define CBMSTSPARSETMODULE_H 1
-#include <Rtypes.h> // for THashConsistencyHolder, ClassDef
-#include <RtypesCore.h> // for UInt_t, Bool_t, kFALSE, kTRUE
+#include "CbmStsParModule.h" // for CbmStsParModule
#include <FairParGenericSet.h> // for FairParGenericSet
+#include <Rtypes.h> // for THashConsistencyHolder, ClassDef
+#include <RtypesCore.h> // for UInt_t, Bool_t, kFALSE, kTRUE
+
#include <map> // for map
#include <string> // for string
-#include "CbmStsParModule.h" // for CbmStsParModule
-
class FairParamList;
/** @class CbmStsParSetModule
@@ -35,8 +35,7 @@ public:
** @param title Parameter container factory name
** @param context No idea
**/
- CbmStsParSetModule(const char* name = "CbmParSetModule",
- const char* title = "STS parameters",
+ CbmStsParSetModule(const char* name = "CbmParSetModule", const char* title = "STS parameters",
const char* context = "Default");
@@ -104,7 +103,8 @@ public:
/** @brief Set global parameters (for all modules)
** @param conditions Module parameter object
**/
- void SetGlobalPar(const CbmStsParModule& params) {
+ void SetGlobalPar(const CbmStsParModule& params)
+ {
fGlobalParams = params;
fUseGlobal = kTRUE;
}
diff --git a/sim/detectors/sts/CbmStsDigitize.cxx b/sim/detectors/sts/CbmStsDigitize.cxx
index 7554c2bf333aa661296179861606934e179c651c..e1efbf67d339cf79354fb28d1f855ae3a407f094 100644
--- a/sim/detectors/sts/CbmStsDigitize.cxx
+++ b/sim/detectors/sts/CbmStsDigitize.cxx
@@ -40,12 +40,6 @@
// Includes from STS
#include "CbmStsModule.h"
-#include "CbmStsParSensorCond.h"
-#include "CbmStsPhysics.h"
-#include "CbmStsSensor.h"
-#include "CbmStsSetup.h"
-#include "CbmStsSimSensorFactory.h"
-
#include "CbmStsParAsic.h"
#include "CbmStsParModule.h"
#include "CbmStsParSensor.h"
@@ -54,6 +48,10 @@
#include "CbmStsParSetSensor.h"
#include "CbmStsParSetSensorCond.h"
#include "CbmStsParSim.h"
+#include "CbmStsPhysics.h"
+#include "CbmStsSensor.h"
+#include "CbmStsSetup.h"
+#include "CbmStsSimSensorFactory.h"
using std::fixed;
using std::left;
@@ -85,7 +83,8 @@ CbmStsDigitize::CbmStsDigitize()
, fModuleParameterFile()
, fTimePointLast(-1.)
, fTimeDigiFirst(-1.)
- , fTimeDigiLast(-1.) {
+ , fTimeDigiLast(-1.)
+{
ResetCounters();
SetGlobalDefaults();
}
@@ -98,7 +97,8 @@ CbmStsDigitize::~CbmStsDigitize() {}
// ----- Content of analogue buffers -----------------------------------
-Int_t CbmStsDigitize::BufferSize() const {
+Int_t CbmStsDigitize::BufferSize() const
+{
Int_t nSignals = 0;
Int_t nSigModule;
Double_t t1Module;
@@ -115,7 +115,8 @@ Int_t CbmStsDigitize::BufferSize() const {
// ----- Print the status of the analogue buffers ----------------------
-string CbmStsDigitize::BufferStatus() const {
+string CbmStsDigitize::BufferStatus() const
+{
Int_t nSignals = 0;
Double_t t1 = -1;
@@ -135,34 +136,28 @@ string CbmStsDigitize::BufferStatus() const {
} //# modules in setup
std::stringstream ss;
- ss << nSignals << (nSignals == 1 ? " signal " : " signals ")
- << "in analogue buffers";
- if (nSignals)
- ss << " ( from " << fixed << setprecision(3) << t1 << " ns to " << t2
- << " ns )";
+ ss << nSignals << (nSignals == 1 ? " signal " : " signals ") << "in analogue buffers";
+ if (nSignals) ss << " ( from " << fixed << setprecision(3) << t1 << " ns to " << t2 << " ns )";
return ss.str();
}
// -------------------------------------------------------------------------
// ----- Create a digi object ------------------------------------------
-void CbmStsDigitize::CreateDigi(Int_t address,
- UShort_t channel,
- Long64_t time,
- UShort_t adc,
- const CbmMatch& match) {
+void CbmStsDigitize::CreateDigi(Int_t address, UShort_t channel, Long64_t time, UShort_t adc, const CbmMatch& match)
+{
// Update times of first and last digi
- fTimeDigiFirst =
- fNofDigis ? TMath::Min(fTimeDigiFirst, Double_t(time)) : time;
- fTimeDigiLast = TMath::Max(fTimeDigiLast, Double_t(time));
+ fTimeDigiFirst = fNofDigis ? TMath::Min(fTimeDigiFirst, Double_t(time)) : time;
+ fTimeDigiLast = TMath::Max(fTimeDigiLast, Double_t(time));
// Create digi and (if required) match and send them to DAQ
CbmStsDigi* digi = new CbmStsDigi(address, channel, time, adc);
if (fCreateMatches) {
CbmMatch* digiMatch = new CbmMatch(match);
SendData(digi, digiMatch);
- } else
+ }
+ else
SendData(digi);
fNofDigis++;
}
@@ -170,7 +165,8 @@ void CbmStsDigitize::CreateDigi(Int_t address,
// ----- Task execution ------------------------------------------------
-void CbmStsDigitize::Exec(Option_t* /*opt*/) {
+void CbmStsDigitize::Exec(Option_t* /*opt*/)
+{
// --- Start timer and reset counters
fTimer.Start();
@@ -194,20 +190,16 @@ void CbmStsDigitize::Exec(Option_t* /*opt*/) {
for (auto& entry : fModules)
nNoise += entry.second->GenerateNoise(tNoiseStart, tNoiseEnd);
fNofNoiseTot += Double_t(nNoise);
- LOG(info) << "+ " << setw(20) << GetName() << ": Generated " << nNoise
- << " noise signals from t = " << tNoiseStart << " ns to "
- << tNoiseEnd << " ns";
+ LOG(info) << "+ " << setw(20) << GetName() << ": Generated " << nNoise << " noise signals from t = " << tNoiseStart
+ << " ns to " << tNoiseEnd << " ns";
}
// --- Analogue response: Process the input array of StsPoints
ProcessMCEvent();
- LOG(debug) << GetName() << ": " << fNofSignalsF + fNofSignalsB
- << " signals generated ( " << fNofSignalsF << " / " << fNofSignalsB
- << " )";
+ LOG(debug) << GetName() << ": " << fNofSignalsF + fNofSignalsB << " signals generated ( " << fNofSignalsF << " / "
+ << fNofSignalsB << " )";
// --- For debug: status of analogue buffers
- if (gLogger->IsLogNeeded(fair::Severity::debug)) {
- LOG(debug) << GetName() << ": " << BufferStatus();
- }
+ if (gLogger->IsLogNeeded(fair::Severity::debug)) { LOG(debug) << GetName() << ": " << BufferStatus(); }
// --- Readout time: in stream mode the time of the current event.
// --- Analogue buffers will be digitised for signals at times smaller than
@@ -220,16 +212,12 @@ void CbmStsDigitize::Exec(Option_t* /*opt*/) {
ProcessAnalogBuffers(readoutTime);
// --- Check status of analogue module buffers
- if (gLogger->IsLogNeeded(fair::Severity::debug)) {
- LOG(debug) << GetName() << ": " << BufferStatus();
- }
+ if (gLogger->IsLogNeeded(fair::Severity::debug)) { LOG(debug) << GetName() << ": " << BufferStatus(); }
// --- Event log
- LOG(info) << left << setw(15) << GetName() << "[" << fixed << setprecision(3)
- << fTimer.RealTime() << " s]"
- << " Points: processed " << fNofPointsProc << ", ignored "
- << fNofPointsIgno << ", signals: " << fNofSignalsF << " / "
- << fNofSignalsB << ", digis: " << fNofDigis;
+ LOG(info) << left << setw(15) << GetName() << "[" << fixed << setprecision(3) << fTimer.RealTime() << " s]"
+ << " Points: processed " << fNofPointsProc << ", ignored " << fNofPointsIgno
+ << ", signals: " << fNofSignalsF << " / " << fNofSignalsB << ", digis: " << fNofDigis;
// --- Counters
fTimer.Stop();
@@ -245,7 +233,8 @@ void CbmStsDigitize::Exec(Option_t* /*opt*/) {
// ----- Finish run ---------------------------------------------------
-void CbmStsDigitize::Finish() {
+void CbmStsDigitize::Finish()
+{
// --- Start timer and reset counters
fTimer.Start();
@@ -273,11 +262,9 @@ void CbmStsDigitize::Finish() {
// --- Screen output
stringstream ss;
- ss << GetName() << ": " << fNofDigis
- << (fNofDigis == 1 ? " digi " : " digis ") << "created and sent to DAQ ";
+ ss << GetName() << ": " << fNofDigis << (fNofDigis == 1 ? " digi " : " digis ") << "created and sent to DAQ ";
if (fNofDigis)
- ss << "( from " << fixed << setprecision(3) << fTimeDigiFirst << " ns to "
- << fTimeDigiLast << " ns )";
+ ss << "( from " << fixed << setprecision(3) << fTimeDigiFirst << " ns to " << fTimeDigiLast << " ns )";
LOG(info) << ss.str();
LOG(info) << GetName() << ": " << BufferStatus();
}
@@ -294,46 +281,37 @@ void CbmStsDigitize::Finish() {
LOG(info) << "=====================================";
LOG(info) << GetName() << ": Run summary";
LOG(info) << "Events processed : " << fNofEvents;
- LOG(info) << "Points processed / evt : " << fixed << setprecision(1)
- << fNofPointsProcTot / Double_t(fNofEvents);
- LOG(info) << "Points ignored / evt : " << fixed << setprecision(1)
- << fNofPointsIgnoTot / Double_t(fNofEvents);
- LOG(info) << "Signals / event : "
- << fNofSignalsFTot / Double_t(fNofEvents) << " / "
+ LOG(info) << "Points processed / evt : " << fixed << setprecision(1) << fNofPointsProcTot / Double_t(fNofEvents);
+ LOG(info) << "Points ignored / evt : " << fixed << setprecision(1) << fNofPointsIgnoTot / Double_t(fNofEvents);
+ LOG(info) << "Signals / event : " << fNofSignalsFTot / Double_t(fNofEvents) << " / "
<< fNofSignalsBTot / Double_t(fNofEvents);
- LOG(info) << "StsDigi / event : "
- << fNofDigisTot / Double_t(fNofEvents);
- LOG(info) << "Digis per point : " << setprecision(6)
- << fNofDigisTot / fNofPointsProcTot;
- LOG(info) << "Digis per signal : "
- << fNofDigisTot / (fNofSignalsFTot + fNofSignalsBTot);
- LOG(info) << "Noise digis / event : "
- << fNofNoiseTot / Double_t(fNofEvents);
+ LOG(info) << "StsDigi / event : " << fNofDigisTot / Double_t(fNofEvents);
+ LOG(info) << "Digis per point : " << setprecision(6) << fNofDigisTot / fNofPointsProcTot;
+ LOG(info) << "Digis per signal : " << fNofDigisTot / (fNofSignalsFTot + fNofSignalsBTot);
+ LOG(info) << "Noise digis / event : " << fNofNoiseTot / Double_t(fNofEvents);
LOG(info) << "Noise fraction : " << fNofNoiseTot / fNofDigisTot;
- LOG(info) << "Real time per event : " << fTimeTot / Double_t(fNofEvents)
- << " s";
+ LOG(info) << "Real time per event : " << fTimeTot / Double_t(fNofEvents) << " s";
LOG(info) << "=====================================";
}
// -------------------------------------------------------------------------
// ----- Get parameter container from runtime DB -----------------------
-void CbmStsDigitize::SetParContainers() {
+void CbmStsDigitize::SetParContainers()
+{
assert(FairRunAna::Instance());
FairRuntimeDb* rtdb = FairRunAna::Instance()->GetRuntimeDb();
- fParSim = static_cast<CbmStsParSim*>(rtdb->getContainer("CbmStsParSim"));
- fParSetModule =
- static_cast<CbmStsParSetModule*>(rtdb->getContainer("CbmStsParSetModule"));
- fParSetSensor =
- static_cast<CbmStsParSetSensor*>(rtdb->getContainer("CbmStsParSetSensor"));
- fParSetCond = static_cast<CbmStsParSetSensorCond*>(
- rtdb->getContainer("CbmStsParSetSensorCond"));
+ fParSim = static_cast<CbmStsParSim*>(rtdb->getContainer("CbmStsParSim"));
+ fParSetModule = static_cast<CbmStsParSetModule*>(rtdb->getContainer("CbmStsParSetModule"));
+ fParSetSensor = static_cast<CbmStsParSetSensor*>(rtdb->getContainer("CbmStsParSetSensor"));
+ fParSetCond = static_cast<CbmStsParSetSensorCond*>(rtdb->getContainer("CbmStsParSetSensorCond"));
}
// -------------------------------------------------------------------------
// ----- Initialisation -----------------------------------------------
-InitStatus CbmStsDigitize::Init() {
+InitStatus CbmStsDigitize::Init()
+{
// Screen output
std::cout << std::endl;
@@ -387,7 +365,8 @@ InitStatus CbmStsDigitize::Init() {
// ----- Instantiation of modules --------------------------------------
-UInt_t CbmStsDigitize::InitModules() {
+UInt_t CbmStsDigitize::InitModules()
+{
UInt_t nModules = 0;
fModules.clear();
@@ -410,7 +389,8 @@ UInt_t CbmStsDigitize::InitModules() {
// ----- Initialise parameters -----------------------------------------
-void CbmStsDigitize::InitParams() {
+void CbmStsDigitize::InitParams()
+{
// --- The parameter containers are completely initialised here.
// --- Any contents possibly obtained from the runtimeDb are ignored
@@ -443,13 +423,10 @@ void CbmStsDigitize::InitParams() {
fParSetModule->SetParModule(address, *fUserParModule);
}
UInt_t deactivated = 0;
- if ( fUserFracDeadChan > 0. ) {
- deactivated = fParSetModule->DeactivateRandomChannels(fUserFracDeadChan);
- }
+ if (fUserFracDeadChan > 0.) { deactivated = fParSetModule->DeactivateRandomChannels(fUserFracDeadChan); }
fParSetModule->setChanged();
fParSetModule->setInputVersion(-2, 1);
- LOG(info) << "--- Using global ASIC parameters: \n "
- << fUserParAsic->ToString();
+ LOG(info) << "--- Using global ASIC parameters: \n " << fUserParAsic->ToString();
LOG(info) << "--- Module parameters: " << fParSetModule->ToString();
LOG(info) << "--- Deactive channels: " << deactivated << " " << fUserFracDeadChan;
@@ -462,7 +439,7 @@ void CbmStsDigitize::InitParams() {
for (Int_t iSensor = 0; iSensor < fSetup->GetNofSensors(); iSensor++) {
CbmStsSensor* sensor = fSetup->GetSensor(iSensor);
UInt_t address = sensor->GetAddress();
- TGeoBBox* box = dynamic_cast<TGeoBBox*>(sensor->GetPnode()->GetShape());
+ TGeoBBox* box = dynamic_cast<TGeoBBox*>(sensor->GetPnode()->GetShape());
assert(box);
Double_t lX = 2. * box->GetDX();
Double_t lY = 2. * box->GetDY();
@@ -478,16 +455,14 @@ void CbmStsDigitize::InitParams() {
Double_t nStripsB = dX / pitchB;
// The stereo sensors with 6.2092 cm width have 1024 strips à 58 mum.
- if (fUserParSensor->GetClass() == CbmStsSensorClass::kDssdStereo
- && TMath::Abs(lX - 6.2092) < 0.0001
+ if (fUserParSensor->GetClass() == CbmStsSensorClass::kDssdStereo && TMath::Abs(lX - 6.2092) < 0.0001
&& TMath::Abs(pitchF - 0.0058) < 0.0001) {
nStripsF = 1024.;
nStripsB = 1024.;
}
// Same for sensors with 6.2000 cm width
- if (fUserParSensor->GetClass() == CbmStsSensorClass::kDssdStereo
- && TMath::Abs(lX - 6.2) < 0.0001
+ if (fUserParSensor->GetClass() == CbmStsSensorClass::kDssdStereo && TMath::Abs(lX - 6.2) < 0.0001
&& TMath::Abs(pitchF - 0.0058) < 0.0001) {
nStripsF = 1024.;
nStripsB = 1024.;
@@ -523,7 +498,8 @@ void CbmStsDigitize::InitParams() {
// ----- Instantiation of sensors --------------------------------------
-UInt_t CbmStsDigitize::InitSensors() {
+UInt_t CbmStsDigitize::InitSensors()
+{
UInt_t nSensors = 0;
fSensors.clear();
@@ -548,8 +524,7 @@ UInt_t CbmStsDigitize::InitSensors() {
const CbmStsParSensor& sensorPar = fParSetSensor->GetParSensor(sensAddress);
// --- Create simulation sensor accordoing to its class
- auto result = fSensors.insert(
- std::make_pair(sensAddress, fSensorFactory->CreateSensor(sensorPar)));
+ auto result = fSensors.insert(std::make_pair(sensAddress, fSensorFactory->CreateSensor(sensorPar)));
assert(result.second); // If false, sensor was already in map
auto& sensor = result.first->second;
assert(sensor); // Valid sensor pointer
@@ -595,7 +570,8 @@ UInt_t CbmStsDigitize::InitSensors() {
// ----- Initialisation of setup --------------------------------------
-void CbmStsDigitize::InitSetup() {
+void CbmStsDigitize::InitSetup()
+{
// Initialise the STS setup interface from TGeoManager
fSetup = CbmStsSetup::Instance();
@@ -613,7 +589,8 @@ void CbmStsDigitize::InitSetup() {
// ----- Process the analogue buffers of all modules -------------------
-void CbmStsDigitize::ProcessAnalogBuffers(Double_t readoutTime) {
+void CbmStsDigitize::ProcessAnalogBuffers(Double_t readoutTime)
+{
// --- Process analogue buffers of all modules
for (auto& it : fModules)
@@ -623,13 +600,14 @@ void CbmStsDigitize::ProcessAnalogBuffers(Double_t readoutTime) {
// ----- Process points from MC event ---------------------------------
-void CbmStsDigitize::ProcessMCEvent() {
+void CbmStsDigitize::ProcessMCEvent()
+{
// --- Loop over all StsPoints and execute the ProcessPoint method
assert(fPoints);
for (Int_t iPoint = 0; iPoint < fPoints->GetEntriesFast(); iPoint++) {
const CbmStsPoint* point = (const CbmStsPoint*) fPoints->At(iPoint);
- CbmLink* link = new CbmLink(1., iPoint, fCurrentMCEntry, fCurrentInput);
+ CbmLink* link = new CbmLink(1., iPoint, fCurrentMCEntry, fCurrentInput);
// --- Ignore points from secondaries if the respective flag is set
if (fParSim->OnlyPrimaries()) {
@@ -653,9 +631,8 @@ void CbmStsDigitize::ProcessMCEvent() {
// ----- Process a StsPoint ---------------------------------------------
-void CbmStsDigitize::ProcessPoint(const CbmStsPoint* point,
- Double_t eventTime,
- CbmLink* link) {
+void CbmStsDigitize::ProcessPoint(const CbmStsPoint* point, Double_t eventTime, CbmLink* link)
+{
// --- Get the sensor the point is in
UInt_t address = static_cast<UInt_t>(point->GetDetectorID());
@@ -667,8 +644,8 @@ void CbmStsDigitize::ProcessPoint(const CbmStsPoint* point,
// --- Statistics
Int_t nSignalsF = status / 1000;
Int_t nSignalsB = status - 1000 * nSignalsF;
- LOG(debug2) << GetName() << ": Produced signals: " << nSignalsF + nSignalsB
- << " ( " << nSignalsF << " / " << nSignalsB << " )";
+ LOG(debug2) << GetName() << ": Produced signals: " << nSignalsF + nSignalsB << " ( " << nSignalsF << " / "
+ << nSignalsB << " )";
fNofSignalsF += nSignalsF;
fNofSignalsB += nSignalsB;
}
@@ -676,7 +653,8 @@ void CbmStsDigitize::ProcessPoint(const CbmStsPoint* point,
// ----- Private method ReInit -----------------------------------------
-InitStatus CbmStsDigitize::ReInit() {
+InitStatus CbmStsDigitize::ReInit()
+{
fSetup = CbmStsSetup::Instance();
@@ -686,7 +664,8 @@ InitStatus CbmStsDigitize::ReInit() {
// ----- Reset event counters ------------------------------------------
-void CbmStsDigitize::ResetCounters() {
+void CbmStsDigitize::ResetCounters()
+{
fTimeDigiFirst = fTimeDigiLast = -1.;
fNofPointsProc = 0;
fNofPointsIgno = 0;
@@ -698,7 +677,8 @@ void CbmStsDigitize::ResetCounters() {
// ----- Global default values for parameters --------------------------
-void CbmStsDigitize::SetGlobalDefaults() {
+void CbmStsDigitize::SetGlobalDefaults()
+{
// The global default values cannot be directly stored in the parameter
// containers, since these are not yet initialised from the database.
@@ -737,8 +717,7 @@ void CbmStsDigitize::SetGlobalDefaults() {
Double_t deadTime = 800.; // Channel dead time [ns]
Double_t noiseRms = 1000.; // RMS of noise [e]
Double_t znr = 3.9789e-3; // Zero-crossing noise rate [1/ns]
- fUserParAsic = new CbmStsParAsic(nAsicChannels, nAdc, dynRange, threshold,
- timeResol, deadTime, noiseRms, znr);
+ fUserParAsic = new CbmStsParAsic(nAsicChannels, nAdc, dynRange, threshold, timeResol, deadTime, noiseRms, znr);
// --- Sensor parameters
// --- Here, only the default pitch and stereo angles are defined. The
// --- other parameters are extracted from the geometry.
@@ -762,34 +741,28 @@ void CbmStsDigitize::SetGlobalDefaults() {
Double_t temperature = 268.; // Temperature
Double_t cCoupling = 17.5; // Coupling capacitance [pF]
Double_t cInterstrip = 1.; // Inter-strip capacitance
- fUserParCond =
- new CbmStsParSensorCond(vFd, vBias, temperature, cCoupling, cInterstrip);
+ fUserParCond = new CbmStsParSensorCond(vFd, vBias, temperature, cCoupling, cInterstrip);
}
// -------------------------------------------------------------------------
// ----- Set the global module parameters ------------------------------
-void CbmStsDigitize::SetGlobalAsicParams(UShort_t nChannels,
- UShort_t nAdc,
- Double_t dynRange,
- Double_t threshold,
- Double_t timeResolution,
- Double_t deadTime,
- Double_t noise,
- Double_t zeroNoiseRate) {
+void CbmStsDigitize::SetGlobalAsicParams(UShort_t nChannels, UShort_t nAdc, Double_t dynRange, Double_t threshold,
+ Double_t timeResolution, Double_t deadTime, Double_t noise,
+ Double_t zeroNoiseRate)
+{
assert(!fIsInitialised);
assert(nAdc > 0);
if (fUserParAsic) delete fUserParAsic;
- fUserParAsic = new CbmStsParAsic(nChannels, nAdc, dynRange, threshold,
- timeResolution, deadTime, noise,
- zeroNoiseRate);
+ fUserParAsic =
+ new CbmStsParAsic(nChannels, nAdc, dynRange, threshold, timeResolution, deadTime, noise, zeroNoiseRate);
}
// -------------------------------------------------------------------------
// ----- Set the global module parameters ------------------------------
-void CbmStsDigitize::SetGlobalModuleParams(UInt_t nChannels,
- UInt_t nAsicChannels) {
+void CbmStsDigitize::SetGlobalModuleParams(UInt_t nChannels, UInt_t nAsicChannels)
+{
assert(!fIsInitialised);
if (fUserParModule) delete fUserParModule;
@@ -799,22 +772,20 @@ void CbmStsDigitize::SetGlobalModuleParams(UInt_t nChannels,
// ----- Set the global sensor conditions ------------------------------
-void CbmStsDigitize::SetGlobalSensorConditions(Double_t vFd,
- Double_t vBias,
- Double_t temperature,
- Double_t cCoupling,
- Double_t cInterstrip) {
+void CbmStsDigitize::SetGlobalSensorConditions(Double_t vFd, Double_t vBias, Double_t temperature, Double_t cCoupling,
+ Double_t cInterstrip)
+{
assert(!fIsInitialised);
if (fUserParCond) delete fUserParCond;
- fUserParCond =
- new CbmStsParSensorCond(vFd, vBias, temperature, cCoupling, cInterstrip);
+ fUserParCond = new CbmStsParSensorCond(vFd, vBias, temperature, cCoupling, cInterstrip);
}
// -------------------------------------------------------------------------
// ----- Set sensor parameter file -------------------------------------
-void CbmStsDigitize::SetModuleParameterFile(const char* fileName) {
+void CbmStsDigitize::SetModuleParameterFile(const char* fileName)
+{
assert(!fIsInitialised);
fModuleParameterFile = fileName;
@@ -823,28 +794,26 @@ void CbmStsDigitize::SetModuleParameterFile(const char* fileName) {
// ----- Set physical processes for the analogue response ---------------
-void CbmStsDigitize::SetProcesses(CbmStsELoss eLossModel,
- Bool_t useLorentzShift,
- Bool_t useDiffusion,
- Bool_t useCrossTalk) {
+void CbmStsDigitize::SetProcesses(CbmStsELoss eLossModel, Bool_t useLorentzShift, Bool_t useDiffusion,
+ Bool_t useCrossTalk)
+{
if (fIsInitialised) {
LOG(error) << GetName() << ": physics processes must be set before "
<< "initialisation! Statement will have no effect.";
return;
}
- fParSim->SetProcesses(
- eLossModel, useLorentzShift, useDiffusion, useCrossTalk);
+ fParSim->SetProcesses(eLossModel, useLorentzShift, useDiffusion, useCrossTalk);
}
// -------------------------------------------------------------------------
// ----- Set sensor condition file -------------------------------------
-void CbmStsDigitize::SetSensorConditionFile(const char* fileName) {
+void CbmStsDigitize::SetSensorConditionFile(const char* fileName)
+{
if (fIsInitialised) {
- LOG(fatal) << GetName()
- << ": sensor conditions must be set before initialisation!";
+ LOG(fatal) << GetName() << ": sensor conditions must be set before initialisation!";
return;
}
fSensorConditionFile = fileName;
@@ -853,11 +822,11 @@ void CbmStsDigitize::SetSensorConditionFile(const char* fileName) {
// ----- Set sensor parameter file -------------------------------------
-void CbmStsDigitize::SetSensorParameterFile(const char* fileName) {
+void CbmStsDigitize::SetSensorParameterFile(const char* fileName)
+{
if (fIsInitialised) {
- LOG(fatal) << GetName()
- << ": sensor parameters must be set before initialisation!";
+ LOG(fatal) << GetName() << ": sensor parameters must be set before initialisation!";
return;
}
fSensorParameterFile = fileName;
@@ -866,9 +835,7 @@ void CbmStsDigitize::SetSensorParameterFile(const char* fileName) {
// ----- Usage of primary tracks only ----------------------------------
-void CbmStsDigitize::UseOnlyPrimaries(Bool_t flag) {
- fUserParSim->SetOnlyPrimaries(flag);
-}
+void CbmStsDigitize::UseOnlyPrimaries(Bool_t flag) { fUserParSim->SetOnlyPrimaries(flag); }
// -------------------------------------------------------------------------
ClassImp(CbmStsDigitize)
diff --git a/sim/detectors/sts/CbmStsDigitize.h b/sim/detectors/sts/CbmStsDigitize.h
index f8ce957de16e26ce633b47b34c62aa149ab27df4..02cd96959c17bb64ba98f44703ef99329c02808b 100644
--- a/sim/detectors/sts/CbmStsDigitize.h
+++ b/sim/detectors/sts/CbmStsDigitize.h
@@ -6,9 +6,6 @@
#ifndef CBMSTSDIGITIZE_H
#define CBMSTSDIGITIZE_H 1
-#include "TStopwatch.h"
-#include <map>
-
#include "CbmDefs.h"
#include "CbmDigitize.h"
#include "CbmMatch.h"
@@ -18,6 +15,10 @@
#include "CbmStsSimModule.h"
#include "CbmStsSimSensor.h"
+#include "TStopwatch.h"
+
+#include <map>
+
class TClonesArray;
class CbmStsPoint;
class CbmStsParAsic;
@@ -64,11 +65,7 @@ public:
** @param adc Digitised charge [ADC channels]
** @param match MC Match object
**/
- void CreateDigi(Int_t address,
- UShort_t channel,
- Long64_t time,
- UShort_t adc,
- const CbmMatch& match);
+ void CreateDigi(Int_t address, UShort_t channel, Long64_t time, UShort_t adc, const CbmMatch& match);
/** @brief Detector system ID
@@ -127,14 +124,8 @@ public:
**
** These parameters will be applied to all ASICS in all modules.
**/
- void SetGlobalAsicParams(UShort_t nChannels,
- UShort_t nAdc,
- Double_t dynRange,
- Double_t threshold,
- Double_t timeResolution,
- Double_t deadTime,
- Double_t noise,
- Double_t zeroNoiseRate);
+ void SetGlobalAsicParams(UShort_t nChannels, UShort_t nAdc, Double_t dynRange, Double_t threshold,
+ Double_t timeResolution, Double_t deadTime, Double_t noise, Double_t zeroNoiseRate);
/** @brief Set global fraction of dead channels
@@ -143,9 +134,7 @@ public:
** If this number is different from zero, in each ASIC a number of
** channels corresponding to this fraction are deactivated.
**/
- void SetGlobalFracDeadChannels(Double_t fraction) {
- fUserFracDeadChan = fraction;
- }
+ void SetGlobalFracDeadChannels(Double_t fraction) { fUserFracDeadChan = fraction; }
/** @brief Set the global module parameters
@@ -167,10 +156,7 @@ public:
** These parameters will be applied to all sensors when no
** condition file is specified.
**/
- void SetGlobalSensorConditions(Double_t vDep,
- Double_t vBias,
- Double_t temperature,
- Double_t cCoupling,
+ void SetGlobalSensorConditions(Double_t vDep, Double_t vBias, Double_t temperature, Double_t cCoupling,
Double_t cInterstrip);
@@ -191,10 +177,8 @@ public:
**
** Changing the physics flags is only allowed before Init() is called.
**/
- void SetProcesses(CbmStsELoss eLossModel,
- Bool_t useLorentzShift = kTRUE,
- Bool_t useDiffusion = kTRUE,
- Bool_t useCrossTalk = kTRUE);
+ void SetProcesses(CbmStsELoss eLossModel, Bool_t useLorentzShift = kTRUE, Bool_t useDiffusion = kTRUE,
+ Bool_t useCrossTalk = kTRUE);
/** @brief Set the file name with sensor conditions
@@ -249,9 +233,9 @@ private:
//std::map<Int_t, CbmStsDigitizeParameters*> fModuleParameterMap; ///< Individual module parameter map
CbmStsSetup* fSetup; //! STS setup interface
CbmStsSimSensorFactory* fSensorFactory = nullptr; //! Sensor factory
- TClonesArray* fPoints; ///< Input array of CbmStsPoint
- TClonesArray* fTracks; ///< Input array of CbmMCTrack
- TStopwatch fTimer; ///< ROOT timer
+ TClonesArray* fPoints; ///< Input array of CbmStsPoint
+ TClonesArray* fTracks; ///< Input array of CbmMCTrack
+ TStopwatch fTimer; ///< ROOT timer
/** Map of modules. Key is the address. **/
std::map<UInt_t, CbmStsSimModule*> fModules {};
@@ -265,8 +249,8 @@ private:
CbmStsParModule* fUserParModule = nullptr; ///< User defined, global
CbmStsParSensor* fUserParSensor = nullptr; ///< User defined, global
CbmStsParSensorCond* fUserParCond = nullptr; ///< User defined, global
- Double_t fUserDinactive = 0.; ///< Size of inactive sensor border [cm]
- Double_t fUserFracDeadChan = 0.; ///< Fraction of inactive ASIC channels
+ Double_t fUserDinactive = 0.; ///< Size of inactive sensor border [cm]
+ Double_t fUserFracDeadChan = 0.; ///< Fraction of inactive ASIC channels
// --- Module and sensor parameters for runtime DB output
CbmStsParSim* fParSim = nullptr; ///< Simulation settings
@@ -361,9 +345,7 @@ private:
** @param point Pointer to CbmStsPoint to be processed
** @param link Link to MCPoint
**/
- void ProcessPoint(const CbmStsPoint* point,
- Double_t eventTime = 0.,
- CbmLink* link = NULL);
+ void ProcessPoint(const CbmStsPoint* point, Double_t eventTime = 0., CbmLink* link = NULL);
/** @brief Reset event counters **/