#include <BesMdcDigitizer.hh>

Inheritance diagram for BesMdcDigitizer:

Public Member Functions
	BesMdcDigitizer (G4String modName)
	~BesMdcDigitizer ()
virtual void	Digitize ()
void	SetNoiseFlag (G4int flag)
void	SetNoiseType (G4int type)
void	SetNoiseLevel (G4double level)
void	SetSmearFlag (G4int flag)
void	SetMdcDRes (G4double res)
void	SetEffFlag (G4int flag)
void	SetEff (G4int layer, G4double eff)
	BesMdcDigitizer (G4String modName)
	~BesMdcDigitizer ()
virtual void	Digitize ()
void	SetNoiseFlag (G4int flag)
void	SetNoiseType (G4int type)
void	SetNoiseLevel (G4double level)
void	SetSmearFlag (G4int flag)
void	SetMdcDRes (G4double res)
void	SetEffFlag (G4int flag)
void	SetEff (G4int layer, G4double eff)
	BesMdcDigitizer (G4String modName)
	~BesMdcDigitizer ()
virtual void	Digitize ()
void	SetNoiseFlag (G4int flag)
void	SetNoiseType (G4int type)
void	SetNoiseLevel (G4double level)
void	SetSmearFlag (G4int flag)
void	SetMdcDRes (G4double res)
void	SetEffFlag (G4int flag)
void	SetEff (G4int layer, G4double eff)

Detailed Description

Definition at line 30 of file InstallArea/x86_64-el9-gcc13-dbg/include/MdcSim/BesMdcDigitizer.hh.

Constructor & Destructor Documentation

◆ BesMdcDigitizer() [1/3]

BesMdcDigitizer::BesMdcDigitizer ( G4String modName )

Definition at line 29 of file BesMdcDigitizer.cc.

                                                   : G4VDigitizerModule( modName ) {
  noiseFlag  = 0;
  noiseType  = 3;
  noiseLevel = 0.1;  // 10%
  maxNoiseT  = 300.; // ns
  smearFlag  = 1;
  mdcDRes    = 0.13; // mm
  effFlag    = 0;
  for ( G4int i = 0; i < 43; i++ ) { layerEff.push_back( 1. ); }
  collectionName.push_back( "BesMdcDigisCollection" );
  digitizerMessenger = new BesMdcDigitizerMessenger( this );
  mdcGeoPointer      = BesMdcGeoParameter::GetGeo();
  mdcCalPointer      = new BesMdcCalTransfer;
 
  StatusCode sc = Gaudi::svcLocator()->service( "G4Svc", m_G4Svc );
  if ( !sc.isSuccess() ) G4cout << " MdcDigitizer::Error,could not open G4Svc" << G4endl;
 
  sc = Gaudi::svcLocator()->service( "MdcTunningSvc", mdcTunningSvc );
  if ( !sc.isSuccess() )
  { G4cout << " MdcDigitizer::Error,could not open Mdc Tunning Service" << G4endl; }
  else { G4cout << " MdcDigitizer:: Open Mdc Tunning Service" << G4endl; }
 
  std::string noiseFile = m_G4Svc->GetMdcNoiseFile();
  f                     = new TFile( noiseFile.c_str() );
  h1                    = (TH1F*)f->Get( "h703" );
  h2                    = (TH1F*)f->Get( "h501" );
  h3                    = (TH1F*)f->Get( "h801" );
  /*
  //get Mdc Ntuple from G4Svc
  if(m_G4Svc->MdcRootFlag())
  {
  m_tupleMdc = m_G4Svc->GetTupleMdc();
  sc = m_tupleMdc->addItem("NHits",m_NHits);
  sc = m_tupleMdc->addItem("LayerId",m_layerId);
  sc = m_tupleMdc->addItem("cellId",m_cellId);
  sc = m_tupleMdc->addItem("Edep",m_edep);
  sc = m_tupleMdc->addItem("driftD",m_driftD);
  // sc = m_tupleMdc->addItem("driftT",m_driftT);
  sc = m_tupleMdc->addItem("globalT",m_globalT);
  sc = m_tupleMdc->addItem("theta",m_theta);
  sc = m_tupleMdc->addItem("enterAngle",m_enterAngle);
  sc = m_tupleMdc->addItem("driftDNew",m_driftDNew);
  sc = m_tupleMdc->addItem("driftTNew",m_driftTNew);
  // sc = m_tupleMdc->addItem("adc",m_adc);
  // sc = m_tupleMdc->addItem("tdc",m_tdc);
  }
  */
}

◆ ~BesMdcDigitizer() [1/3]

BesMdcDigitizer::~BesMdcDigitizer ( )

Definition at line 78 of file BesMdcDigitizer.cc.

78{ delete digitizerMessenger; }

◆ BesMdcDigitizer() [2/3]

BesMdcDigitizer::BesMdcDigitizer ( G4String modName )

◆ ~BesMdcDigitizer() [2/3]

BesMdcDigitizer::~BesMdcDigitizer ( )

◆ BesMdcDigitizer() [3/3]

BesMdcDigitizer::BesMdcDigitizer ( G4String modName )

◆ ~BesMdcDigitizer() [3/3]

BesMdcDigitizer::~BesMdcDigitizer ( )

Member Function Documentation

◆ Digitize() [1/3]

void BesMdcDigitizer::Digitize ( )

virtual

Definition at line 88 of file BesMdcDigitizer.cc.

                               {
 
  // initialize
  for ( G4int i = 0; i < 43; i++ )
  {
    for ( G4int j = 0; j < 288; j++ ) { digiPointer[i][j] = -1; }
  }
 
  G4int    NHits, layerId, cellId, posFlag;
  G4double edep, driftD, driftT, globalT, theta, cosTheta, enterAngle;
  G4double mean, sigma, mean1, mean2, sigma1, sigma2, f, sig, delSig, fRandom, driftDNew,
      driftTNew;
  G4double tempEff;
  G4double resLargest, resSmallest, resRatio; // added by liukai
 
  G4DigiManager* DigiMan = G4DigiManager::GetDMpointer();
 
  // hits collection ID
  G4int THCID = -1;
  THCID       = DigiMan->GetHitsCollectionID( "BesMdcHitsCollection" );
 
  // hits collection
  BesMdcHitsCollection* THC = 0;
  THC                       = (BesMdcHitsCollection*)( DigiMan->GetHitsCollection( THCID ) );
 
  if ( THC )
  {
    digisCollection = new BesMdcDigisCollection( moduleName, collectionName[0] );
    NHits           = THC->entries();
    for ( G4int i = 0; i < NHits; i++ )
    {
      layerId    = ( *THC )[i]->GetLayerNo();
      cellId     = ( *THC )[i]->GetCellNo();
      edep       = ( *THC )[i]->GetEdep();
      driftD     = ( *THC )[i]->GetDriftD();
      globalT    = ( *THC )[i]->GetGlobalT();
      theta      = ( *THC )[i]->GetTheta();
      cosTheta   = cos( theta );
      enterAngle = ( *THC )[i]->GetEnterAngle();
      posFlag    = ( *THC )[i]->GetPosFlag();
 
      // Transfer hit pointer to BesMdcCalTransfer
      mdcCalPointer->SetHitPointer( ( *THC )[i] );
 
      // Filter with wire efficiency
      if ( effFlag == 0 )
      {
        // tempEff = mdcCalPointer->GetEff();
        tempEff = mdcTunningSvc->GetEff( layerId, cellId, driftD, cosTheta, posFlag );
      }
      else { tempEff = layerEff[layerId]; }
      fRandom = G4UniformRand();
      if ( fRandom > tempEff ) continue;
 
      // cout<<"layerid "<<layerId<<" cellid "<<cellId<<" theta "<<cosTheta<<" enterangle
      // "<<enterAngle<<endl; Drift distance smear
      if ( smearFlag == 0 )
      { // No smear
        driftDNew = driftD;
      }
      else if ( smearFlag == 1 )
      { // Smear from TuningSvc
        //  mdcTunningSvc->GetRes(layerId,cellId,driftD,cosTheta,posFlag,enterAngle,mean,sigma);
        // mdcTunningSvc->GetRes2(layerId,cellId,driftD,cosTheta,posFlag,enterAngle,f,mean1,sigma1,mean2,sigma2);
        mdcTunningSvc->GetRes3( layerId, cellId, driftD, cosTheta, posFlag, enterAngle, f,
                                mean1, sigma1, mean2, sigma2, resLargest, resSmallest,
                                resRatio );
 
        // driftDNew = Smear(driftD,f,mean1,sigma1,mean2,sigma2);
        // driftDNew = Smear(driftD-(f*mean1+(1-f)*mean2),f,mean1,sigma1,mean2,sigma2);//new
        // method
 
        driftDNew =
            Smear( driftD - ( f * mean1 + ( 1 - f ) * mean2 ), f, mean1, sigma1, mean2, sigma2,
                   resLargest, resSmallest, resRatio ); //----added by liukai 2012-6-4
      }
      else if ( smearFlag == 2 )
      { // Smear with fixed resolution
        driftDNew = Smear( driftD );
      }
      else
      {
        G4cerr << "MdcDigitizer::wrong smearFlag: " << smearFlag << G4endl;
        abort();
      }
 
      // Do X-T conversion
      driftTNew = mdcCalPointer->D2T( driftDNew );
 
      // Do Q-T correct
      driftTNew += mdcCalPointer->GetTimeWalk();
 
      // Add T0
      driftTNew += mdcCalPointer->GetT0();
 
      // Add TOF
      driftTNew += globalT;
 
      // Signal transfer time on wire
      //  transferT=Transfer(layerId,cellId,hitPosition);
      // driftTNew+=transferT;
 
      if ( std::isnan( driftTNew ) )
      {
        G4cout << "MdcDigitizer::error, driftT is nan" << G4endl;
        continue;
      }
 
      /*
         if(m_G4Svc->MdcRootFlag())
         {
         m_NHits= NHits;
         m_layerId= layerId;
         m_cellId= cellId;
         m_edep= edep;
         m_driftD= driftD;
      //     m_driftT= driftT;
      m_globalT = globalT;
      m_enterAngle = enterAngle;
      m_driftDNew = driftDNew;
      m_driftTNew = driftTNew;
      m_theta = theta;
      m_tupleMdc ->write();
      }
      */
      BesMdcDigi* newDigi = new BesMdcDigi();
      newDigi->SetTrackID( ( *THC )[i]->GetTrackID() );
      newDigi->SetLayerNo( layerId );
      newDigi->SetCellNo( cellId );
      newDigi->SetEdep( edep );
      newDigi->SetDriftT( driftTNew );
      G4int NbDigis                = digisCollection->insert( newDigi );
      digiPointer[layerId][cellId] = NbDigis - 1;
    }
 
    if ( noiseFlag == 1 ) AddNoise();
    if ( noiseFlag == 2 )
    {
      ifstream readNoiseLevel( "$MDCSIMROOT/share/noiselevel.txt" );
      if ( !readNoiseLevel.good() )
      { std::cout << " Error , noiselevel file not exist " << std::endl; }
      else { std::cout << " MdcDigitizer:: Open noiselevel file  " << std::endl; }
      G4int    NLayer = mdcGeoPointer->SignalLayerNo();
      G4double level;
      for ( G4int i = 0; i < NLayer; i++ )
      {
        readNoiseLevel >> level;
        mixLevel.push_back( level );
      }
      AddNoise2();
    }
 
    if ( verboseLevel > 0 )
    {
      G4cout << "\n-------->digis Collection: in this event they are "
             << digisCollection->entries() << " digis in the MDC chambers: " << G4endl;
      digisCollection->PrintAllDigi();
    }
    StoreDigiCollection( digisCollection );
  }
}

◆ Digitize() [2/3]

virtual void BesMdcDigitizer::Digitize ( )

virtual

◆ Digitize() [3/3]

virtual void BesMdcDigitizer::Digitize ( )

virtual

◆ SetEff() [1/3]

void BesMdcDigitizer::SetEff	(	G4int	layer,
		G4double	eff )

Definition at line 80 of file BesMdcDigitizer.cc.

                                                        {
  if ( layer == -1 )
  {
    for ( G4int i = 0; i < 43; i++ ) { layerEff[i] = eff; }
  }
  else { layerEff[layer] = eff; }
}