#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)

Detailed Description

Definition at line 30 of file InstallArea/include/MdcSim/MdcSim/BesMdcDigitizer.hh.

Constructor & Destructor Documentation

◆ BesMdcDigitizer() [1/2]

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;
 
    //  ISvcLocator* svcLocator = Gaudi::svcLocator();
    IG4Svc* tmpSvc;
    //G4Svc* m_G4Svc;
    StatusCode sc=Gaudi::svcLocator()->service("G4Svc", tmpSvc);
    if (!sc.isSuccess())
        G4cout <<" MdcDigitizer::Error,could not open G4Svc"<<G4endl;
 
    m_G4Svc=dynamic_cast<G4Svc *>(tmpSvc); 
 
    IMdcTunningSvc* IMdcTunningSvc;  
    sc= Gaudi::svcLocator()->service("MdcTunningSvc",IMdcTunningSvc);
    if (!sc.isSuccess()){
        G4cout <<" MdcDigitizer::Error,could not open Mdc Tunning Service"<<G4endl;
    }else{
        G4cout<<" MdcDigitizer:: Open Mdc Tunning Service"<<G4endl; 
    }
    mdcTunningSvc=dynamic_cast<MdcTunningSvc *>(IMdcTunningSvc); 
 
    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/2]

BesMdcDigitizer::~BesMdcDigitizer ( )

Definition at line 90 of file BesMdcDigitizer.cc.

90{delete digitizerMessenger;}

◆ BesMdcDigitizer() [2/2]

BesMdcDigitizer::BesMdcDigitizer ( G4String modName )

◆ ~BesMdcDigitizer() [2/2]

BesMdcDigitizer::~BesMdcDigitizer ( )

Member Function Documentation

◆ Digitize() [1/2]

void BesMdcDigitizer::Digitize ( )

virtual

Definition at line 102 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::worong smearFlag: "<<smearFlag<<G4endl;
            }
 
            //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(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/2]

virtual void BesMdcDigitizer::Digitize ( )

virtual

◆ SetEff() [1/2]

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

Definition at line 92 of file BesMdcDigitizer.cc.

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