CbmStsDigitize.cxx

Go to the documentation of this file.

 
// Include class header
#include "CbmStsDigitize.h"
 
// Includes from C++
#include <cassert>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <sstream>
 
// Includes from ROOT
#include "TClonesArray.h"
#include "TGeoBBox.h"
#include "TGeoMatrix.h"
#include "TGeoPhysicalNode.h"
#include "TGeoVolume.h"
#include <TMCProcess.h>
 
// Includes from FairRoot
#include "FairEventHeader.h"
#include "FairField.h"
#include "FairLink.h"
#include "FairLogger.h"
#include "FairMCEventHeader.h"
#include "FairMCPoint.h"
#include "FairRunAna.h"
#include "FairRunSim.h"
#include "FairRuntimeDb.h"
 
// Includes from CbmRoot
#include "CbmMCTrack.h"
#include "CbmStsDigi.h"
#include "CbmStsPoint.h"
 
// 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"
#include "CbmStsParSensorCond.h"
#include "CbmStsParSetModule.h"
#include "CbmStsParSetSensor.h"
#include "CbmStsParSetSensorCond.h"
#include "CbmStsParSim.h"
 
using std::fixed;
using std::left;
using std::right;
using std::setprecision;
using std::setw;
using std::string;
using std::stringstream;
 
using namespace CbmSts;
 
 
// -----   Standard constructor   ------------------------------------------
CbmStsDigitize::CbmStsDigitize()
  : CbmDigitize<CbmStsDigi>("StsDigitize")
  , fIsInitialised(kFALSE)
  ,
  //fModuleParameterMap(),
  fSetup(nullptr)
  , fPoints(nullptr)
  , fTracks(nullptr)
  , fTimer()
  , fSensorDinact(0.12)
  , fSensorPitch(0.0058)
  , fSensorStereoF(0.)
  , fSensorStereoB(7.5)
  , fSensorParameterFile()
  , fSensorConditionFile()
  , fModuleParameterFile()
  , fTimePointLast(-1.)
  , fTimeDigiFirst(-1.)
  , fTimeDigiLast(-1.) {
  ResetCounters();
  SetGlobalDefaults();
}
// -------------------------------------------------------------------------
 
 
// -----   Destructor   ----------------------------------------------------
CbmStsDigitize::~CbmStsDigitize() {}
// -------------------------------------------------------------------------
 
 
// -----   Content of analogue buffers   -----------------------------------
Int_t CbmStsDigitize::BufferSize() const {
  Int_t nSignals = 0;
  Int_t nSigModule;
  Double_t t1Module;
  Double_t t2Module;
 
  for (auto& entry : fModules) {
    entry.second->BufferStatus(nSigModule, t1Module, t2Module);
    nSignals += nSigModule;
  }  //# modules
 
  return nSignals;
}
// -------------------------------------------------------------------------
 
 
// -----   Print the status of the analogue buffers   ----------------------
string CbmStsDigitize::BufferStatus() const {
 
  Int_t nSignals = 0;
  Double_t t1    = -1;
  Double_t t2    = -1.;
 
  Int_t nSigModule;
  Double_t t1Module;
  Double_t t2Module;
 
  for (auto& entry : fModules) {
    entry.second->BufferStatus(nSigModule, t1Module, t2Module);
    if (nSigModule) {
      nSignals += nSigModule;
      t1 = t1 < 0. ? t1Module : TMath::Min(t1, t1Module);
      t2 = TMath::Max(t2, t2Module);
    }  //? signals in module buffer?
  }    //# 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 )";
  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) {
 
  // Update times of first and last digi
  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
    SendData(digi);
  fNofDigis++;
}
// -------------------------------------------------------------------------
 
 
// -----   Task execution   ------------------------------------------------
void CbmStsDigitize::Exec(Option_t* /*opt*/) {
 
  // --- Start timer and reset counters
  fTimer.Start();
  ResetCounters();
 
  // --- For debug: status of analogue buffers
  if (gLogger->IsLogNeeded(fair::Severity::debug)) {
    std::cout << std::endl;
    LOG(debug) << GetName() << ": " << BufferStatus();
  }
 
  // --- Store previous event time.  Get current event time.
  Double_t eventTimePrevious = fCurrentEventTime;
  GetEventInfo();
 
  // --- Generate noise from previous to current event time
  if (fParSim->Noise()) {
    Int_t nNoise         = 0;
    Double_t tNoiseStart = fNofEvents ? eventTimePrevious : 0.;
    Double_t tNoiseEnd   = fCurrentEventTime;
    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";
  }
 
  // --- Analogue response: Process the input array of StsPoints
  ProcessMCEvent();
  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();
  }
 
  // --- Readout time: in stream mode the time of the current event.
  // --- Analogue buffers will be digitised for signals at times smaller than
  // --- that time minus a safety margin depending on the module properties
  // --- (dead time and time resolution). In event mode, the readout time
  // --- is set to -1., meaning to digitise everything in the readout buffers.
  Double_t readoutTime = fEventMode ? -1. : fCurrentEventTime;
 
  // --- Digital response: Process buffers of all modules
  ProcessAnalogBuffers(readoutTime);
 
  // --- Check status of analogue module buffers
  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;
 
  // --- Counters
  fTimer.Stop();
  fNofEvents++;
  fNofPointsProcTot += fNofPointsProc;
  fNofPointsIgnoTot += fNofPointsIgno;
  fNofSignalsFTot += fNofSignalsF;
  fNofSignalsBTot += fNofSignalsB;
  fNofDigisTot += fNofDigis;
  fTimeTot += fTimer.RealTime();
}
// -------------------------------------------------------------------------
 
 
// -----   Finish run    ---------------------------------------------------
void CbmStsDigitize::Finish() {
 
  // --- Start timer and reset counters
  fTimer.Start();
  ResetCounters();
 
  // --- In event-by-event mode, the analogue buffers should be empty.
  if (fEventMode) {
    if (BufferSize()) {
      LOG(info) << fName << BufferStatus();
      LOG(fatal) << fName << ": Non-empty analogue buffers at end of event "
                 << " in event-by-event mode!";
    }  //? buffers not empty
  }    //? event-by-event mode
 
  // ---  In time-based mode: process the remaining signals in the buffers
  else {
    std::cout << std::endl;
    LOG(info) << GetName() << ": Finish run";
    LOG(info) << GetName() << ": " << BufferStatus();
    LOG(info) << GetName() << ": Processing analogue buffers";
 
    // --- Process buffers of all modules
    for (auto& entry : fModules)
      entry.second->ProcessAnalogBuffer(-1.);
 
    // --- Screen output
    stringstream ss;
    ss << GetName() << ": " << fNofDigis
       << (fNofDigis == 1 ? " digi " : " digis ") << "created and sent to DAQ ";
    if (fNofDigis)
      ss << "( from " << fixed << setprecision(3) << fTimeDigiFirst << " ns to "
         << fTimeDigiLast << " ns )";
    LOG(info) << ss.str();
    LOG(info) << GetName() << ": " << BufferStatus();
  }
 
  fTimer.Stop();
  fNofPointsProcTot += fNofPointsProc;
  fNofPointsIgnoTot += fNofPointsIgno;
  fNofSignalsFTot += fNofSignalsF;
  fNofSignalsBTot += fNofSignalsB;
  fNofDigisTot += fNofDigis;
  fTimeTot += fTimer.RealTime();
 
  std::cout << std::endl;
  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) << " / "
            << 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) << "Noise fraction         : " << fNofNoiseTot / fNofDigisTot;
  LOG(info) << "Real time per event    : " << fTimeTot / Double_t(fNofEvents)
            << " s";
  LOG(info) << "=====================================";
}
// -------------------------------------------------------------------------
 
 
// -----   Get parameter container from runtime DB   -----------------------
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"));
}
// -------------------------------------------------------------------------
 
 
// -----   Initialisation    -----------------------------------------------
InitStatus CbmStsDigitize::Init() {
 
  // Screen output
  std::cout << std::endl;
  LOG(info) << "==========================================================";
  LOG(info) << GetName() << ": Initialisation \n\n";
 
  // Initialise the STS setup interface from TGeoManager
  fSetup = CbmStsSetup::Instance();
  fSetup->Init();
 
  // --- Instantiate StsPhysics
  CbmStsPhysics::Instance();
 
  // --- Initialise parameters
  InitParams();
 
  // Instantiate modules
  UInt_t nModules = InitModules();
  LOG(info) << GetName() << ": Created " << nModules << " modules";
 
  // Instantiate sensors
  UInt_t nSensors = InitSensors();
  LOG(info) << GetName() << ": Created " << nSensors << " sensors";
 
 
  // --- Get FairRootManager instance
  FairRootManager* ioman = FairRootManager::Instance();
  assert(ioman);
 
  // --- Get input array (CbmStsPoint)
  fPoints = (TClonesArray*) ioman->GetObject("StsPoint");
  assert(fPoints);
 
  // --- Get input array (CbmMCTrack)
  fTracks = (TClonesArray*) ioman->GetObject("MCTrack");
  assert(fTracks);
 
  RegisterOutput();
 
  // --- Screen output
  LOG(info) << GetName() << ": Initialisation successful";
  LOG(info) << "==========================================================";
  std::cout << std::endl;
 
  // Set static initialisation flag
  fIsInitialised = kTRUE;
 
  return kSUCCESS;
}
// -------------------------------------------------------------------------
 
 
// -----   Instantiation of modules   --------------------------------------
UInt_t CbmStsDigitize::InitModules() {
 
  UInt_t nModules = 0;
  fModules.clear();
 
  for (Int_t iModule = 0; iModule < fSetup->GetNofModules(); iModule++) {
    CbmStsElement* geoModule = fSetup->GetModule(iModule);
    assert(geoModule);
    UInt_t address          = geoModule->GetAddress();
    auto& modulePar         = fParSetModule->GetParModule(address);
    CbmStsSimModule* module = new CbmStsSimModule(geoModule, &modulePar, this);
    auto result             = fModules.insert({address, module});
    assert(result.second);  // If false, module was already in map
    nModules++;
  }  //# modules in setup
 
  assert(nModules == fModules.size());
  return nModules;
}
// -------------------------------------------------------------------------
 
 
// -----   Initialise parameters   -----------------------------------------
void CbmStsDigitize::InitParams() {
 
  // --- The parameter containers are completely initialised here.
  // --- Any contents possibly obtained from the runtimeDb are ignored
  // --- and overwritten.
 
  // --- Simulation settings
  assert(fParSim);
  assert(fUserParSim);
  *fParSim = *fUserParSim;                   // adapt user settings
  fParSim->SetEventMode(fEventMode);         // from CbmDigitizeBase
  fParSim->SetGenerateNoise(fProduceNoise);  // from CbmDigitizeBase
  /*  fParSim->SetProcesses(fUserParSim->ELossModel(),
                        fUserParSim->LorentzShift(),
                        fUserParSim->Diffusion(),
                        fUserParSim->CrossTalk());
                        */
  if (fEventMode) fParSim->SetGenerateNoise(kFALSE);
  fParSim->setChanged();
  fParSim->setInputVersion(-2, 1);
  LOG(info) << "--- Settings: " << fParSim->ToString();
 
  // --- Module parameters (global for the time being)
  assert(fParSetModule);
  fParSetModule->clear();
  assert(fUserParModule);
  assert(fUserParAsic);
  fUserParModule->SetAllAsics(*fUserParAsic);
  fParSetModule->SetGlobalPar(*fUserParModule);
  fParSetModule->setChanged();
  fParSetModule->setInputVersion(-2, 1);
  LOG(info) << "--- Using global ASIC parameters: \n       "
            << fUserParAsic->ToString();
  LOG(info) << "--- Module parameters: " << fParSetModule->ToString();
 
  // --- Sensor parameters
  // TODO: The code above is highly unsatisfactory. A better implementation
  // would use data sheets with the actual sensor design parameters.
  assert(fParSetSensor);
  fParSetSensor->clear();
  assert(fUserParSensor);
  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());
    assert(box);
    Double_t lX = 2. * box->GetDX();
    Double_t lY = 2. * box->GetDY();
    Double_t lZ = 2. * box->GetDZ();
    Double_t dX = lX - 2. * fUserDinactive;
    Double_t dY = lY - 2. * fUserDinactive;
 
    // In general, the number of strips is given by the active size in x
    // divided by the strip pitch.
    Double_t pitchF   = fUserParSensor->GetPar(6);
    Double_t pitchB   = fUserParSensor->GetPar(7);
    Double_t nStripsF = dX / pitchF;
    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
        && 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
        && TMath::Abs(pitchF - 0.0058) < 0.0001) {
      nStripsF = 1024.;
      nStripsB = 1024.;
    }
 
    // Create a sensor parameter object and add it to the container
    CbmStsParSensor par(fUserParSensor->GetClass());
    par.SetPar(0, lX);        // Extension in x
    par.SetPar(1, lY);        // Extension in y
    par.SetPar(2, lZ);        // Extension in z
    par.SetPar(3, dY);        // Active size in y
    par.SetPar(4, nStripsF);  // Number of strips front side
    par.SetPar(5, nStripsB);  // Number of strips back side
    for (UInt_t parIndex = 6; parIndex < 10; parIndex++) {
      par.SetPar(parIndex, fUserParSensor->GetPar(parIndex));
    }  //# parameters 6 - 9 (pitches and stereo angles) set by user or default
    fParSetSensor->SetParSensor(address, par);
 
  }  //# sensors in setup
  LOG(info) << "--- Sensor parameters: " << fParSetSensor->ToString();
  fParSetSensor->setChanged();
  fParSetSensor->setInputVersion(-2, 1);
 
  // --- Sensor conditions
  assert(fParSetCond);
  fParSetCond->clear();
  fParSetCond->SetGlobalPar(*fUserParCond);
  LOG(info) << "--- Sensor conditions: " << fParSetCond->ToString();
  fParSetCond->setChanged();
  fParSetCond->setInputVersion(-2, 1);
}
// -------------------------------------------------------------------------
 
 
// -----   Instantiation of sensors   --------------------------------------
UInt_t CbmStsDigitize::InitSensors() {
 
  UInt_t nSensors = 0;
  fSensors.clear();
 
  fSensorFactory = new CbmStsSimSensorFactory();
  for (Int_t iSensor = 0; iSensor < fSetup->GetNofSensors(); iSensor++) {
 
    // --- Sensor and module elements in setup
    CbmStsElement* geoSensor = fSetup->GetSensor(iSensor);
    assert(geoSensor);  // Valid geo sensor
    UInt_t sensAddress       = geoSensor->GetAddress();
    CbmStsElement* geoModule = geoSensor->GetMother();
    assert(geoModule);  // Valid geo mother module
    UInt_t moduAddress = geoModule->GetAddress();
 
    // --- Simulation module
    auto moduIt = fModules.find(moduAddress);
    assert(moduIt != fModules.end());
    assert(moduIt->second);  // Valid sim module
 
    // --- Sensor parameters
    const CbmStsParSensor& sensorPar = fParSetSensor->GetParSensor(sensAddress);
 
    // --- Create simulation sensor accordoing to its class
    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
 
    // Assign setup element and module
    sensor->SetElement(geoSensor);
    sensor->SetModule(moduIt->second);
 
    // Assign simulation settings
    sensor->SetSimSettings(fParSim);
 
    // Set sensor conditions
    assert(fParSetCond);
    const CbmStsParSensorCond& cond = fParSetCond->GetParSensor(sensAddress);
    sensor->SetConditions(&cond);
 
    // Get the magnetic field in the sensor centre
    Double_t bx = 0.;
    Double_t by = 0.;
    Double_t bz = 0.;
    if (FairRun::Instance()->GetField()) {
      Double_t local[3] = {0., 0., 0.};  // sensor centre in local C.S.
      Double_t global[3];                // sensor centre in global C.S.
      geoSensor->GetPnode()->GetMatrix()->LocalToMaster(local, global);
      Double_t field[3] = {0., 0., 0.};  // magnetic field components
      FairRun::Instance()->GetField()->Field(global, field);
      bx = field[0] / 10.;  // kG->T
      by = field[1] / 10.;  // kG->T
      bz = field[2] / 10.;  // kG->T
    }                       //? field present
    sensor->SetField(bx, by, bz);
 
    // Initialise sensor
    assert(sensor->Init());
 
    nSensors++;
  }  //# sensors in setup
 
  assert(nSensors == fSensors.size());
  return nSensors;
}
// -------------------------------------------------------------------------
 
 
// -----   Initialisation of setup    --------------------------------------
void CbmStsDigitize::InitSetup() {
 
  // Initialise the STS setup interface from TGeoManager
  fSetup = CbmStsSetup::Instance();
  fSetup->Init();
 
  // Set parameters to modules and sensor
  fSetup->SetModuleParameters(fParSetModule);
  fSetup->SetSensorParameters(fParSetSensor);
  fSetup->SetSensorConditions(fParSetCond);
 
  // Individual configuration
  //fSetup->SetModuleParameterMap(fModuleParameterMap);
}
// -------------------------------------------------------------------------
 
 
// -----   Process the analogue buffers of all modules   -------------------
void CbmStsDigitize::ProcessAnalogBuffers(Double_t readoutTime) {
 
  // --- Process analogue buffers of all modules
  for (auto& it : fModules)
    it.second->ProcessAnalogBuffer(readoutTime);
}
// -------------------------------------------------------------------------
 
 
// -----   Process points from MC event    ---------------------------------
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);
 
    // --- Ignore points from secondaries if the respective flag is set
    if (fParSim->OnlyPrimaries()) {
      Int_t iTrack = point->GetTrackID();
      if (iTrack >= 0) {  // MC track is present
        CbmMCTrack* track = (CbmMCTrack*) fTracks->At(iTrack);
        assert(track);
        if (track->GetGeantProcessId() != kPPrimary) {
          fNofPointsIgno++;
          continue;
        }
      }  //? MC track present
    }    //? discard secondaries
 
    ProcessPoint(point, fCurrentEventTime, link);
    fNofPointsProc++;
    delete link;
  }  //# StsPoints
}
// -------------------------------------------------------------------------
 
 
// -----  Process a StsPoint   ---------------------------------------------
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());
  assert(fSensors.count(address));
  auto& sensor = fSensors.find(address)->second;
  assert(sensor);
  Int_t status = sensor->ProcessPoint(point, eventTime, link);
 
  // --- Statistics
  Int_t nSignalsF = status / 1000;
  Int_t nSignalsB = status - 1000 * nSignalsF;
  LOG(debug2) << GetName() << ": Produced signals: " << nSignalsF + nSignalsB
              << " ( " << nSignalsF << " / " << nSignalsB << " )";
  fNofSignalsF += nSignalsF;
  fNofSignalsB += nSignalsB;
}
// -------------------------------------------------------------------------
 
 
// -----   Private method ReInit   -----------------------------------------
InitStatus CbmStsDigitize::ReInit() {
 
  fSetup = CbmStsSetup::Instance();
 
  return kERROR;
}
// -------------------------------------------------------------------------
 
 
// -----   Reset event counters   ------------------------------------------
void CbmStsDigitize::ResetCounters() {
  fTimeDigiFirst = fTimeDigiLast = -1.;
  fNofPointsProc                 = 0;
  fNofPointsIgno                 = 0;
  fNofSignalsF                   = 0;
  fNofSignalsB                   = 0;
  fNofDigis                      = 0;
}
// -------------------------------------------------------------------------
 
 
// -----   Global default values for parameters   --------------------------
void CbmStsDigitize::SetGlobalDefaults() {
 
  // The global default values cannot be directly stored in the parameter
  // containers, since these are not yet initialised from the database.
 
  // --- Protect against setting after initialisation
  assert(!fIsInitialised);
 
  // --- Simulation settings
  if (fUserParSim) delete fUserParSim;
  fUserParSim            = new CbmStsParSim();
  Bool_t eventMode       = kFALSE;
  CbmStsELoss eLossModel = CbmStsELoss::kUrban;
  Bool_t lorentzShift    = kTRUE;
  Bool_t diffusion       = kTRUE;
  Bool_t crossTalk       = kTRUE;
  Bool_t generateNoise   = kTRUE;
  fUserParSim->SetEventMode(eventMode);
  fUserParSim->SetProcesses(eLossModel, lorentzShift, diffusion, crossTalk);
  fUserParSim->SetGenerateNoise(generateNoise);
  // Note that the run mode and the generation of noise are centrally set
  // through the base class CbmDigitizeBase, such that the settings here
  // will be overwritten later (in Init).
 
  // --- ASIC parameters
  if (fUserParAsic) delete fUserParAsic;
  UInt_t nAdc        = 32;         // Number of ADC channels (5 bit)
  Double_t dynRange  = 75000.;     // Dynamic range [e]
  Double_t threshold = 3000.;      // Threshold [e]
  Double_t timeResol = 5.;         // Time resolution [ns]
  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(
    nAdc, dynRange, threshold, timeResol, deadTime, noiseRms, znr);
 
  // --- Module parameters
  if (fUserParModule) delete fUserParModule;
  UInt_t nChannels     = 2048;  // Number of module readout channels
  UInt_t nAsicChannels = 128;   // Number of readout channels per ASIC
  fUserParModule       = new CbmStsParModule(nChannels, nAsicChannels);
 
  // --- Sensor parameters
  // --- Here, only the default pitch and stereo angles are defined. The
  // --- other parameters are extracted from the geometry.
  if (fUserParSensor) delete fUserParSensor;
  CbmStsSensorClass sClass = CbmStsSensorClass::kDssdStereo;
  fUserParSensor           = new CbmStsParSensor(sClass);
  Double_t pitchF          = 0.0058;  // Strip pitch front side
  Double_t pitchB          = 0.0058;  // Strip pitch back side
  Double_t stereoF         = 0.;      // Stereo angle front side
  Double_t stereoB         = 7.5;     // Stereo angle back side [deg]
  fUserParSensor->SetPar(6, pitchF);
  fUserParSensor->SetPar(7, pitchB);
  fUserParSensor->SetPar(8, stereoF);
  fUserParSensor->SetPar(9, stereoB);
  fUserDinactive = 0.12;  // Size of inactive sensor border [cm]
 
  // --- Sensor conditions
  if (fUserParCond) delete fUserParCond;
  Double_t vFd         = 70.;   // Full-depletion voltage
  Double_t vBias       = 140.;  // Bias voltage
  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);
}
// -------------------------------------------------------------------------
 
 
// -----   Set the global module parameters   ------------------------------
void CbmStsDigitize::SetGlobalAsicParams(UInt_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(
    nAdc, dynRange, threshold, timeResolution, deadTime, noise, zeroNoiseRate);
}
// -------------------------------------------------------------------------
 
 
// -----   Set the global module parameters   ------------------------------
void CbmStsDigitize::SetGlobalModuleParams(UInt_t nChannels,
                                           UInt_t nAsicChannels) {
  assert(!fIsInitialised);
 
  if (fUserParModule) delete fUserParModule;
  fUserParModule = new CbmStsParModule(nChannels, nAsicChannels);
}
// -------------------------------------------------------------------------
 
 
// -----   Set the global sensor conditions   ------------------------------
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);
}
// -------------------------------------------------------------------------
 
 
// -----   Set sensor parameter file   -------------------------------------
void CbmStsDigitize::SetModuleParameterFile(const char* fileName) {
 
  assert(!fIsInitialised);
  fModuleParameterFile = fileName;
}
// -------------------------------------------------------------------------
 
 
// -----   Set physical processes for the analogue response  ---------------
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);
}
// -------------------------------------------------------------------------
 
 
// -----   Set sensor condition file   -------------------------------------
void CbmStsDigitize::SetSensorConditionFile(const char* fileName) {
 
  if (fIsInitialised) {
    LOG(fatal) << GetName()
               << ": sensor conditions must be set before initialisation!";
    return;
  }
  fSensorConditionFile = fileName;
}
// -------------------------------------------------------------------------
 
 
// -----   Set sensor parameter file   -------------------------------------
void CbmStsDigitize::SetSensorParameterFile(const char* fileName) {
 
  if (fIsInitialised) {
    LOG(fatal) << GetName()
               << ": sensor parameters must be set before initialisation!";
    return;
  }
  fSensorParameterFile = fileName;
}
// -------------------------------------------------------------------------
 
 
// -----   Usage of primary tracks only   ----------------------------------
void CbmStsDigitize::UseOnlyPrimaries(Bool_t flag) {
  fUserParSim->SetOnlyPrimaries(flag);
}
// -------------------------------------------------------------------------
 
ClassImp(CbmStsDigitize)