BesMdcDigitizer Class Reference

#include <BesMdcDigitizer.hh>

List of all members.

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)

Private Member Functions

G4double Smear (G4double)
G4double Smear (G4double, G4double, G4double)
G4double Smear (G4double, G4double, G4double, G4double, G4double, G4double)
G4double Smear (G4double, G4double, G4double, G4double, G4double, G4double, G4double, G4double, G4double)
void AddNoise (void)
void AddNoise2 (void)

Private Attributes

G4int noiseFlag
G4int noiseType
G4double noiseLevel
G4double maxNoiseT
G4int smearFlag
G4double mdcDRes
G4int effFlag
vector< G4double > layerEff
vector< G4double > mixLevel
G4int digiPointer [43][288]
BesMdcDigisCollection * digisCollection
BesMdcDigitizerMessenger * digitizerMessenger
BesMdcGeoParameter * mdcGeoPointer
BesMdcCalTransfer * mdcCalPointer
MdcTunningSvc * mdcTunningSvc
TFile * f
TH1F * h1
TH1F * h2
TH1F * h3
G4Svc * m_G4Svc
NTuple::Tuple * m_tupleMdc
NTuple::Item< long > m_NHits
NTuple::Item< long > m_layerId
NTuple::Item< long > m_cellId
NTuple::Item< double > m_edep
NTuple::Item< double > m_driftD
NTuple::Item< double > m_globalT
NTuple::Item< double > m_theta
NTuple::Item< double > m_enterAngle
NTuple::Item< double > m_driftDNew
NTuple::Item< double > m_driftTNew

Detailed Description

Definition at line 30 of file BesMdcDigitizer.hh.

Constructor & Destructor Documentation

BesMdcDigitizer::BesMdcDigitizer ( G4String  modName  ) 

Definition at line 29 of file BesMdcDigitizer.cc.

References digitizerMessenger, effFlag, f, BesMdcGeoParameter::GetGeo(), G4Svc::GetMdcNoiseFile(), h1, h2, h3, genRecEmupikp::i, layerEff, m_G4Svc, maxNoiseT, mdcCalPointer, mdcDRes, mdcGeoPointer, mdcTunningSvc, noiseFlag, noiseLevel, noiseType, smearFlag, and deljobs::string.

00029                                                 :G4VDigitizerModule(modName){
00030         noiseFlag=0;
00031         noiseType=3;
00032         noiseLevel=0.1;//10%
00033         maxNoiseT=300.;//ns
00034         smearFlag=1;
00035         mdcDRes = 0.13; //mm
00036         effFlag = 0;
00037         for(G4int i=0; i<43;i++){
00038                 layerEff.push_back(1.);
00039         }
00040         collectionName.push_back("BesMdcDigisCollection");
00041         digitizerMessenger = new BesMdcDigitizerMessenger(this);
00042         mdcGeoPointer=BesMdcGeoParameter::GetGeo();
00043         mdcCalPointer=new BesMdcCalTransfer;
00044 
00045         //  ISvcLocator* svcLocator = Gaudi::svcLocator();
00046         IG4Svc* tmpSvc;
00047         //G4Svc* m_G4Svc;
00048         StatusCode sc=Gaudi::svcLocator()->service("G4Svc", tmpSvc);
00049         if (!sc.isSuccess())
00050                 G4cout <<" MdcDigitizer::Error,could not open G4Svc"<<G4endl;
00051 
00052         m_G4Svc=dynamic_cast<G4Svc *>(tmpSvc); 
00053 
00054         IMdcTunningSvc* IMdcTunningSvc;  
00055         sc= Gaudi::svcLocator()->service("MdcTunningSvc",IMdcTunningSvc);
00056         if (!sc.isSuccess()){
00057                 G4cout <<" MdcDigitizer::Error,could not open Mdc Tunning Service"<<G4endl;
00058         }else{
00059                 G4cout<<" MdcDigitizer:: Open Mdc Tunning Service"<<G4endl; 
00060         }
00061         mdcTunningSvc=dynamic_cast<MdcTunningSvc *>(IMdcTunningSvc); 
00062 
00063         std::string noiseFile=m_G4Svc->GetMdcNoiseFile();
00064         f=new TFile(noiseFile.c_str());
00065         h1=(TH1F*)f->Get("h703");
00066         h2=(TH1F*)f->Get("h501");
00067         h3=(TH1F*)f->Get("h801");    
00068         /*
00069         //get Mdc Ntuple from G4Svc
00070         if(m_G4Svc->MdcRootFlag())
00071         {
00072         m_tupleMdc = m_G4Svc->GetTupleMdc();
00073         sc = m_tupleMdc->addItem("NHits",m_NHits);
00074         sc = m_tupleMdc->addItem("LayerId",m_layerId);
00075         sc = m_tupleMdc->addItem("cellId",m_cellId);
00076         sc = m_tupleMdc->addItem("Edep",m_edep);
00077         sc = m_tupleMdc->addItem("driftD",m_driftD);
00078         // sc = m_tupleMdc->addItem("driftT",m_driftT);
00079         sc = m_tupleMdc->addItem("globalT",m_globalT);
00080         sc = m_tupleMdc->addItem("theta",m_theta);
00081         sc = m_tupleMdc->addItem("enterAngle",m_enterAngle);
00082         sc = m_tupleMdc->addItem("driftDNew",m_driftDNew);  
00083         sc = m_tupleMdc->addItem("driftTNew",m_driftTNew);  
00084         // sc = m_tupleMdc->addItem("adc",m_adc);
00085         // sc = m_tupleMdc->addItem("tdc",m_tdc);
00086         }
00087         */
00088 }

BesMdcDigitizer::~BesMdcDigitizer (  ) 

Definition at line 90 of file BesMdcDigitizer.cc.

References digitizerMessenger.

00090 {delete digitizerMessenger;}

Member Function Documentation

void BesMdcDigitizer::AddNoise ( void   )  [private]

Definition at line 370 of file BesMdcDigitizer.cc.

References digiPointer, digisCollection, G4Svc::GetBeamStartTime(), h1, h2, genRecEmupikp::i, ganga-rec::j, m_G4Svc, mdcGeoPointer, noiseLevel, noiseType, BesMdcWire::R(), BesMdcDigi::SetCellNo(), BesMdcDigi::SetDriftT(), BesMdcDigi::SetEdep(), BesMdcDigi::SetLayerNo(), BesMdcDigi::SetTrackID(), BesMdcGeoParameter::SignalLayer(), BesMdcGeoParameter::SignalLayerNo(), BesMdcLayer::WireNo(), wireNo, and x.

Referenced by Digitize().

00370                                   {
00371         G4double r0,r;
00372         vector<G4double>  noise; //Noise level of each layer
00373 
00374         G4int NLayer=mdcGeoPointer->SignalLayerNo();
00375         if(noiseType==0){
00376                 for(G4int i=0;i<NLayer;i++){
00377                         noise.push_back(noiseLevel);
00378                 }
00379         }else if(noiseType==1){
00380                 r0=mdcGeoPointer->SignalLayer(0).R();
00381                 for(G4int i=0;i<NLayer;i++){
00382                         r=mdcGeoPointer->SignalLayer(i).R();
00383                         noise.push_back(noiseLevel * r0 / r);
00384                 }
00385         }else if(noiseType==2){
00386                 r0=mdcGeoPointer->SignalLayer(0).R();
00387                 for(G4int i=0;i<NLayer;i++){
00388                         r=mdcGeoPointer->SignalLayer(i).R();
00389                         noise.push_back(noiseLevel * r0 * r0 / r / r);
00390                 }
00391         }else if(noiseType==3){ // liugc add 22:11 4/14/06
00392                 Int_t Nbins=(Int_t)h1->GetNbinsX();
00393 
00394                 double xmax=h1->GetXaxis()->GetXmax();
00395                 double xmin=h1->GetXaxis()->GetXmin();
00396                 double dx=(xmax-xmin)/Nbins;
00397                 G4double y;
00398                 for(G4int i=0;i<Nbins;i++){
00399                         double x=double(i+1)*dx;
00400                         y=(G4double)h1->GetBinContent(x);
00401                         y=y*noiseLevel/0.05608559;// Normalize use noise level of 1st layer in "run23096noise.root" 
00402                         noise.push_back(y);
00403                 }
00404         }
00405 
00406         G4int wireNo;
00407         G4double random;
00408         G4double randomT;
00409         G4double randomQ;
00410         G4double T0=m_G4Svc->GetBeamStartTime();
00411         for(G4int i=0;i<NLayer;i++){
00412                 wireNo=mdcGeoPointer->SignalLayer(i).WireNo()/2;
00413                 for(G4int j=0;j<wireNo;j++){
00414                         random=G4UniformRand(); 
00415                         if(random < noise[i]){
00416                                 //randomT=G4UniformRand() * maxNoiseT;
00417                                 randomT=h2->GetRandom()+T0;
00418                                 //        randomT=randomT;
00419                                 //        randomQ=h3->GetRandom();
00420                                 //        randomQ=randomQ*0.001*0.001; //Transfer from TDC channels to Mev, coef. is temporary one.
00421                                 if(isnan(randomT)){
00422                                         G4cout<<"MdcDigitizer: error, randomT is nan"<<G4endl;
00423                                         continue;
00424                                 }
00425 
00426                                 randomQ=0.;
00427                                 if(digiPointer[i][j]!=-1){
00428                                         G4int pointer=digiPointer[i][j];
00429                                         G4double signalEdep=(*digisCollection)[pointer]->GetEdep();
00430                                         (*digisCollection)[pointer]->SetEdep(randomQ+signalEdep);
00431                                         G4double preDriftT=(*digisCollection)[pointer]->GetDriftT();
00432                                         if(preDriftT <= randomT)continue;
00433                                         (*digisCollection)[pointer]->SetDriftT(randomT);
00434                                         (*digisCollection)[pointer]->SetTrackID(-1);
00435                                 }else{
00436                                         BesMdcDigi* newDigi = new BesMdcDigi(); 
00437                                         newDigi->SetTrackID(-1);
00438                                         newDigi->SetLayerNo(i);
00439                                         newDigi->SetCellNo(j);
00440                                         newDigi->SetEdep(randomQ);
00441                                         newDigi->SetDriftT(randomT);
00442                                         digisCollection->insert(newDigi);  
00443                                 }
00444                         }
00445                 }
00446         }
00447 }

void BesMdcDigitizer::AddNoise2 ( void   )  [private]

Definition at line 331 of file BesMdcDigitizer.cc.

References digiPointer, digisCollection, genRecEmupikp::i, ganga-rec::j, mdcGeoPointer, mixLevel, BesMdcDigi::SetCellNo(), BesMdcDigi::SetDriftT(), BesMdcDigi::SetEdep(), BesMdcDigi::SetLayerNo(), BesMdcDigi::SetTrackID(), BesMdcGeoParameter::SignalLayer(), BesMdcGeoParameter::SignalLayerNo(), BesMdcLayer::WireNo(), and wireNo.

Referenced by Digitize().

00331                                    {
00332         G4int wireNo;
00333         G4double random;
00334         G4double randomT;
00335         G4double randomQ;
00336         G4int NLayer=mdcGeoPointer->SignalLayerNo();
00337         for(G4int i=0;i<NLayer;i++){
00338                 wireNo=mdcGeoPointer->SignalLayer(i).WireNo()/2;
00339                 for(G4int j=0;j<wireNo;j++){
00340                         random=G4UniformRand(); 
00341                         if(random < mixLevel[i]){
00342                                 randomT=G4UniformRand() * 2000;
00343                                 if(isnan(randomT)){
00344                                         G4cout<<"MdcDigitizer: error, randomT is nan"<<G4endl;
00345                                         continue;
00346                                 }
00347 
00348                                 randomQ=200.;
00349                                 if(digiPointer[i][j]!=-1){
00350                                         G4int pointer=digiPointer[i][j];
00351                                         G4double preDriftT=(*digisCollection)[pointer]->GetDriftT();
00352                                         if(preDriftT <= randomT)continue;
00353                                         (*digisCollection)[pointer]->SetDriftT(randomT);
00354                                         (*digisCollection)[pointer]->SetTrackID(-1);
00355                                 }else{
00356                                         BesMdcDigi* newDigi = new BesMdcDigi(); 
00357                                         newDigi->SetTrackID(-1);
00358                                         newDigi->SetLayerNo(i);
00359                                         newDigi->SetCellNo(j);
00360                                         newDigi->SetEdep(randomQ);
00361                                         newDigi->SetDriftT(randomT);
00362                                         digisCollection->insert(newDigi);  
00363                                 }
00364                         }
00365                 }
00366         }
00367 }

void BesMdcDigitizer::Digitize (  )  [virtual]

Definition at line 102 of file BesMdcDigitizer.cc.

References AddNoise(), AddNoise2(), cos(), BesMdcCalTransfer::D2T(), digiPointer, digisCollection, effFlag, f, MdcTunningSvc::GetEff(), MdcTunningSvc::GetRes3(), BesMdcCalTransfer::GetT0(), BesMdcCalTransfer::GetTimeWalk(), genRecEmupikp::i, ganga-rec::j, layerEff, mdcCalPointer, mdcGeoPointer, mdcTunningSvc, mixLevel, NHits(), noiseFlag, BesMdcDigi::SetCellNo(), BesMdcDigi::SetDriftT(), BesMdcDigi::SetEdep(), BesMdcCalTransfer::SetHitPointer(), BesMdcDigi::SetLayerNo(), BesMdcDigi::SetTrackID(), BesMdcGeoParameter::SignalLayerNo(), Smear(), and smearFlag.

00102                               {
00103 
00104         //initialize 
00105         for(G4int i=0; i<43;i++){
00106                 for(G4int j=0;j<288;j++){
00107                         digiPointer[i][j]=-1;
00108                 }
00109         }
00110 
00111         G4int  NHits,layerId, cellId, posFlag; 
00112         G4double edep,driftD,driftT, globalT, theta,cosTheta,enterAngle;
00113         G4double mean,sigma,mean1,mean2,sigma1, sigma2, f,sig,delSig, fRandom, driftDNew, driftTNew;
00114         G4double tempEff;
00115         G4double resLargest,resSmallest,resRatio;//added by liukai
00116 
00117         G4DigiManager* DigiMan = G4DigiManager::GetDMpointer();
00118 
00119         //hits collection ID
00120         G4int THCID=-1;
00121         THCID = DigiMan->GetHitsCollectionID("BesMdcHitsCollection");
00122 
00123         //hits collection
00124         BesMdcHitsCollection* THC = 0;
00125         THC = (BesMdcHitsCollection*) (DigiMan->GetHitsCollection(THCID));
00126 
00127         if(THC){
00128                 digisCollection=new BesMdcDigisCollection
00129                         (moduleName, collectionName[0]);
00130                 NHits=THC->entries();
00131                 for(G4int i=0;i<NHits;i++){
00132                         layerId = (*THC)[i]->GetLayerNo();
00133                         cellId = (*THC)[i]->GetCellNo();
00134                         edep = (*THC)[i]->GetEdep();
00135                         driftD = (*THC)[i]->GetDriftD();
00136                         globalT = (*THC)[i]->GetGlobalT();
00137                         theta = (*THC)[i]->GetTheta();
00138                         cosTheta = cos(theta); 
00139                         enterAngle = (*THC)[i]->GetEnterAngle();
00140                         posFlag = (*THC)[i]->GetPosFlag();
00141 
00142                         //Transfer hit pointer to BesMdcCalTransfer
00143                         mdcCalPointer->SetHitPointer((*THC)[i]);
00144 
00145                         //Filter with wire efficiency
00146                         if(effFlag==0){
00147                                 //tempEff = mdcCalPointer->GetEff();
00148                                 tempEff=mdcTunningSvc->GetEff(layerId,cellId,driftD,cosTheta,posFlag);
00149                         }else{
00150                                 tempEff = layerEff[layerId];
00151                         }
00152                         fRandom=G4UniformRand();
00153                         if(fRandom>tempEff)continue;
00154 
00155                         //cout<<"layerid "<<layerId<<" cellid "<<cellId<<" theta "<<cosTheta<<" enterangle "<<enterAngle<<endl;
00156                         //Drift distance smear
00157                         if(smearFlag==0){ //No smear
00158                                 driftDNew = driftD;
00159                         }else if(smearFlag==1){           //Smear from TuningSvc
00160                                 //      mdcTunningSvc->GetRes(layerId,cellId,driftD,cosTheta,posFlag,enterAngle,mean,sigma);
00161                                 //mdcTunningSvc->GetRes2(layerId,cellId,driftD,cosTheta,posFlag,enterAngle,f,mean1,sigma1,mean2,sigma2);
00162                                 mdcTunningSvc->GetRes3(layerId,cellId,driftD,cosTheta,posFlag,enterAngle,f,mean1,sigma1,mean2,sigma2,resLargest,resSmallest,resRatio);
00163 
00164                                 //driftDNew = Smear(driftD,f,mean1,sigma1,mean2,sigma2);
00165                                 //driftDNew = Smear(driftD-(f*mean1+(1-f)*mean2),f,mean1,sigma1,mean2,sigma2);//new method
00166 
00167                                 driftDNew = Smear(driftD-(f*mean1+(1-f)*mean2),f,mean1,sigma1,mean2,sigma2,resLargest,resSmallest,resRatio);//----added by liukai 2012-6-4
00168 
00169 
00170                         }else if(smearFlag==2){ //Smear with fixed resolution
00171                                 driftDNew = Smear(driftD);
00172                         }else{
00173                                 G4cerr<<"MdcDigitizer::worong smearFlag: "<<smearFlag<<G4endl;
00174                         }
00175 
00176                         //Do X-T conversion
00177                         driftTNew = mdcCalPointer->D2T(driftDNew);
00178 
00179                         //Do Q-T correct
00180                         driftTNew += mdcCalPointer->GetTimeWalk();
00181 
00182                         //Add T0
00183                         driftTNew += mdcCalPointer->GetT0();
00184 
00185                         //Add TOF
00186                         driftTNew += globalT;
00187 
00188                         //Signal transfer time on wire
00189                         // transferT=Transfer(layerId,cellId,hitPosition);
00190                         //driftTNew+=transferT;
00191 
00192                         if(isnan(driftTNew)){
00193                                 G4cout<<"MdcDigitizer::error, driftT is nan"<<G4endl;
00194                                 continue;
00195                         }
00196 
00197                         /*
00198                            if(m_G4Svc->MdcRootFlag())
00199                            {
00200                            m_NHits= NHits;
00201                            m_layerId= layerId;
00202                            m_cellId= cellId;
00203                            m_edep= edep;
00204                            m_driftD= driftD;
00205                         //     m_driftT= driftT;
00206                         m_globalT = globalT;
00207                         m_enterAngle = enterAngle;
00208                         m_driftDNew = driftDNew;
00209                         m_driftTNew = driftTNew;
00210                         m_theta = theta;
00211                         m_tupleMdc ->write(); 
00212                         }
00213                         */
00214                         BesMdcDigi* newDigi = new BesMdcDigi(); 
00215                         newDigi->SetTrackID((*THC)[i]->GetTrackID());
00216                         newDigi->SetLayerNo(layerId);
00217                         newDigi->SetCellNo(cellId);
00218                         newDigi->SetEdep(edep);
00219                         newDigi->SetDriftT(driftTNew);
00220                         G4int NbDigis = digisCollection->insert(newDigi);
00221                         digiPointer[layerId][cellId]=NbDigis-1;
00222                 } 
00223 
00224                 if(noiseFlag==1)AddNoise();
00225                 if(noiseFlag==2){
00226                         ifstream readNoiseLevel("$MDCSIMROOT/share/noiselevel.txt");
00227                         if(!readNoiseLevel.good()){
00228                                 std::cout<<" Error , noiselevel file not exist "<<std::endl;
00229                         }else{
00230                                 std::cout<<" MdcDigitizer:: Open noiselevel file  "<<std::endl;
00231                         }
00232                         G4int NLayer=mdcGeoPointer->SignalLayerNo();
00233                         G4double level;
00234                         for(G4int i=0;i<NLayer;i++){
00235                                 readNoiseLevel>>level;
00236                                 mixLevel.push_back(level);
00237                         }
00238                         AddNoise2();
00239                 }
00240 
00241                 if (verboseLevel>0) { 
00242                         G4cout << "\n-------->digis Collection: in this event they are " 
00243                                 << digisCollection->entries() 
00244                                 << " digis in the MDC chambers: " << G4endl;
00245                         digisCollection->PrintAllDigi();
00246                 } 
00247                 StoreDigiCollection(digisCollection);   
00248         }
00249 
00250 }

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

Definition at line 92 of file BesMdcDigitizer.cc.

References genRecEmupikp::i, and layerEff.

Referenced by BesMdcDigitizerMessenger::SetNewValue().

00092                                                      {
00093         if(layer==-1){
00094                 for(G4int i=0; i<43;i++){
00095                         layerEff[i]=eff;
00096                 }
00097         }else{
00098                 layerEff[layer]=eff;
00099         }
00100 }

void BesMdcDigitizer::SetEffFlag ( G4int  flag  )  [inline]

Definition at line 46 of file BesMdcDigitizer.hh.

References effFlag.

Referenced by BesMdcDigitizerMessenger::SetNewValue().

00046 {effFlag=flag;}

void BesMdcDigitizer::SetMdcDRes ( G4double  res  )  [inline]

Definition at line 44 of file BesMdcDigitizer.hh.

References mdcDRes.

Referenced by BesMdcDigitizerMessenger::SetNewValue().

00044 {mdcDRes=res;}

void BesMdcDigitizer::SetNoiseFlag ( G4int  flag  )  [inline]

Definition at line 39 of file BesMdcDigitizer.hh.

References noiseFlag.

Referenced by BesMdcDigitizerMessenger::SetNewValue().

00039 {noiseFlag=flag;}

void BesMdcDigitizer::SetNoiseLevel ( G4double  level  )  [inline]

Definition at line 41 of file BesMdcDigitizer.hh.

References noiseLevel.

Referenced by BesMdcDigitizerMessenger::SetNewValue().

00041 {noiseLevel=level;}

void BesMdcDigitizer::SetNoiseType ( G4int  type  )  [inline]

Definition at line 40 of file BesMdcDigitizer.hh.

References noiseType.

Referenced by BesMdcDigitizerMessenger::SetNewValue().

00040 {noiseType=type;}

void BesMdcDigitizer::SetSmearFlag ( G4int  flag  )  [inline]

Definition at line 43 of file BesMdcDigitizer.hh.

References smearFlag.

Referenced by BesMdcDigitizerMessenger::SetNewValue().

00043 {smearFlag=flag;}

G4double BesMdcDigitizer::Smear ( G4double  ,
G4double  ,
G4double  ,
G4double  ,
G4double  ,
G4double  ,
G4double  ,
G4double  ,
G4double   
) [private]

Definition at line 296 of file BesMdcDigitizer.cc.

00296                                                                                                                                                                                   {
00297         G4double r, driftDNew,mean,sigma;
00298         G4double ratio,tempd;
00299         ratio=G4UniformRand();
00300         int times;
00301         if(ratio<=resRatio)
00302         {
00303                 //for hitOnTrk distribution
00304                 r = G4UniformRand(); 
00305                 if(r<=f){
00306                         mean=mean1;
00307                         sigma=sigma1;
00308                 }else{
00309                         mean=mean2;
00310                         sigma=sigma2;
00311                 }
00312                 times=0;
00313                 r = G4RandGauss::shoot();
00314                 driftDNew = driftD + sigma * r+mean;
00315         }
00316         else//for hitNotOnTrk
00317         {
00318                 tempd=G4UniformRand()*2.0+resLargest;
00319                 times=0;
00320                 driftDNew = driftD + tempd;
00321         }
00322         while(driftDNew <= 0){
00323                 r = G4RandGauss::shoot();
00324                 driftDNew = driftD + sigma * r+mean;
00325                 times++;
00326                 if(times>10)driftDNew=0.01;
00327         }
00328         return driftDNew;
00329 }

G4double BesMdcDigitizer::Smear ( G4double  ,
G4double  ,
G4double  ,
G4double  ,
G4double  ,
G4double   
) [private]

Definition at line 274 of file BesMdcDigitizer.cc.

00274                                                                                                                        {
00275         G4double r, driftDNew,mean,sigma;
00276         r = G4UniformRand(); 
00277         if(r<=f){
00278                 mean=mean1;
00279                 sigma=sigma1;
00280         }else{
00281                 mean=mean2;
00282                 sigma=sigma2;
00283         }
00284         int times=0;
00285         r = G4RandGauss::shoot();
00286         driftDNew = driftD + sigma * r+mean;
00287         while(driftDNew <= 0){
00288                 r = G4RandGauss::shoot();
00289                 driftDNew = driftD + sigma * r+mean;
00290                 times++;
00291                 if(times>10)driftDNew=0.01;
00292         }
00293         return driftDNew;
00294 }

G4double BesMdcDigitizer::Smear ( G4double  ,
G4double  ,
G4double   
) [private]

Definition at line 263 of file BesMdcDigitizer.cc.

00263                                                                            {
00264         G4double r, driftDNew;
00265         r = G4RandGauss::shoot();
00266         driftDNew = driftD + sigma * r+mean;
00267         while(driftDNew <= 0){
00268                 r = G4RandGauss::shoot();
00269                 driftDNew = driftD + sigma * r+mean;
00270         }
00271         return driftDNew;
00272 }

G4double BesMdcDigitizer::Smear ( G4double   )  [private]

Definition at line 252 of file BesMdcDigitizer.cc.

References mdcDRes.

Referenced by Digitize().

00252                                               {
00253         G4double r, driftDNew;
00254         r = G4RandGauss::shoot();
00255         driftDNew = driftD + mdcDRes * r;
00256         while(driftDNew<=0){
00257                 r = G4RandGauss::shoot();
00258                 driftDNew = driftD + mdcDRes * r;
00259         }
00260         return driftDNew;
00261 }

Member Data Documentation

G4int BesMdcDigitizer::digiPointer[43][288] [private]

Definition at line 70 of file BesMdcDigitizer.hh.

Referenced by AddNoise(), AddNoise2(), and Digitize().

BesMdcDigisCollection* BesMdcDigitizer::digisCollection [private]

Definition at line 71 of file BesMdcDigitizer.hh.

Referenced by AddNoise(), AddNoise2(), and Digitize().

BesMdcDigitizerMessenger* BesMdcDigitizer::digitizerMessenger [private]

Definition at line 72 of file BesMdcDigitizer.hh.

Referenced by BesMdcDigitizer(), and ~BesMdcDigitizer().

G4int BesMdcDigitizer::effFlag [private]

Definition at line 66 of file BesMdcDigitizer.hh.

Referenced by BesMdcDigitizer(), Digitize(), and SetEffFlag().

TFile* BesMdcDigitizer::f [private]

Definition at line 77 of file BesMdcDigitizer.hh.

Referenced by BesMdcDigitizer(), and Digitize().

TH1F* BesMdcDigitizer::h1 [private]

Definition at line 78 of file BesMdcDigitizer.hh.

Referenced by AddNoise(), and BesMdcDigitizer().

TH1F* BesMdcDigitizer::h2 [private]

Definition at line 79 of file BesMdcDigitizer.hh.

Referenced by AddNoise(), and BesMdcDigitizer().

TH1F* BesMdcDigitizer::h3 [private]

Definition at line 80 of file BesMdcDigitizer.hh.

Referenced by BesMdcDigitizer().

vector<G4double> BesMdcDigitizer::layerEff [private]

Definition at line 67 of file BesMdcDigitizer.hh.

Referenced by BesMdcDigitizer(), Digitize(), and SetEff().

NTuple::Item<long> BesMdcDigitizer::m_cellId [private]

Definition at line 86 of file BesMdcDigitizer.hh.

NTuple::Item<double> BesMdcDigitizer::m_driftD [private]

Definition at line 88 of file BesMdcDigitizer.hh.

NTuple::Item<double> BesMdcDigitizer::m_driftDNew [private]

Definition at line 93 of file BesMdcDigitizer.hh.

NTuple::Item<double> BesMdcDigitizer::m_driftTNew [private]

Definition at line 94 of file BesMdcDigitizer.hh.

NTuple::Item<double> BesMdcDigitizer::m_edep [private]

Definition at line 87 of file BesMdcDigitizer.hh.

NTuple::Item<double> BesMdcDigitizer::m_enterAngle [private]

Definition at line 92 of file BesMdcDigitizer.hh.

G4Svc* BesMdcDigitizer::m_G4Svc [private]

Definition at line 82 of file BesMdcDigitizer.hh.

Referenced by AddNoise(), and BesMdcDigitizer().

NTuple::Item<double> BesMdcDigitizer::m_globalT [private]

Definition at line 90 of file BesMdcDigitizer.hh.

NTuple::Item<long> BesMdcDigitizer::m_layerId [private]

Definition at line 85 of file BesMdcDigitizer.hh.

NTuple::Item<long> BesMdcDigitizer::m_NHits [private]

Definition at line 84 of file BesMdcDigitizer.hh.

NTuple::Item<double> BesMdcDigitizer::m_theta [private]

Definition at line 91 of file BesMdcDigitizer.hh.

NTuple::Tuple* BesMdcDigitizer::m_tupleMdc [private]

Definition at line 83 of file BesMdcDigitizer.hh.

G4double BesMdcDigitizer::maxNoiseT [private]

Definition at line 61 of file BesMdcDigitizer.hh.

Referenced by BesMdcDigitizer().

BesMdcCalTransfer* BesMdcDigitizer::mdcCalPointer [private]

Definition at line 74 of file BesMdcDigitizer.hh.

Referenced by BesMdcDigitizer(), and Digitize().

G4double BesMdcDigitizer::mdcDRes [private]

Definition at line 64 of file BesMdcDigitizer.hh.

Referenced by BesMdcDigitizer(), SetMdcDRes(), and Smear().

BesMdcGeoParameter* BesMdcDigitizer::mdcGeoPointer [private]

Definition at line 73 of file BesMdcDigitizer.hh.

Referenced by AddNoise(), AddNoise2(), BesMdcDigitizer(), and Digitize().

MdcTunningSvc* BesMdcDigitizer::mdcTunningSvc [private]

Definition at line 75 of file BesMdcDigitizer.hh.

Referenced by BesMdcDigitizer(), and Digitize().

vector<G4double> BesMdcDigitizer::mixLevel [private]

Definition at line 68 of file BesMdcDigitizer.hh.

Referenced by AddNoise2(), and Digitize().

G4int BesMdcDigitizer::noiseFlag [private]

Definition at line 58 of file BesMdcDigitizer.hh.

Referenced by BesMdcDigitizer(), Digitize(), and SetNoiseFlag().

G4double BesMdcDigitizer::noiseLevel [private]

Definition at line 60 of file BesMdcDigitizer.hh.

Referenced by AddNoise(), BesMdcDigitizer(), and SetNoiseLevel().

G4int BesMdcDigitizer::noiseType [private]

Definition at line 59 of file BesMdcDigitizer.hh.

Referenced by AddNoise(), BesMdcDigitizer(), and SetNoiseType().

G4int BesMdcDigitizer::smearFlag [private]

Definition at line 63 of file BesMdcDigitizer.hh.

Referenced by BesMdcDigitizer(), Digitize(), and SetSmearFlag().

Generated on Tue Nov 29 23:17:32 2016 for BOSS_7.0.2 by  doxygen 1.4.7