CbmMvdDetector.cxx

Go to the documentation of this file.

/* Copyright (C) 2014-2021 Institut fuer Kernphysik, Goethe-Universitaet Frankfurt, Frankfurt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Philipp Sitzmann [committer] */
 
// -------------------------------------------------------------------------
// -----                     CbmMvdDetector source file                  -----
// -----                  Created 31/01/11  by M. Deveaux              -----
// -------------------------------------------------------------------------
 
#include "CbmMvdDetector.h"
 
#include "CbmMvdAddress.h"
#include "CbmMvdGeoHandler.h"    // for CbmMvdGeoHandler
#include "CbmMvdHelper.h"        // for CbmMvdSensorTyp
#include "CbmMvdSensor.h"        // for CbmMvdSensor
#include "CbmMvdSensorPlugin.h"  // for CbmMvdSensorPlugin, MvdSensorPluginType
#include "CbmMvdSensorTask.h"    // for CbmMvdSensorTask
 
#include <Logger.h>  // for LOG, Logger
 
#include <Rtypes.h>        // for TGenericClassInfo
#include <TClonesArray.h>  // for TClonesArray
#include <TH1.h>           // for Histograms (only base class is used)
#include <TNamed.h>        // for TNamed
#include <TObjArray.h>     // for TObjArray
#include <TRandom.h>       // for TRandom, gRandom
#include <TString.h>       // for TString, operator==, operator<<
 
//_____________________________________________________________________________
CbmMvdDetector* CbmMvdDetector::fInstance = 0;
 
CbmMvdSensorTyp CbmMvdDetector::fSensorTyp = CbmMvdSensorTyp::MIMOSIS;
 
//_____________________________________________________________________________
CbmMvdDetector* CbmMvdDetector::Instance()
{
  if (fInstance)
    return fInstance;
  else {
    fInstance                    = new CbmMvdDetector("A");
    CbmMvdGeoHandler* mvdHandler = new CbmMvdGeoHandler();
    mvdHandler->SetSensorTyp(fSensorTyp);
    LOG(info) << "SensorType";
    mvdHandler->Init();
    LOG(info) << "Init";
    mvdHandler->Fill();
    LOG(info) << "Filled";
    mvdHandler->PrintGeoParameter();
    return fInstance;
  }
}
 
// -----   Default constructor   -------------------------------------------
CbmMvdDetector::CbmMvdDetector()
  : TNamed()
  , fSensorArray(nullptr)
  , fSensorMap()
  , fPluginCount(0)
  , foutput(nullptr)
  , foutputHits(nullptr)
  , foutputDigis(nullptr)
  , foutputCluster(nullptr)
  ,  //khun
  foutputDigiMatchs(nullptr)
  , foutputHitMatchs(nullptr)
  , fcurrentEvent(nullptr)
  , fepsilon()
  , fDigiPlugin(-1)
  , fHitPlugin(-1)
  , fClusterPlugin(-1)
  , fSensorArrayFilled(kFALSE)
  , initialized(kFALSE)
  , fFinished(kFALSE)
  , fName("")
  , fParameter(nullptr)
{
 
  Fatal(GetName(), " - Do not use standard constructor");
}
// -------------------------------------------------------------------------
 
 
// -----   Standard constructor   ------------------------------------------
CbmMvdDetector::CbmMvdDetector(const char* name)
  : TNamed()
  , fSensorArray(new TClonesArray("CbmMvdSensor", 10))
  , fSensorMap()
  , fPluginCount(0)
  , foutput(nullptr)
  , foutputHits(nullptr)
  , foutputDigis(nullptr)
  , foutputCluster(nullptr)
  ,  //khun
  foutputDigiMatchs(nullptr)
  , foutputHitMatchs(nullptr)
  , fcurrentEvent(nullptr)
  , fepsilon()
  , fDigiPlugin(-1)
  , fHitPlugin(-1)
  , fClusterPlugin(-1)
  , fSensorArrayFilled(kFALSE)
  , initialized(kFALSE)
  , fFinished(kFALSE)
  , fName(name)
  , fParameter(nullptr)
{
 
  if (fInstance) {
    Fatal(GetName(), " - Error, singleton does already exist.");
  }
  else {
    fInstance = this;
  };
  fepsilon[0] = fepsilon[1] = fepsilon[2] = 0;
  fName                                   = name;
}
// -------------------------------------------------------------------------
 
 
// -----   Destructor   ----------------------------------------------------
CbmMvdDetector::~CbmMvdDetector() {}
//-----------------------------------------------------------------------
 
// -------Setters -----------------------------------------------------
 
void CbmMvdDetector::AddSensor(TString clearName, TString fullName, TString nodeName, CbmMvdSensorDataSheet* sensorData,
                               Int_t sensorNr, Int_t volumeId, Double_t sensorStartTime, Int_t stationNr)
{
 
  TString myname;
 
  if (fSensorArrayFilled) {
    Fatal(GetName(), " - Error, must add all sensors before adding plugins.");
  }
 
 
  Int_t nSensors = fSensorArray->GetEntriesFast();
 
  myname = clearName;
  myname += nSensors;
 
  new ((*fSensorArray)[nSensors])
    CbmMvdSensor(myname, sensorData, fullName, nodeName, sensorNr, volumeId, sensorStartTime);
  //CbmMvdSensor(const char* name, CbmMvdSensorDataSheet* dataSheet, TString volName,
  //TString nodeName, Int_t stationNr, Int_t volumeId, Double_t sensorStartTime);
 
  CbmMvdSensor* sensor = (CbmMvdSensor*) fSensorArray->At(nSensors);
  sensor->SetDataSheet(sensorData);
  sensor->SetStation(stationNr);
 
  // FIXME: replace the sensorNr with a proper hardware address here (at the moment using the "07/2025" legacy
  //        address definition, which stores the global sensorNr to bits 4-12).
  uint32_t address = CbmMvdAddress::GetAddressFromSensorNrAndPixelXY(sensorNr, 0, 0);
  sensor->SetAddress(address);
 
  // Add sensor to SensorMap
  fSensorMap[address] = sensor;
 
  // FIXME: Should misalignment be applied here?
  Float_t misalignment[3], randArray[3];
  //    TRandom3* rand = new TRandom3(0);
  gRandom->RndmArray(3, randArray);
  misalignment[0] = ((2 * randArray[0]) - 1) * fepsilon[0];
  misalignment[1] = ((2 * randArray[0]) - 1) * fepsilon[1];
  misalignment[2] = ((2 * randArray[0]) - 1) * fepsilon[2];
  sensor->SetMisalignment(misalignment);
  LOG(debug1) << "new sensor " << myname << " to detector added at station: " << stationNr;
}
 
// ----------------------------------------------------------------------
 
Int_t CbmMvdDetector::DetectPlugin(Int_t pluginID)
{
  // Detects the position of a plugin with a given Plugin-ID (set in the plugin implementation constructor) in the plugin-array of the sensors
 
 
  if (!fSensorArrayFilled) {
    LOG(warning)
      << "CbmMvdDetector::DetectPlugin: You tried to access sensor plugins while the detector is not initialized yet.";
    return -1;
  }
  CbmMvdSensor* sensor   = GetSensor(0);
  TObjArray* pluginArray = sensor->GetPluginArray();
 
  Int_t nPlugin = pluginArray->GetEntries();
  for (Int_t i = 0; i < nPlugin; i++) {
    CbmMvdSensorPlugin* plugin = (CbmMvdSensorPlugin*) pluginArray->At(i);
    // LOG(info) <<"CbmMvdDetector::DetectPlugin: PlugInID = " << plugin->GetPluginIDNumber() << " Position: "<< i;
    if (pluginID == plugin->GetPluginIDNumber()) {
      return i;
    }
  }
 
 
  return -1;
}
 
//-----------------------------------------------------------------------
void CbmMvdDetector::Init()
{

 
 
  if (!initialized) {
    foutput           = new TClonesArray("CbmMvdPoint", 1000);
    fcurrentEvent     = new TClonesArray("CbmMvdPoint", 1000);
    foutputDigis      = new TClonesArray("CbmMvdDigi", 1000);
    foutputDigiMatchs = new TClonesArray("CbmMatch", 1000);
    foutputHits       = new TClonesArray("CbmMvdHit", 1000);
    foutputCluster    = new TClonesArray("CbmMvdCluster", 1000);  //khun
  }
 
  Int_t nSensors = fSensorArray->GetEntriesFast();
  if (nSensors <= 0) LOG(fatal) << "CbmMvdDetector could not load Sensors from Geometry!";
  CbmMvdSensor* sensor;
 
  for (Int_t j = 0; j < nSensors; j++) {
 
    sensor = (CbmMvdSensor*) fSensorArray->At(j);
    LOG(debug1) << "Init Sensor " << sensor->GetName();
    sensor->Init();
  }
 
  initialized = kTRUE;
}
//-----------------------------------------------------------------------
 
//-----------------------------------------------------------------------
void CbmMvdDetector::ShowDebugHistos()
{
 
  Int_t nSensors = fSensorArray->GetEntriesFast();
  CbmMvdSensor* sensor;
 
  for (Int_t j = 0; j < nSensors; j++) {
    sensor = (CbmMvdSensor*) fSensorArray->At(j);
    sensor->ShowDebugHistos();
  }
}
//-----------------------------------------------------------------------
 
//-----------------------------------------------------------------------
void CbmMvdDetector::SendInputToSensorPlugin(uint32_t detectorId, Int_t nPlugin, TObject* input)
{
  fSensorMap.at(detectorId)->SendInputToPlugin(nPlugin, input);
}
//-----------------------------------------------------------------------
 
//-----------------------------------------------------------------------
void CbmMvdDetector::ExecChain()
{
 
  foutput->Clear();
  fcurrentEvent->Clear();
  foutputDigis->Clear();
  foutputDigiMatchs->Clear();
  foutputHits->Clear();
  foutputCluster->Clear();  //khun
 
  Int_t nSensors = fSensorArray->GetEntriesFast();
  CbmMvdSensor* sensor;
  for (Int_t i = 0; i < nSensors; i++) {
    sensor = (CbmMvdSensor*) fSensorArray->At(i);
    //LOG(info) << "Send Chain to " << sensor->GetName() << endl;
    sensor->ExecChain();
    //LOG(info) << "finished Chain at "<< sensor->GetName() <<endl<< endl;
  };
}
 
//-----------------------------------------------------------------------
 
 
//-----------------------------------------------------------------------
void CbmMvdDetector::Exec(UInt_t nLevel)
{
 
  foutput->Clear();
  fcurrentEvent->Clear();
  foutputDigis->Clear();
  foutputDigiMatchs->Clear();
  foutputHits->Clear();
  foutputCluster->Clear();  //khun
  Int_t nSensors = fSensorArray->GetEntriesFast();
  CbmMvdSensor* sensor;
  for (Int_t i = 0; i < nSensors; i++) {
    sensor = (CbmMvdSensor*) fSensorArray->At(i);
    sensor->Exec(nLevel);
  }
}
 
//-----------------------------------------------------------------------
 
//-----------------------------------------------------------------------
 
void CbmMvdDetector::ExecFrom(UInt_t nLevel)
{

  foutput->Clear();
  fcurrentEvent->Clear();
  foutputDigis->Clear();
  foutputDigiMatchs->Clear();
  foutputHits->Clear();
  foutputCluster->Clear();  //khun
 
  Int_t nSensors = fSensorArray->GetEntriesFast();
  CbmMvdSensor* sensor;
  for (Int_t i = 0; i < nSensors; i++) {
    sensor = (CbmMvdSensor*) fSensorArray->At(i);
    sensor->ExecFrom(nLevel);
  }
}
//-----------------------------------------------------------------------
 
void CbmMvdDetector::GetOutputArray(Int_t nPlugin, TClonesArray* outputArray)
{
  Int_t nSensors = fSensorArray->GetEntriesFast();
  CbmMvdSensor* sensor;
  TClonesArray* tmpArray;
 
 
  for (Int_t i = 0; i < nSensors; i++) {
    sensor       = (CbmMvdSensor*) fSensorArray->At(i);
    tmpArray     = sensor->GetOutputArray(nPlugin);
    Int_t length = tmpArray->GetEntriesFast();
    //LOG(info)<< "CbmMvdDetector::GetOutputArray - Length = " << length;
    if (length >= 0) {
      outputArray->AbsorbObjects(tmpArray);
    }
  }
}
 
//-----------------------------------------------------------------------
void CbmMvdDetector::GetMatchArray(Int_t nPlugin, TClonesArray* matchArray)
{
  Int_t nSensors = fSensorArray->GetEntriesFast();
  CbmMvdSensor* sensor;
  TClonesArray* tmpArray;
 
 
  for (Int_t i = 0; i < nSensors; i++) {
    sensor       = (CbmMvdSensor*) fSensorArray->At(i);
    tmpArray     = sensor->GetMatchArray(nPlugin);
    Int_t length = tmpArray->GetEntriesFast();
 
    if (length >= 0) {
      matchArray->AbsorbObjects(tmpArray);
    }
  }
}
 
//-----------------------------------------------------------------------
 
UInt_t CbmMvdDetector::GetMaxHistoNumber(UInt_t nPlugin)
{
 
  if (!fSensorArray) return -1;
 
  CbmMvdSensor* sensor = (CbmMvdSensor*) fSensorArray->At(0);
 
  if (sensor->GetPluginArraySize() < nPlugin) return -1;
 
  //CbmMvdSensorPlugin* plugin= (CbmMvdSensorPlugin*)sensor->GetPluginArray()->At(nPlugin);
 
  return sensor->GetNumberOfHistograms(nPlugin);
};
 
 
//-----------------------------------------------------------------------
TH1* CbmMvdDetector::GetHistogram(UInt_t nPlugin, UInt_t nHistogram)
{
  if (!fSensorArray) return 0;
 
  CbmMvdSensor* sensor = (CbmMvdSensor*) fSensorArray->At(0);
 
  if (sensor->GetPluginArraySize() < nPlugin) return 0;
  if (nHistogram >= sensor->GetNumberOfHistograms(nPlugin)) return 0;
 
  TH1* mySummedHistogram = (TH1*) ((sensor->GetHistogram(nPlugin, nHistogram))->Clone());
 
  for (Int_t i = 1; i < fSensorArray->GetEntriesFast(); i++) {  // Read histograms from all sensors and add them up.
    sensor = (CbmMvdSensor*) fSensorArray->At(i);
    mySummedHistogram->Add((TH1*) sensor->GetHistogram(nPlugin, nHistogram));
  }
 
  return mySummedHistogram;
}
 
//-----------------------------------------------------------------------
TH1* CbmMvdDetector::GetHistogram(UInt_t /*nLevel*/, UInt_t /*nHistogramNumber*/, UInt_t /*sensorInSensorArrayNumber*/)
{
  return 0;
}
 
//-----------------------------------------------------------------------
void CbmMvdDetector::Finish()
{
  if (!fFinished) {
    Int_t nSensors = fSensorArray->GetEntriesFast();
    CbmMvdSensor* sensor;
    for (Int_t i = 0; i < nSensors; i++) {
      sensor = (CbmMvdSensor*) fSensorArray->At(i);
      sensor->Finish();
    }
    fFinished = kTRUE;
  }
}
//-----------------------------------------------------------------------
 
ClassImp(CbmMvdDetector)