BesRawDataWriter.cc

Go to the documentation of this file.

//---------------------------------------------------------------------------//
////      BOOST --- BESIII Object_Oriented Simulation Tool                     //
////---------------------------------------------------------------------------//
////Description:
////Author:   Dengzy
////Created:  Mar, 2004
////Modified:
////Comment:
//
#include "BesRawDataWriter.hh"
#include "EmcSim/BesEmcDigi.hh"
#include "G4DigiManager.hh"
// #include "G4Svc/G4Svc.h"
#include "G4Svc/IG4Svc.h"
#include "MdcSim/BesMdcDigi.hh"
#include "MucSim/BesMucDigi.hh"
#include "TofSim/BesTofDigi.hh"
 
#include "GaudiKernel/Bootstrap.h"
#include "GaudiKernel/IDataProviderSvc.h"
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/RegistryEntry.h"
 
#include "EmcRawEvent/EmcDigi.h"
#include "MdcRawEvent/MdcDigi.h"
#include "MucRawEvent/MucDigi.h"
#include "TofRawEvent/TofDigi.h"
 
#include "Identifier/EmcID.h"
#include "Identifier/Identifier.h"
#include "Identifier/MdcID.h"
#include "Identifier/MucID.h"
#include "Identifier/TofID.h"
 
#include "GaudiKernel/SmartDataPtr.h"
#include "RawEvent/DigiEvent.h"
#include "RawEvent/RawDataUtil.h"
 
BesRawDataWriter::BesRawDataWriter() {
  m_DigiMan = G4DigiManager::GetDMpointer();
  // yuany 2005-2-28
  mdcGeoPointer = BesMdcGeoParameter::GetGeo();
 
  StatusCode sc = Gaudi::svcLocator()->service( "G4Svc", m_G4Svc );
  if ( !sc.isSuccess() )
  {
    std::cout << "Could not access G4Svc!" << std::endl;
    exit( 1 );
  }
 
  sc = Gaudi::svcLocator()->service( "RealizationSvc", m_RealizationSvc );
  if ( !sc.isSuccess() )
  {
    std::cout << "Could not access RealizationSvc!" << std::endl;
    exit( 1 );
  }
}
 
BesRawDataWriter::~BesRawDataWriter() {}
 
void BesRawDataWriter::SaveDigits() {
  // interface to event data service
  ISvcLocator* svcLocator = Gaudi::svcLocator();
  StatusCode   sc         = svcLocator->service( "EventDataSvc", m_evtSvc );
  if ( sc.isFailure() ) G4cout << "Could not accesss EventDataSvc!" << G4endl;
 
  DigiEvent* aDigiEvent = new DigiEvent;
  sc                    = m_evtSvc->registerObject( "/Event/Digi", aDigiEvent );
  if ( sc != StatusCode::SUCCESS ) { G4cout << "Could not register DigiEvent" << G4endl; }
 
  SaveMdcDigits();
  SaveTofDigits();
  SaveEmcDigits();
  SaveMucDigits();
}
 
void BesRawDataWriter::SaveMdcDigits() {
  // mdc digis collection defined in BOSS
  MdcDigiCol* aMdcDigiCol = new MdcDigiCol;
 
  G4int mdcDigiCollID = -1;
  mdcDigiCollID       = m_DigiMan->GetDigiCollectionID( "BesMdcDigisCollection" );
  if ( mdcDigiCollID >= 0 )
  {
    BesMdcDigisCollection* mdcDC =
        (BesMdcDigisCollection*)m_DigiMan->GetDigiCollection( mdcDigiCollID );
    G4int nDigi = mdcDC->entries();
    if ( nDigi > 0 )
    {
      // push back mdc digits to MdcDigiCol in BOSS
      BesMdcDigi* mdcDigi;
      for ( int i = 0; i < nDigi; i++ )
      {
        mdcDigi = ( *mdcDC )[i];
        unsigned int charge;
        if ( m_G4Svc->GetMdcDedxFlag() == 1 ) { charge = int( mdcDigi->GetEdep() ); }
        else { charge = RawDataUtil::MdcChargeChannel( mdcDigi->GetEdep() ); }
        unsigned int     time  = RawDataUtil::MdcTimeChannel( mdcDigi->GetDriftT() );
        const Identifier ident = MdcID::wire_id( mdcDigi->GetLayerNo(), mdcDigi->GetCellNo() );
 
        MdcDigi* aMdcDigi = new MdcDigi( ident, time, charge );
        aMdcDigi->setTrackIndex( mdcDigi->GetTrackID() );
        aMdcDigiCol->push_back( aMdcDigi );
      }
    }
  }
 
  // register MDC digits collection to TDS
  StatusCode scMdc = m_evtSvc->registerObject( "/Event/Digi/MdcDigiCol", aMdcDigiCol );
  if ( scMdc != StatusCode::SUCCESS )
    G4cout << "Could not register MDC digi collection" << G4endl;
 
  // retrieve MDC digits from TDS
  /*SmartDataPtr<MdcDigiCol> aDigiCol(m_evtSvc,"/Event/Digi/MdcDigiCol");
    if(!aDigiCol)
    G4cout<<"Could not retrieve MDC digi collection"<<G4endl;
 
    MdcDigiCol::iterator iDigiCol;
    for(iDigiCol=aDigiCol->begin(); iDigiCol!=aDigiCol->end(); iDigiCol++)
    {
    const Identifier ident = (*iDigiCol)->identify();
    G4cout<<"layer: "<<MdcID::layer(ident);
    G4cout<<"  cell: "<<MdcID::wire(ident);
    G4cout<<"  charge: "<<(*iDigiCol)->getChargeChannel();
    G4cout<<"  time: "<<(*iDigiCol)->getTimeChannel()<<G4endl;
    }
    G4cout<<"end of retrieve MDC digi collection"<<G4endl;
   */
}
 
void BesRawDataWriter::SaveTofDigits() {
 
  // Tof digits collection defined in BOSS
  TofDigiCol* aTofDigiCol = new TofDigiCol;
 
  G4int tofDigiCollID = -1;
  tofDigiCollID       = m_DigiMan->GetDigiCollectionID( "BesTofDigitsCollection" );
 
  if ( tofDigiCollID >= 0 )
  {
    BesTofDigitsCollection* tofDC =
        (BesTofDigitsCollection*)m_DigiMan->GetDigiCollection( tofDigiCollID );
    G4int nDigi = tofDC->entries();
    if ( nDigi > 0 )
    {
      // arrange digis in digitsCollection in order of trackIndex
      BesTofDigi*          digi;
      vector<BesTofDigi*>* vecDC = tofDC->GetVector();
      for ( int i = 0; i < nDigi - 1; i++ )
      {
        for ( int j = i + 1; j < nDigi; j++ )
        {
          if ( ( *vecDC )[i]->GetTrackIndex() > ( *vecDC )[j]->GetTrackIndex() )
          {
            digi          = ( *vecDC )[i];
            ( *vecDC )[i] = ( *vecDC )[j];
            ( *vecDC )[j] = digi;
          }
        }
      }
 
      // push back tof digits to TofDigiCol in BOSS
      for ( int i = 0; i < nDigi; i++ )
      {
        digi = ( *tofDC )[i];
 
        // for Scintillator, scinNum is the number of scintillator
        // for MRPC, scinNum is the number of module
        G4int scinNum = digi->GetScinNb();
        // for Scintillator, barrel_ec is 0 for east endcap, 1 for barrel, and 2 for west
        // endcap for MRPC, barrel_ec is 100 + module number for east, 200 + module number for
        // west
        G4int barrel_ec = digi->GetPartId();
 
        if ( TofID::is_scin( barrel_ec ) )
        { // for Scintillator
          unsigned int layer = 0;
          if ( TofID::is_barrel( barrel_ec ) && scinNum > TofID::getPHI_BARREL_MAX() )
          {
            layer   = 1;
            scinNum = scinNum - TofID::getPHI_BARREL_MAX() - 1;
          }
 
          // Store tofDigi for end==0
          Identifier   ident = TofID::cell_id( barrel_ec, layer, scinNum, 0 );
          unsigned int time;
          if ( digi->GetForwTDC() > 0 )
          { time = RawDataUtil::TofTimeChannel( digi->GetForwTDC() ); }
          else { time = 0; }
 
          unsigned int charge;
          if ( digi->GetForwADC() > 0 )
          {
            // ADC linear conversion
            charge = digi->GetForwADC(); // convert ADC(pC) of bTof into Q channel in Data
            // Treat ADC overflow
            if ( charge >= 8192 )
            {
              // The overlow flag is the 20th bit of the ADC_channel.
              charge = ( charge | 0x080000 ); // if ADC_channel>=8192, set overflow flag = 1.
            }
            charge =
                ( ( time & 0x07e000 ) | charge ); // Store tclock into ADC_channel as qclock
          }
          else { charge = 0; }
 
          TofDigi* tofDigi = new TofDigi( ident, time, charge );
          if ( charge & 0x80000 )
          { // Treat overflow flag(20th bit)
            tofDigi->setOverflow( 0x2 );
          }
          tofDigi->setTrackIndex( digi->GetTrackIndex() );
          aTofDigiCol->push_back( tofDigi );
 
          // Store tofDigi for end==1
          ident = TofID::cell_id( barrel_ec, layer, scinNum, 1 );
          if ( digi->GetBackTDC() > 0 )
          { time = RawDataUtil::TofTimeChannel( digi->GetBackTDC() ); }
          else { time = 0; }
 
          if ( digi->GetBackADC() > 0 )
          {
            // ADC linear conversion
            charge = digi->GetBackADC();
            // Treat ADC overflow
            if ( charge >= 8192 )
            {
              // The overlow flag is the 20th bit of the ADC_channel.
              charge = ( charge | 0x080000 ); // if ADC_channel>=8192, set overflow flag = 1.
            }
            charge =
                ( ( time & 0x07e000 ) | charge ); // Store tclock into ADC_channel as qclock
          }
          else { charge = 0; }
 
          tofDigi = new TofDigi( ident, time, charge );
          if ( charge & 0x80000 )
          { // Treat overflow flag(20th bit)
            tofDigi->setOverflow( 0x2 );
          }
          tofDigi->setTrackIndex( digi->GetTrackIndex() );
          aTofDigiCol->push_back( tofDigi );
        } // end if is_scin
        else
        { // for ETF(MRPC)
          if ( barrel_ec == 3 || barrel_ec == 4 )
          {
            unsigned int endcap = 0;
            unsigned int module = digi->GetModule();
            unsigned int strip  = digi->GetStrip();
            if ( barrel_ec == 4 )
            { // west end cap
              endcap = 1;
            }
 
            // Store tofDigi for end==0
            Identifier   ident = TofID::cell_id( 3, endcap, module, strip, 0 );
            unsigned int tleading;
            if ( digi->GetForwT1() > 0 )
            { tleading = RawDataUtil::TofTimeChannel( digi->GetForwT1() ); }
            else { tleading = 0; }
            unsigned int ttrailing;
            if ( digi->GetForwT2() > 0 )
            { ttrailing = RawDataUtil::TofTimeChannel( digi->GetForwT2() ); }
            else { ttrailing = 0; }
            TofDigi* tofDigi = new TofDigi( ident, tleading, ttrailing );
            tofDigi->setTrackIndex( digi->GetTrackIndex() );
            aTofDigiCol->push_back( tofDigi );
            /*
            G4cout << "  --------- BesRawDataWriter: TOF ------------------  " << G4endl;
            G4cout << " endcap=" << endcap << " module=" << module << " strip=" << strip <<
            G4endl; G4cout << " tleading=" << tleading << " ttrailing=" << ttrailing << G4endl;
            G4cout << "  --------- BesRawDataWriter: TOF ------------------  " << G4endl;
            */
            // Store tofDigi for end==1
            ident = TofID::cell_id( 3, endcap, module, strip, 1 );
            if ( digi->GetBackT1() > 0 )
            { tleading = RawDataUtil::TofTimeChannel( digi->GetBackT1() ); }
            else { tleading = 0; }
            if ( digi->GetBackT2() > 0 )
            { ttrailing = RawDataUtil::TofTimeChannel( digi->GetBackT2() ); }
            else { ttrailing = 0; }
            tofDigi = new TofDigi( ident, tleading, ttrailing );
            tofDigi->setTrackIndex( digi->GetTrackIndex() );
            aTofDigiCol->push_back( tofDigi );
          }
        } // end if is_MRPC
      }
    }
  }
 
  // register TOF digits collection to TDS
  StatusCode scTof = m_evtSvc->registerObject( "/Event/Digi/TofDigiCol", aTofDigiCol );
  if ( scTof != StatusCode::SUCCESS )
  { G4cout << "Could not register TOF digi collection" << G4endl; }
  return;
}
 
void BesRawDataWriter::SaveEmcDigits() {
  // Emc digits collection defined in BOSS
  EmcDigiCol* aEmcDigiCol = new EmcDigiCol;
 
  G4int emcDigiCollID = -1;
  emcDigiCollID       = m_DigiMan->GetDigiCollectionID( "BesEmcDigitsCollection" );
  if ( emcDigiCollID >= 0 )
  {
    BesEmcDigitsCollection* emcDC =
        (BesEmcDigitsCollection*)m_DigiMan->GetDigiCollection( emcDigiCollID );
    G4int nDigi = emcDC->entries();
    if ( nDigi > 0 )
    {
      // arrange digis in digitsCollection in order of trackIndex
      BesEmcDigi*          digi;
      vector<BesEmcDigi*>* vecDC = emcDC->GetVector();
      for ( int i = 0; i < nDigi - 1; i++ )
        for ( int j = i + 1; j < nDigi; j++ )
          if ( ( *vecDC )[i]->GetTrackIndex() > ( *vecDC )[j]->GetTrackIndex() )
          {
            digi          = ( *vecDC )[i];
            ( *vecDC )[i] = ( *vecDC )[j];
            ( *vecDC )[j] = digi;
          }
      // push back EmcDigi to EmcDigiCol in BOSS
      for ( int i = 0; i < nDigi; i++ )
      {
        digi = ( *emcDC )[i];
 
        int        charge  = RawDataUtil::EmcChargeChannel( digi->GetEnergy() );
        int        measure = RawDataUtil::EmcChargeMeasure( digi->GetEnergy() );
        int        time    = RawDataUtil::EmcTimeChannel( digi->GetTime() );
        Identifier ident =
            EmcID::crystal_id( digi->GetPartId(), digi->GetThetaNb(), digi->GetPhiNb() );
        EmcDigi* emcDigi = new EmcDigi( ident, time, charge );
        emcDigi->setTrackIndex( digi->GetTrackIndex() );
        emcDigi->setMeasure( measure );
        aEmcDigiCol->push_back( emcDigi );
      }
    }
  }
 
  // register EMC digits collection to TDS
  StatusCode scEmc = m_evtSvc->registerObject( "/Event/Digi/EmcDigiCol", aEmcDigiCol );
  if ( scEmc != StatusCode::SUCCESS )
    G4cout << "Could not register EMC digi collection" << G4endl;
 
  // retrieve EMC digits from TDS
  /*SmartDataPtr<EmcDigiCol> aDigiCol(m_evtSvc,"/Event/Digi/EmcDigiCol");
    if(!aDigiCol)
    G4cout<<"Could not retrieve EMC digi collection"<<G4endl;
 
    EmcDigiCol::iterator iDigiCol;
    for(iDigiCol=aDigiCol->begin(); iDigiCol!=aDigiCol->end(); iDigiCol++)
    {
    const Identifier ident = (*iDigiCol)->identify();
    G4cout<<"barrel_ec: "<<EmcID::barrel_ec(ident);
    G4cout<<"  theta: "<<EmcID::theta_module(ident);
    G4cout<<"  phi: "<<EmcID::phi_module(ident);
    G4cout<<"  charge: "<<(*iDigiCol)->getChargeChannel();
    G4cout<<"  time: "<<(*iDigiCol)->getTimeChannel()<<G4endl;
    }
    G4cout<<"end of retrieve EMC digits"<<G4endl;
   */
}
 
void BesRawDataWriter::SaveMucDigits() {
  // Muc digits collection defined in BOSS
  MucDigiCol* aMucDigiCol = new MucDigiCol;
 
  G4int mucDigiCollID = -1;
  mucDigiCollID       = m_DigiMan->GetDigiCollectionID( "BesMucDigisCollection" );
  if ( mucDigiCollID >= 0 )
  {
    BesMucDigisCollection* mucDC =
        (BesMucDigisCollection*)m_DigiMan->GetDigiCollection( mucDigiCollID );
    G4int nDigi = mucDC->entries();
 
    if ( nDigi > 0 )
    {
      BesMucDigi* digi;
      for ( int i = 0; i < nDigi; i++ )
      {
        digi               = ( *mucDC )[i];
        Identifier ident   = MucID::channel_id( digi->GetPartId(), digi->GetSegId(),
                                                digi->GetGapId(), digi->GetStripId() );
        MucDigi*   mucDigi = new MucDigi( ident );
        mucDigi->setTrackIndex( digi->GetTrackIndex() );
        aMucDigiCol->push_back( mucDigi );
      }
    }
  }
 
  // register MUC digits collection to TDS
  StatusCode scMuc = m_evtSvc->registerObject( "/Event/Digi/MucDigiCol", aMucDigiCol );
  if ( scMuc != StatusCode::SUCCESS )
    G4cout << "Could not register MUC digi collection" << G4endl;
 
  // retrieve MUC digits from TDS
  /*SmartDataPtr<MucDigiCol> aDigiCol(m_evtSvc,"/Event/Digi/MucDigiCol");
    if(!aDigiCol)
    G4cout<<"Could not retrieve MUC digi collection"<<G4endl;
 
    MucDigiCol::iterator iDigiCol;
    for(iDigiCol=aDigiCol->begin(); iDigiCol!=aDigiCol->end(); iDigiCol++)
    {
    const Identifier ident = (*iDigiCol)->identify();
    G4cout<<"Part: "<<MucID::part(ident);
    G4cout<<"  Seg: "<<MucID::seg(ident);
    G4cout<<"  Gap: "<<MucID::gap(ident);
    G4cout<<"  Strip: "<<MucID::strip(ident)<<G4endl;
    }
    G4cout<<"end of retrieve MUC digits"<<G4endl;
   */
}