BesMdcDigitizer Class Reference

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

Detailed Description

Definition at line 30 of file BesMdcDigitizer.hh.

Constructor & Destructor Documentation

BesMdcDigitizer()

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

BesMdcDigitizer::~BesMdcDigitizer

(

)

Definition at line 90 of file BesMdcDigitizer.cc.

{delete digitizerMessenger;}

Member Function Documentation

Digitize()

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(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);   
    }
 
}

SetEff()

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;
    }
}

SetEffFlag()

void BesMdcDigitizer::SetEffFlag ( G4int flag )

inline

Definition at line 46 of file BesMdcDigitizer.hh.

{effFlag=flag;}

SetMdcDRes()

void BesMdcDigitizer::SetMdcDRes ( G4double res )

inline

Definition at line 44 of file BesMdcDigitizer.hh.

{mdcDRes=res;}

SetNoiseFlag()

void BesMdcDigitizer::SetNoiseFlag ( G4int flag )

inline

Definition at line 39 of file BesMdcDigitizer.hh.

{noiseFlag=flag;}  

SetNoiseLevel()

void BesMdcDigitizer::SetNoiseLevel ( G4double level )

inline

Definition at line 41 of file BesMdcDigitizer.hh.

{noiseLevel=level;}  

SetNoiseType()

void BesMdcDigitizer::SetNoiseType ( G4int type )

inline

Definition at line 40 of file BesMdcDigitizer.hh.

{noiseType=type;}

SetSmearFlag()

void BesMdcDigitizer::SetSmearFlag ( G4int flag )

inline

Definition at line 43 of file BesMdcDigitizer.hh.

{smearFlag=flag;}

---

The documentation for this class was generated from the following files:

• BesMdcDigitizer.hh
• BesMdcDigitizer.cc