BesTofDigitizerEcV4 Class Reference

#include <BesTofDigitizerEcV4.hh>

Inheritance diagram for BesTofDigitizerEcV4:

Classes
struct	HitStruct
struct	Param
struct	StripStruct

Public Member Functions
	BesTofDigitizerEcV4 ()
	~BesTofDigitizerEcV4 ()
void	initial ()
virtual void	Digitize (ScintSingle *, BesTofDigitsCollection *)
int	calStrip (double locZ)
bool	underStrip (double locX, double locZ)
double	calTdcRes_charge (double charge_fC)
double	charge2Time (double charge_fC)
double	calAdcRes_charge (double charge_fC)
double	calTdcRes_charge1 (double charge_fC)
double	charge2Time1 (double charge_fC)
double	calAdcRes_charge1 (double charge_fC)
Public Member Functions inherited from BesTofDigitizerV
	BesTofDigitizerV ()
	~BesTofDigitizerV ()
void	Initialize ()

Additional Inherited Members
Protected Attributes inherited from BesTofDigitizerV
BesTofDigitsCollection *	m_besTofDigitsCollection
BesTofHitsCollection *	m_THC
ITofCaliSvc *	m_tofCaliSvc
ITofSimSvc *	m_tofSimSvc
ITofQElecSvc *	m_tofQElecSvc
G4double	m_ADC [2]
G4double	m_TDC [2]
G4int	m_trackIndex
G4double	m_globalTime
Static Protected Attributes inherited from BesTofDigitizerV
static bool	m_booked = false
static NTuple::Tuple *	m_tupleTof1 = 0
static NTuple::Item< double >	m_partId
static NTuple::Item< double >	m_scinNb
static NTuple::Item< double >	m_edep
static NTuple::Item< double >	m_nHits
static NTuple::Item< double >	m_time1st0
static NTuple::Item< double >	m_time1st1
static NTuple::Item< double >	m_timelast0
static NTuple::Item< double >	m_timelast1
static NTuple::Item< double >	m_totalPhot0
static NTuple::Item< double >	m_totalPhot1
static NTuple::Item< double >	m_NphAllSteps
static NTuple::Item< double >	m_max0
static NTuple::Item< double >	m_max1
static NTuple::Item< double >	m_tdc0
static NTuple::Item< double >	m_adc0
static NTuple::Item< double >	m_tdc1
static NTuple::Item< double >	m_adc1
static NTuple::Tuple *	m_tupleTof2 = 0
static NTuple::Item< double >	m_eTotal
static NTuple::Item< double >	m_nDigi
static NTuple::Item< double >	m_partIdMPV
static NTuple::Item< double >	m_scinNbMPV
static NTuple::Item< double >	m_edepMPV
static NTuple::Item< double >	m_nDigiOut
static NTuple::Tuple *	m_tupleTof3 = 0
static NTuple::Item< double >	m_forb
static NTuple::Item< double >	m_timeFlight
static NTuple::Item< double >	m_ddT
static NTuple::Item< double >	m_scinSwim
static NTuple::Item< double >	m_scinTime
static NTuple::Item< double >	m_transitTime
static NTuple::Item< double >	m_endTime
static NTuple::Item< double >	m_edepHit

Detailed Description

Definition at line 27 of file BesTofDigitizerEcV4.hh.

Constructor & Destructor Documentation

BesTofDigitizerEcV4()

BesTofDigitizerEcV4::BesTofDigitizerEcV4

(

)

Definition at line 33 of file BesTofDigitizerEcV4.cc.

{
    PropertyMgr m_propMgr;
    m_propMgr.declareProperty("FileName",         m_fileName = "mrpc.root");
    m_propMgr.declareProperty("RootFlag",         m_rootFlag = false);
    m_propMgr.declareProperty("E",                m_V = 7000);
    m_propMgr.declareProperty("Threshold",        m_threshold = 5.5e+08);
 
    m_propMgr.declareProperty("nstep",            m_nstep = -1);
    m_propMgr.declareProperty("E_weight",         m_E_weight = -1);
    m_propMgr.declareProperty("saturationFlag",   m_saturationFlag = true);
    m_propMgr.declareProperty("tdcRes_const",     tdcRes_const = -1);
    m_propMgr.declareProperty("adcRes_const",     adcRes_const = -1);
    m_propMgr.declareProperty("calTdcRes_charge_flag",  m_calTdcRes_charge_flag=0);
    m_propMgr.declareProperty("charge2Time_flag",       m_charge2Time_flag=0);
    m_propMgr.declareProperty("calAdcRes_charge_flag",  m_calAdcRes_charge_flag=0);
 
    IJobOptionsSvc* jobSvc;
    Gaudi::svcLocator()->service("JobOptionsSvc", jobSvc);
    jobSvc->setMyProperties("BesTofDigitizerEcV4", &m_propMgr);
 
    initial();
 
    if(m_rootFlag)
    {
        m_file = new TFile(m_fileName.c_str(), "RECREATE");
        m_tree = new TTree("mrpc", "mrpc");
 
        m_tree->Branch("event",     &m_event,     "event/D");
        m_tree->Branch("partId",    &m_partId,    "partId/D");
        m_tree->Branch("module", &m_module, "module/D");
        m_tree->Branch("time_leading_sphi", &m_time_leading_sphi, "time_leading_sphi/D");
        m_tree->Branch("time_leading_xphi", &m_time_leading_xphi, "time_leading_xphi/D");
        m_tree->Branch("time_trailing_sphi", &m_time_trailing_sphi, "time_trailing_sphi/D");
        m_tree->Branch("time_trailing_xphi", &m_time_trailing_xphi, "time_trailing_xphi/D");
        m_tree->Branch("tdcRes", &m_tdcRes, "tdcRes/D");
        m_tree->Branch("tdcRes_charge", &m_tdcRes_charge, "tdcRes_charge/D");
        m_tree->Branch("adc", &m_adc, "adc/D");
        m_tree->Branch("adcRes", &m_adcRes, "adcRes/D");
        m_tree->Branch("adcRes_charge", &m_adcRes_charge, "adcRes_charge/D");
        m_tree->Branch("strip", &m_strip, "strip/D");
        m_tree->Branch("trkIndex", &m_trkIndex, "trkIndex/D");
        m_tree->Branch("tStart", &m_tStart, "tStart/D");
        m_tree->Branch("tPropagate_sphi", &m_tPropagate_sphi, "tPropagate_sphi/D");
        m_tree->Branch("tPropagate_xphi", &m_tPropagate_xphi, "tPropagate_xphi/D");
        m_tree->Branch("tThreshold", &m_tThreshold, "tThreshold/D");
        m_tree->Branch("charge", &m_charge, "charge/D");
        m_tree->Branch("nhit", &m_nhit, "nhit/I");
        m_tree->Branch("ions_hit", m_ions_hit, "ions_hit[nhit]/D");
        m_tree->Branch("trkIndex_hit", m_trkIndex_hit, "trkIndex_hit[nhit]/D");
        m_tree->Branch("pdgCode_hit", m_pdgCode_hit, "pdgCode_hit[nhit]/D");
        m_tree->Branch("gap_hit", m_gap_hit, "gap_hit[nhit]/D");
        m_tree->Branch("underStrip_hit", m_underStrip_hit, "underStrip_hit[nhit]/D");
        m_tree->Branch("locx_hit", m_locx_hit, "locx_hit[nhit]/D");
        m_tree->Branch("locy_hit", m_locy_hit, "locy_hit[nhit]/D");
        m_tree->Branch("locz_hit", m_locz_hit, "locz_hit[nhit]/D");
        m_tree->Branch("x_hit", m_x_hit, "x_hit[nhit]/D");
        m_tree->Branch("y_hit", m_y_hit, "y_hit[nhit]/D");
        m_tree->Branch("z_hit", m_z_hit, "z_hit[nhit]/D");
        m_tree->Branch("px_hit", m_px_hit, "px_hit[nhit]/D");
        m_tree->Branch("py_hit", m_py_hit, "py_hit[nhit]/D");
        m_tree->Branch("pz_hit", m_pz_hit, "pz_hit[nhit]/D");
    }
}

~BesTofDigitizerEcV4()

BesTofDigitizerEcV4::~BesTofDigitizerEcV4

(

)

Definition at line 99 of file BesTofDigitizerEcV4.cc.

{
    if(m_rootFlag)
    {
        m_file->Write();
        m_file->Close();
    }
}

Member Function Documentation

calAdcRes_charge()

double BesTofDigitizerEcV4::calAdcRes_charge

(

double

charge_fC

)

Definition at line 586 of file BesTofDigitizerEcV4.cc.

{
    double time=0;
    if(charge_fC<250)
    {
        time = 72.6005*exp(-charge_fC*0.0302626 + 1.49059) + 40.8627;
    }
    else 
    {
        time = 32.6233+0.00404149*charge_fC;
    }
    if(time<0) time=0;
    return time; //ps
}

Referenced by Digitize().

calAdcRes_charge1()

double BesTofDigitizerEcV4::calAdcRes_charge1

(

double

charge_fC

)

Definition at line 624 of file BesTofDigitizerEcV4.cc.

{
    double time = 64.3326*exp(-charge_fC/25.4638 + 0.944184)+19.4846;
    if(time<0) time=0;
    return time; //ps
}

Referenced by Digitize().

calStrip()

int BesTofDigitizerEcV4::calStrip

(

double

locZ

)

Definition at line 355 of file BesTofDigitizerEcV4.cc.

{
    int strip=-1;
    double stripWidth = m_param.strip_z+m_param.strip_gap; //Strip spread: (24+3)mm
    int nstrip = m_param.nstrip;
    //the offset between strip coordinate and gas SD: 0.5
    double length = locZ+stripWidth*nstrip/2-0.5;
    if(length<=0)
    {
        strip=0;
    }
    else if(length<stripWidth*nstrip)
    {
        for(int i=0; i<nstrip; i++)
        {
            if(length>i*stripWidth && length<(i+1)*stripWidth)
            {
                strip = i;
                break;
            }
        }
    }
    else
    {
        strip=nstrip-1;
    }
    if(strip<0) strip=0;
    if(strip>nstrip-1) strip=nstrip-1;
 
    return strip;
}

Referenced by Digitize().

calTdcRes_charge()

double BesTofDigitizerEcV4::calTdcRes_charge

(

double

charge_fC

)

Definition at line 563 of file BesTofDigitizerEcV4.cc.

{
    double time=0;
    if( charge_fC<250) 
    {
        time =  100.764*exp(-charge_fC*0.0413966+0.377154)+ 13.814;
    }
    else
    {
        time = 12.8562+0.000507299*charge_fC;
    }
    if(time<0) time=0;
    return time; //ps
}

Referenced by Digitize().

calTdcRes_charge1()

double BesTofDigitizerEcV4::calTdcRes_charge1

(

double

charge_fC

)

Definition at line 601 of file BesTofDigitizerEcV4.cc.

{
    double result =0;
    if( charge_fC > 50.)
    {
        result =  67.6737*exp(-charge_fC/50.9995-0.27755)+9.06223;
    }
    else
    {
        result = 176.322-2.98345*charge_fC;
    }
    if(result<0) result=0;
    return result; //ps
}

Referenced by Digitize().

charge2Time()

double BesTofDigitizerEcV4::charge2Time

(

double

charge_fC

)

Definition at line 578 of file BesTofDigitizerEcV4.cc.

{
    double time=0;
    time=-120.808/log(charge_fC*30.1306)+26.6024; //ns
    if(time<0) time=0;
    return time;
}

Referenced by Digitize().

charge2Time1()

double BesTofDigitizerEcV4::charge2Time1

(

double

charge_fC

)

Definition at line 616 of file BesTofDigitizerEcV4.cc.

{
    double time=0;
    time=-4.50565/log(charge_fC*0.0812208)+16.6653; //ns
    if(time<0) time=0;
    return time;
}

Referenced by Digitize().

Digitize()

void BesTofDigitizerEcV4::Digitize ( ScintSingle * single_module, BesTofDigitsCollection * DC )

virtual

Reimplemented from BesTofDigitizerV.

Definition at line 146 of file BesTofDigitizerEcV4.cc.

{
    m_besTofDigitsCollection = DC;
    G4DigiManager* digiManager = G4DigiManager::GetDMpointer();
    G4int THCID = digiManager->GetHitsCollectionID("BesTofHitsCollection");
    m_THC = (BesTofHitsCollection*) (digiManager->GetHitsCollection(THCID));
    if( !m_THC ) return;
 
    partId = single_module->GetPartId();
    module = single_module->GetModule_mrpc();
    //cout<<"partId= "<<partId<<"  module= "<<module<<endl;
 
    //Process the hits
    int nstrip = m_param.nstrip;
    StripStruct stripStruct[12];
    for(int i=0; i<nstrip; i++)
    {
        stripStruct[i].m_param = m_param;
        stripStruct[i].setPar(m_param.alpha, m_param.eta, m_param.v_drift, m_threshold, m_saturationFlag);
    }
 
    BesTofHit* hit;
    for(unsigned int i=0; i<single_module->GetHitIndexes_mrpc()->size(); i++)
    {
        hit = (*m_THC)[ (*(single_module->GetHitIndexes_mrpc()))[i] ];
        m_event = hit->GetEvent();
 
        HitStruct hitStruct;
        hitStruct.m_param = m_param;
        hitStruct.trkIndex = hit->GetG4Index();
        hitStruct.pdgCode = hit->GetPDGcode();
        hitStruct.ions = hit->GetIons();
        hitStruct.strip = calStrip(hit->GetLocPos().z()/mm);
        hitStruct.underStrip = underStrip(hit->GetLocPos().x()/mm, hit->GetLocPos().z()/mm);
        hitStruct.gap = hit->GetGapNb();
        hitStruct.glbTime = hit->GetTime()/ns;
        hitStruct.locx = hit->GetLocPos().x()/mm;
        hitStruct.locy = hit->GetLocPos().y()/mm;
        hitStruct.locz = hit->GetLocPos().z()/mm;
        hitStruct.x = hit->GetPos().x()/mm;
        hitStruct.y = hit->GetPos().y()/mm;
        hitStruct.z = hit->GetPos().z()/mm;
        hitStruct.px = hit->GetMomentum().x()/(GeV/(3e+08*m/s));
        hitStruct.py = hit->GetMomentum().y()/(GeV/(3e+08*m/s));
        hitStruct.pz = hit->GetMomentum().z()/(GeV/(3e+08*m/s));
        //hitStruct.print();
 
        if(hitStruct.ions>0 && hitStruct.glbTime>0) 
        {
            stripStruct[hitStruct.strip].hitStructCol.push_back(hitStruct);
        }
    }
 
    //test multihit, study the lower peak in charge
    int hitSize=0;
 
    for(int i=0; i<nstrip; i++)
    {
        if(stripStruct[i].hitStructCol.size()==0) continue;
        stripStruct[i].strip = i;
        stripStruct[i].calFirstHit();
        stripStruct[i].avalanche();
        //stripStruct[i].print();
 
        if(stripStruct[i].tThreshold<=0) continue;
 
        tdc_sphi = stripStruct[i].tStart + stripStruct[i].tThreshold + stripStruct[i].tPropagate_sphi;
        tdc_xphi = stripStruct[i].tStart + stripStruct[i].tThreshold + stripStruct[i].tPropagate_xphi;
 
        double tdcRes_charge;
        if(m_calTdcRes_charge_flag==0)
        {
            tdcRes_charge = calTdcRes_charge(stripStruct[i].charge*1000); //ps, charge in fC
        }
        else if(m_calTdcRes_charge_flag==1)
        {
            tdcRes_charge = calTdcRes_charge1(stripStruct[i].charge*1000);
        }
        else if(m_calTdcRes_charge_flag==2)
        {
            tdcRes_charge = 0;
        }
 
        tdcRes = sqrt(tdcRes_charge*tdcRes_charge+tdcRes_const*tdcRes_const)/1000; //ns
 
        tdc_sphi = G4RandGauss::shoot(tdc_sphi, tdcRes);
        tdc_xphi = G4RandGauss::shoot(tdc_xphi, tdcRes);
 
        if(m_charge2Time_flag==0)
        {
            adc = charge2Time(stripStruct[i].charge*1000); //ns, charge in fC
        }
        else if(m_charge2Time_flag==1)
        {
            adc = charge2Time1(stripStruct[i].charge*1000);
        }
 
        double adcRes_charge;       
        if(m_calAdcRes_charge_flag==0)
        {
            adcRes_charge = calAdcRes_charge(stripStruct[i].charge*1000); //ps, charge in fC
        }
        else if(m_calAdcRes_charge_flag==1)
        {
            adcRes_charge = calAdcRes_charge1(stripStruct[i].charge*1000);
        }
        else if(m_calAdcRes_charge_flag==2)
        {
            adcRes_charge = 0;
        }
 
        adcRes = sqrt(adcRes_charge*adcRes_charge+adcRes_const*adcRes_const)/1000;
        adc = G4RandGauss::shoot(adc, adcRes);
        if(adc<0) adc=0;
 
        time_leading_sphi = tdc_sphi;
        time_leading_xphi = tdc_xphi;
        time_trailing_sphi = tdc_sphi+adc;
        time_trailing_xphi = tdc_xphi+adc;
 
 
        //save digi information
        BesTofDigi *digi = new BesTofDigi;
        digi->SetTrackIndex(stripStruct[i].trkIndex);
        digi->SetPartId(partId);
        digi->SetModule(module);
        digi->SetStrip(stripStruct[i].strip);
        int mo = (partId-3)*36+module;
        int st = stripStruct[i].strip;
        if(m_param.deadChannel[mo][st]==0 || m_param.deadChannel[mo][st]==2)
        {
            //Set dead channel
            digi->SetForwT1(-999);
            digi->SetForwT2(-999);
        }
        else
        {
            digi->SetForwT1(time_leading_sphi);
            digi->SetForwT2(time_trailing_sphi);
        }
        if(m_param.deadChannel[mo][st]==1 || m_param.deadChannel[mo][st]==2)
        {
            digi->SetBackT1(-999);
            digi->SetBackT2(-999);
        }
        else
        {
            digi->SetBackT1(time_leading_xphi);
            digi->SetBackT2(time_trailing_xphi);
        }
        m_besTofDigitsCollection->insert(digi);
        //cout<<"Print digi info: "
        //    <<"  partId= "<<partId
        //    <<"  module= "<<module
        //    <<"  strip= "<<stripStruct[i].strip
        //    <<"  time_leading_sphi= "<<time_leading_sphi
        //    <<"  time_leading_xphi= "<<time_leading_xphi
        //    <<"  time_trailing_sphi= "<<time_trailing_sphi
        //    <<"  time_trailing_xphi= "<<time_trailing_xphi
        //    <<endl;
 
 
        //save digi information
        if(m_rootFlag)
        {
            m_partId = partId;
            m_module = module;
            m_time_leading_sphi = time_leading_sphi;
            m_time_leading_xphi = time_leading_xphi;
            m_time_trailing_sphi = time_trailing_sphi;
            m_time_trailing_xphi = time_trailing_xphi;
            m_tdcRes = tdcRes;
            m_tdcRes_charge = tdcRes_charge;
            m_adc = adc;
            m_adcRes = adcRes;
            m_adcRes_charge = adcRes_charge;
 
            m_strip = stripStruct[i].strip;
            m_trkIndex = stripStruct[i].trkIndex;
            m_tStart = stripStruct[i].tStart;
            m_tPropagate_sphi = stripStruct[i].tPropagate_sphi;
            m_tPropagate_xphi = stripStruct[i].tPropagate_xphi;
            m_tThreshold = stripStruct[i].tThreshold;
            m_charge = stripStruct[i].charge;
 
            m_nhit = stripStruct[i].hitStructCol.size();
            //cout<<"m_nhit= "<<m_nhit<<endl;
            for(int j=0; j<m_nhit; j++)
            {
                m_ions_hit[j] = stripStruct[i].hitStructCol[j].ions;
                m_trkIndex_hit[j] = stripStruct[i].hitStructCol[j].trkIndex;
                m_pdgCode_hit[j] = stripStruct[i].hitStructCol[j].pdgCode;
                m_gap_hit[j] = stripStruct[i].hitStructCol[j].gap;
                m_underStrip_hit[j] = stripStruct[i].hitStructCol[j].underStrip;
                m_locx_hit[j] = stripStruct[i].hitStructCol[j].locx;
                m_locy_hit[j] = stripStruct[i].hitStructCol[j].locy;
                m_locz_hit[j] = stripStruct[i].hitStructCol[j].locz;
                m_x_hit[j] = stripStruct[i].hitStructCol[j].x;
                m_y_hit[j] = stripStruct[i].hitStructCol[j].y;
                m_z_hit[j] = stripStruct[i].hitStructCol[j].z;
                m_px_hit[j] = stripStruct[i].hitStructCol[j].px;
                m_py_hit[j] = stripStruct[i].hitStructCol[j].py;
                m_pz_hit[j] = stripStruct[i].hitStructCol[j].pz;
            }
            m_tree->Fill();
        }
    }
}

initial()

void BesTofDigitizerEcV4::initial

(

)

Definition at line 108 of file BesTofDigitizerEcV4.cc.

{
    m_param = Param();
    m_param.setPar(m_nstep, m_E_weight, m_V);
    m_param.print();
    m_event=-1;
    partId = -999;
    module = -999;
    tdc_sphi = -999;
    tdc_xphi = -999;
    if(tdcRes_const<0) tdcRes_const = 38;
      //45; //sqrt(27*27.+30.*30+20.*20); //ps, 27:TDC; 30:gapNb; 20:cables..
    tdcRes = -999;
 
    adc = -999;
    if(adcRes_const<0) adcRes_const = 27; //ps TDC
    adcRes = -999;
 
    time_leading_sphi = -999;
    time_leading_xphi = -999;
    time_trailing_sphi = -999;
    time_trailing_xphi = -999;
 
    cout<<"Property:"<<endl
        <<"  FileName= "<<m_fileName
        <<"  E= "<<m_V
        <<"  Threshold= "<<m_threshold
        <<"  nstep= "<<m_nstep
        <<"  E_weight= "<<m_E_weight
        <<"  saturationFlag= "<<m_saturationFlag
        <<"  tdcRes_const= "<<tdcRes_const
        <<"  adcRes_const= "<<adcRes_const
        <<"  calTdcRes_charge_flag= "<<m_calTdcRes_charge_flag
        <<"  charge2Time_flag= "<<m_charge2Time_flag
        <<"  calAdcRes_charge_flag= "<<m_calAdcRes_charge_flag
        <<endl;
}

Referenced by BesTofDigitizerEcV4(), BesTofDigitizerEcV4::HitStruct::HitStruct(), and BesTofDigitizerEcV4::StripStruct::StripStruct().

underStrip()

bool BesTofDigitizerEcV4::underStrip	(	double	locX,
		double	locZ )

Definition at line 387 of file BesTofDigitizerEcV4.cc.

{
    bool flag = 0;
    int strip=-1;
    double stripWidth = m_param.strip_z+m_param.strip_gap; //Strip spread: (24+3)mm
    int nstrip = m_param.nstrip;
    //the offset between strip coordinate and gas SD: 0.5
    double length = locZ+stripWidth*nstrip/2-0.5;
    if(length<stripWidth*nstrip)
    {
        for(int i=0; i<nstrip; i++)
        {
            if(length>i*stripWidth && length<(i+1)*stripWidth)
            {
                strip = i;
                if(length>i*stripWidth+m_param.strip_gap/2 && length<(i+1)*stripWidth-m_param.strip_gap/2
                            && locX>-m_param.strip_x[strip]/2 && locX<m_param.strip_x[strip]/2) flag=1;
                break;
            }
        }
    }
 
    return flag;
}

Referenced by Digitize().

---

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

• BesTofDigitizerEcV4.hh
• BesTofDigitizerEcV4.cc