BesTofDigitizer.cc

Go to the documentation of this file.

//---------------------------------------------------------------------------//
//      BOOST --- BESIII Object_Oriented Simulation Tool                     //
//---------------------------------------------------------------------------//
// Description: Chief control center for digitizing modes.Also define 'group hits'.
// Author: Dengzy
// Created: Mar, 2004
// Modified: Sun Shengsen based on Matthias Ullrich for MRPC Endcap TOF 2014.04.28.
// Comment: Double Side Readout Version
//---------------------------------------------------------------------------//
//$Id: BesTofDigitizer.cc
 
#include "TofSim/BesTofDigitizer.hh"
#include "G4DigiManager.hh"
#include "G4Svc/IG4Svc.h"
#include "GaudiKernel/Bootstrap.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/MsgStream.h"
#include "Randomize.hh"
#include "SimUtil/ReadBoostRoot.hh"
#include "TofSim/ScintSingle.hh"
 
BesTofDigitizer::BesTofDigitizer( G4String modName ) : G4VDigitizerModule( modName ) {
 
  collectionName.push_back( "BesTofDigitsCollection" );
  m_besTofDigitsCollection = 0;
  // m_digiMessenger = new BesTofDigitizerMessenger(this);
 
  tofDMBr1 = new BesTofDigitizerBrV1();
  tofDMEc1 = new BesTofDigitizerEcV1();
  tofDMBr2 = new BesTofDigitizerBrV2();
  tofDMEc2 = new BesTofDigitizerEcV2();
  tofDMEc3 = new BesTofDigitizerEcV3(); // Scintillator
  tofDMEc4 = new BesTofDigitizerEcV4(); // MRPC Double End
 
  // retrieve RealizationSvc
  StatusCode scReal = Gaudi::svcLocator()->service( "RealizationSvc", m_RealizationSvc );
  if ( !scReal.isSuccess() )
  {
    std::cout << " Could not initialize Realization Service in BesTofDigitizerBrV2"
              << std::endl;
    exit( 1 );
  }
 
  m_versionBr = 2;
 
  if ( ReadBoostRoot::GetTof() == 3 || ReadBoostRoot::GetTof() == 4 )
  {
    m_versionEc = 4;
    std::cout
        << std::endl
        << "TofSim: BesTofDigitizer       You are using the new End Cap Tof (MRPC) Digitizer!"
        << std::endl;
  }
  else
  {
    m_versionEc = 3;
    std::cout << std::endl
              << "TofSim: BesTofDigitizer       You are using the old End Cap Tof "
                 "(Scintillator) Digitizer!"
              << std::endl;
  }
}
 
BesTofDigitizer::~BesTofDigitizer() {
  // delete m_digiMessenger;
  delete tofDMBr1;
  delete tofDMEc1;
  delete tofDMBr2;
  delete tofDMEc2;
  delete tofDMEc3;
  delete tofDMEc4;
}
 
void BesTofDigitizer::Digitize() {
 
  m_besTofDigitsCollection   = new BesTofDigitsCollection( moduleName, collectionName[0] );
  G4DigiManager* digiManager = G4DigiManager::GetDMpointer();
  G4int          THCID       = digiManager->GetHitsCollectionID( "BesTofHitsCollection" );
  m_THC = (BesTofHitsCollection*)( digiManager->GetHitsCollection( THCID ) );
 
  if ( m_THC )
  {
    m_scintGroup = new vector<ScintSingle*>; // ScintSingle contains: partId, scintnb, edep
                                             // <--only the basics
    GroupHits(); // If one finds more hits in one scintillator, they are grouped together
    G4int size = m_scintGroup->size();
 
    //    std::cout << "TofSim: BesTofDigitizer     m_scintGroup->size():  " << size <<
    //    std::endl;
 
    ScintSingle* scint;
    G4int        partId;
    for ( G4int i = 0; i < size; i++ )
    {
      scint  = ( *m_scintGroup )[i];
      partId = scint->GetPartId();
 
      //      std::cout << "TofSim: BesTofDigitizer     scint->GetPartId():  " << partId <<
      //      std::endl;
 
      if ( partId == 1 )
      { // for barrel part
        if ( m_versionBr == 1 ) tofDMBr1->Digitize( scint, m_besTofDigitsCollection );
        else if ( m_versionBr == 2 )
        {
          // std::cout << "TofSim:  tofDMBr2->Digitize" << std::endl;
          tofDMBr2->Digitize( scint, m_besTofDigitsCollection );
        }
        else { tofDMBr2->Digitize( scint, m_besTofDigitsCollection ); }
      }
      else
      { // for endcap part
        if ( m_versionEc == 1 ) { tofDMEc1->Digitize( scint, m_besTofDigitsCollection ); }
        else if ( m_versionEc == 2 ) { tofDMEc2->Digitize( scint, m_besTofDigitsCollection ); }
        else if ( m_versionEc == 3 ) { tofDMEc3->Digitize( scint, m_besTofDigitsCollection ); }
        else if ( m_versionEc == 4 ) { tofDMEc4->Digitize( scint, m_besTofDigitsCollection ); }
        else
        {
          cout << "TofSim: Warning: BesTofDigitizerEcV2 is utilized otherwise!" << endl;
          tofDMEc2->Digitize( scint, m_besTofDigitsCollection );
        }
      } // Close endcap part
    }
 
    if ( m_scintGroup )
    {
      for ( size_t i = 0; i < m_scintGroup->size(); i++ )
      {
        delete ( *m_scintGroup )[i];
        // std::cout << "TofSim: i: " << i << std::endl;
        // std::cout << "TofSim: delete m_scintGroup[i] successfully " << std::endl;
      }
      m_scintGroup->clear();
      delete m_scintGroup;
    }
  } // close if(m_THC)
 
  StoreDigiCollection( m_besTofDigitsCollection );
}
 
void BesTofDigitizer::GroupHits() {
 
  G4int      partId, scinNb, size, flag, trackId;
  G4double   edep;
  BesTofHit* hit;
  G4int      nHits = m_THC->entries();
 
  // sunss 20140508 add to suppress the efficiency of TOF signal
  vector<G4int> deadTrackVec;
  deadTrackVec.clear();
  G4int runId = m_RealizationSvc->getRunId();
  if ( ( runId >= -11396 && runId <= -8093 ) || ( runId > -1000000 && runId <= -23463 ) )
  {
    G4int         previousTrack = -999;
    vector<G4int> trackVec;
    trackVec.clear();
    for ( G4int i = 0; i < nHits; i++ )
    {
      hit     = ( *m_THC )[i];
      trackId = hit->GetTrackIndex();
      if ( trackId != previousTrack )
      {
        previousTrack                = trackId;
        bool                    same = false;
        vector<G4int>::iterator iter = trackVec.begin();
        for ( ; iter != trackVec.end(); iter++ )
        {
          if ( ( *iter ) == trackId )
          {
            same = true;
            break;
          }
        }
        if ( !same )
        {
          trackVec.push_back( trackId );
          G4double ranSignal = G4UniformRand();
          if ( ranSignal > 0.988 )
          { // hhliu 20140613
            deadTrackVec.push_back( trackId );
          }
        }
      }
    }
  }
  // sunss 20140508
 
  // group the hits which are in the same scintillator
  for ( G4int i = 0; i < nHits; i++ )
  {
    hit = ( *m_THC )[i];
    // sunss 20140508
    if ( ( runId >= -11396 && runId <= -8093 ) || ( runId > -1000000 && runId <= -23463 ) )
    {
      trackId                       = hit->GetTrackIndex();
      partId                        = hit->GetPartId();
      bool                    aband = false;
      vector<G4int>::iterator iter  = deadTrackVec.begin();
      for ( ; iter != deadTrackVec.end(); iter++ )
      {
        if ( ( trackId == ( *iter ) ) && ( partId != 3 && partId != 4 ) ) { aband = true; }
      }
      if ( aband ) continue;
    }
    // sunss 20140508
    partId = hit->GetPartId();
    scinNb = hit->GetScinNb();
    edep   = hit->GetEdep();
    size   = m_scintGroup->size();
    flag   = 0;
    if ( size > 0 )
    {
      ScintSingle* oldScint;
      for ( G4int j = 0; j < size; j++ )
      {
        oldScint = ( *m_scintGroup )[j];
        if ( oldScint->GetPartId() == partId && oldScint->GetScinNb() == scinNb )
        {
          // std::cout << "BesTodDigitizer:       GroupHits: 'Oldhit:'  partID |  scinnb :  "
          // << partId   << "  |  "
          // << scinNb << std::endl;
          oldScint->GetHitIndexes()->push_back( i );
          // ATTENTION!!! sum over all deposited energy!
          oldScint->AddEdep( edep );
          flag = 1;
          break;
        }
      }
    }
 
    if ( flag == 0 )
    {
      ScintSingle* newScint = new ScintSingle;
      newScint->SetPartId( partId );
      newScint->SetScinNb( scinNb );
      newScint->SetEdep( edep );
      newScint->GetHitIndexes()->push_back( i );
      m_scintGroup->push_back( newScint );
 
      //      std::cout << "BesTofDigitizer:        GroupHits:  NewHitGroup:   " << partId  <<
      //      "   "  << scinNb << std::endl;
    }
  }
}