CgemSimCheck Class Reference

#include <CgemSimCheck.h>

Inheritance diagram for CgemSimCheck:

Public Member Functions
	CgemSimCheck (const std::string &name, ISvcLocator *pSvcLocator)
	~CgemSimCheck ()
StatusCode	initialize ()
StatusCode	execute ()
StatusCode	finalize ()
StatusCode	beginRun ()

Detailed Description

Definition at line 42 of file CgemSimCheck.h.

Constructor & Destructor Documentation

CgemSimCheck()

CgemSimCheck::CgemSimCheck	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 58 of file CgemSimCheck.cxx.

                                                                          :
    Algorithm(name, pSvcLocator)
{
    m_F_McTruth = 1;
    m_F_Digi    = 1;
    m_F_McParticle=1;     
 
    declareProperty("PostFix", m_postfix = "");
 
    /* Save McTruth information to compare with  Root RawData Information */
    if (m_F_McTruth == 1)
    {
        cout << "INFO : CgemSimCheck::CgemSimCheck(), McTruth Hit will be output to a txt file!" 
            << endl;
 
        // string outputFile1 = getenv("CGEMSIMCHECKROOT");
        string outputFile1 = "output_McTruth.txt";
        cout<<"output_McTruth : "<<outputFile1<<endl;
 
        // m_output_McTruth.open(outputFile1.c_str(), ios::out | ios::app);
        m_output_McTruth.open(outputFile1.c_str(), ios::out );
 
        if (!m_output_McTruth.good())
        {
            cout << "ERROR : CgemSimCheck::CgemSimCheck(), Fail to open McTruth output file: "
                << outputFile1 << endl;
            return ;
        }
 
    } /* End of 'if (m_F_McTruth == 1)' */
 
    /* Save Digi information to compare with  Root RawData Information */
    if (m_F_Digi == 1)
    {
        cout << "INFO : CgemSimCheck::CgemSimCheck(), Digi Hit will be output to a txt file!" 
            << endl;
 
       // string outputFile2 = getenv("CGEMSIMCHECKROOT");
        string outputFile2 = "output_Digi.txt";
        cout<<"Digi file : "<<outputFile2<<endl;
        //  m_output_Digi.open(outputFile2.c_str(), ios::out | ios::app);
        m_output_Digi.open(outputFile2.c_str(), ios::out );
 
        if (!m_output_Digi.good())
        {
            cout << "ERROR : CgemSimCheck::CgemSimCheck(), Fail to open Digi output file: "
                << outputFile2 << endl;
            return ;
        }
 
    } /* End of 'if (m_F_Digi == 1)' */
 
    if (m_F_McParticle == 1 )
    {
        cout << "INFO : CgemSimCheck::CgemSimCheck(), MCParticle will be output to a txt file!" 
            << endl;
 
       // string outputFile3 = getenv("CGEMSIMCHECKROOT");
       string outputFile3 = "output_McParticle.txt";
        cout<<"Digi file : "<<outputFile3<<endl;
        //  m_output_Digi.open(outputFile2.c_str(), ios::out | ios::app);
        m_output_McParticle.open(outputFile3.c_str(), ios::out );
 
        if (!m_output_McParticle.good())
        {
            cout << "ERROR : CgemSimCheck::CgemSimCheck(), Fail to open McParticle output file: "
                << outputFile3 << endl;
            return ;
        }
 
    } /* End of 'if (m_F_McParticle == 1)' */
}

~CgemSimCheck()

CgemSimCheck::~CgemSimCheck

(

)

Definition at line 132 of file CgemSimCheck.cxx.

{
    m_output_McTruth.close();
    m_output_Digi.close();
}

Member Function Documentation

beginRun()

StatusCode CgemSimCheck::beginRun

(

)

Definition at line 139 of file CgemSimCheck.cxx.

{
    MsgStream log(msgSvc(), name());
    log << MSG::INFO << "in beginRun()" << endreq;
    return StatusCode::SUCCESS;
}

execute()

StatusCode CgemSimCheck::execute

(

)

Definition at line 257 of file CgemSimCheck.cxx.

{
    MsgStream log(msgSvc(), name());
    log << MSG::INFO << "in execute()" << endreq;
 
    SmartDataPtr<Event::EventHeader> eventHeader(eventSvc(),"/Event/EventHeader");
    if (!eventHeader) 
    {
        log << MSG::FATAL << "Could not find Event Header" << endreq;
        return StatusCode::FAILURE;
    }
 
    cout << "" << endl;
    cout << "Event: " << eventHeader->eventNumber() << endl;
    int iEvt = eventHeader->eventNumber();
    int iRun = eventHeader->runNumber();
 
    m_run = iRun;
    m_evt = iEvt;
    cout<<" Run : "<<m_run<<"Event : "<<m_evt<<endl;
    /* Get McTruth information */
    if (m_F_McTruth == 1)
    {
        SmartDataPtr<Event::CgemMcHitCol> lv_CgemMcHitCol(eventSvc(), "/Event/MC/CgemMcHitCol");
        if (!lv_CgemMcHitCol) 
        {
            log << MSG::WARNING << "Could not find event" << endreq;
            return StatusCode::FAILURE;
        }    
 
        Event::CgemMcHitCol::iterator iter_truth = lv_CgemMcHitCol->begin();
        int i=0;
        for(; iter_truth != lv_CgemMcHitCol->end(); ++iter_truth) 
        {
            m_output_McTruth << left << setw( 5) << (*iter_truth)->GetTrackID()                 
                << left << setw( 3) << (*iter_truth)->GetLayerID()                 
                << left << setw(12) << (*iter_truth)->GetTotalEnergyDeposit()      
                << left << setw(12) << (*iter_truth)->GetPositionXOfPrePoint()  
                << left << setw(12) << (*iter_truth)->GetPositionYOfPrePoint()  
                << left << setw(12) << (*iter_truth)->GetPositionZOfPrePoint()  
                << left << setw(12) << (*iter_truth)->GetPositionXOfPostPoint() 
                << left << setw(12) << (*iter_truth)->GetPositionYOfPostPoint() 
                << left << setw(12) << (*iter_truth)->GetPositionZOfPostPoint() 
                << left << setw(12) << (*iter_truth)->GetMomentumXOfPrePoint()  
                << left << setw(12) << (*iter_truth)->GetMomentumYOfPrePoint()  
                << left << setw(12) << (*iter_truth)->GetMomentumZOfPrePoint()  
                << left << setw(12) << (*iter_truth)->GetMomentumXOfPostPoint() 
                << left << setw(12) << (*iter_truth)->GetMomentumYOfPostPoint() 
                << left << setw(12) << (*iter_truth)->GetMomentumZOfPostPoint()
                << endl;
 
 
            m_mc_ID_track[i]=(*iter_truth)->GetTrackID();
            m_mc_ID_layer[i]=(*iter_truth)->GetLayerID();
            m_mc_E_deposit[i]=(*iter_truth)->GetTotalEnergyDeposit();
            m_mc_XYZ_pre_X[i] =(*iter_truth)->GetPositionXOfPrePoint() ;    
            m_mc_XYZ_pre_Y[i] =(*iter_truth)->GetPositionYOfPrePoint() ;
            m_mc_XYZ_pre_Z[i] =(*iter_truth)->GetPositionZOfPrePoint() ;
            m_mc_XYZ_post_X[i]=(*iter_truth)->GetPositionXOfPostPoint();
            m_mc_XYZ_post_Y[i]=(*iter_truth)->GetPositionYOfPostPoint();
            m_mc_XYZ_post_Z[i]=(*iter_truth)->GetPositionZOfPostPoint();
            m_mc_P_pre_X[i]=(*iter_truth)->GetMomentumXOfPrePoint() ;
            m_mc_P_pre_Y[i]=(*iter_truth)->GetMomentumYOfPrePoint() ;
            m_mc_P_pre_Z[i]=(*iter_truth)->GetMomentumZOfPrePoint() ;
            m_mc_P_post_X[i]=(*iter_truth)->GetMomentumXOfPostPoint();
            m_mc_P_post_Y[i]=(*iter_truth)->GetMomentumYOfPostPoint();
            m_mc_P_post_Z[i]=(*iter_truth)->GetMomentumZOfPostPoint();
            i++;
        }
 
        m_mc_nHit=i;
        cout<<" mc_Hit "<<m_mc_nHit<<endl;
        mc_tuple->write();
    } /* End of 'if (m_F_McTruth == 1)' */
 
    /* Get Digi information */
    if (m_F_Digi == 1)
    {
        SmartDataPtr<CgemDigiCol> lv_CgemDigiCol(eventSvc(),"/Event/Digi/CgemDigiCol");
 
        if ( !lv_CgemDigiCol ) 
        {
            log << MSG::WARNING << "Could not find event" << endreq;
            return StatusCode::FAILURE;
        }
 
        CgemDigiCol::iterator iter_digi = lv_CgemDigiCol->begin();
        CgemID *cgemid=new CgemID();
        int j = 0,x_flag;
        int m_X=0,m_V=0;
        bool xflag;
        for( ; iter_digi != lv_CgemDigiCol->end(); ++iter_digi) 
        {
            x_flag = 0;
            m_output_Digi << left << setw( 8) << (*iter_digi)->getTrackIndex()
                << left << setw( 8) << CgemID::layer((*iter_digi)->identify())
                << left << setw( 8) << CgemID::sheet((*iter_digi)->identify())
                << left << setw( 8) << CgemID::strip((*iter_digi)->identify())
                << left << setw(16) << (*iter_digi)->getTimeChannel()
                << left << setw(16) << (*iter_digi)->getChargeChannel()
                << endl;
            xflag=cgemid->is_xstrip((*iter_digi)->identify());
            //      if (xflag){
            //          x_flag=1;
            //      m_X_ID_strip[j]=CgemID::strip((*iter_digi)->identify());
            //      }
            //      else{
            //      m_V_ID_strip[j]=CgemID::strip((*iter_digi)->identify());
            //      }
            //         cout<<"X_Flag : "<<x_flag<<endl;
            m_ID_track[j]=(*iter_digi)->getTrackIndex();
            m_ID_layer[j]=CgemID::layer((*iter_digi)->identify());
            m_ID_sheet[j]=CgemID::sheet((*iter_digi)->identify());
            m_ID_strip[j]=CgemID::strip((*iter_digi)->identify());
            m_globle_time[j]= (*iter_digi)->getTimeChannel();
            m_E_deposit[j]= (*iter_digi)->getChargeChannel();  
            j++;
            if (xflag){
                m_E_X[m_X]=(*iter_digi)->getChargeChannel();
                m_X++;
            }
            else{
                m_E_V[m_V]=(*iter_digi)->getChargeChannel();
                m_V++;
            }
 
        }
        m_nHit=j;
        m_Xnstrip=m_X;
        m_Vnstrip=m_V;
        // cout<<"Hit : "<<m_nHit<<endl;
        // cout<<"Xnsrtip : "<<m_Xnstrip<<endl;
        // cout<<"Vnsrtip : "<<m_Vnstrip<<endl;
        m_tuple->write();
    } /* End of 'if(m_F_Digi == 1)' */
 
    if (m_F_McParticle == 1 )
    {
        SmartDataPtr<Event::McParticleCol> mcParticleCol(eventSvc(),"/Event/MC/McParticleCol");
        if (!mcParticleCol)
        {
            cout<< "Could not retrieve McParticelCol" << endl;
        }
 
        Event::McParticleCol::iterator iter_mcP = mcParticleCol->begin();
        int ii=0;
        for (; iter_mcP != mcParticleCol->end(); iter_mcP++)
        {
            m_trkindex[ii]=(*iter_mcP)->trackIndex();
            m_mcParticle_x[ii]=((*iter_mcP)->initialPosition()).x();
            m_mcParticle_y[ii]=((*iter_mcP)->initialPosition()).y();
            m_mcParticle_z[ii]=((*iter_mcP)->initialPosition()).z();
            m_mcParticle_px[ii]=((*iter_mcP)->initialFourMomentum()).x();
            m_mcParticle_py[ii]=((*iter_mcP)->initialFourMomentum()).y();
            m_mcParticle_pz[ii]=((*iter_mcP)->initialFourMomentum()).z();
            m_mcParticle_E[ii]=((*iter_mcP)->initialFourMomentum()).e();
            m_mcParticle_phi[ii]=((*iter_mcP)->initialFourMomentum()).phi();
            m_mcParticle_costheta[ii]=((*iter_mcP)->initialFourMomentum()).cosTheta();
            m_mcParticle_theta[ii]=((*iter_mcP)->initialFourMomentum()).theta();
            m_mcParticle_pt[ii]=(((*iter_mcP)->initialFourMomentum()).mag())*sin(m_mcParticle_theta[ii]);
            // cout<<(*iter_mcP)->trackIndex()<<endl;
            m_output_McParticle << left << setw( 8) << (*iter_mcP)->trackIndex()
                <<left<<setw(10)<<((*iter_mcP)->initialPosition()).x()
                <<left<<setw(10)<<((*iter_mcP)->initialPosition()).y()
                <<left<<setw(10)<<((*iter_mcP)->initialPosition()).z()
                <<left<<setw(10)<<((*iter_mcP)->initialFourMomentum()).px()
                <<left<<setw(10)<<((*iter_mcP)->initialFourMomentum()).py()
                <<left<<setw(12)<<((*iter_mcP)->initialFourMomentum()).pz()
                <<left<<setw(12)<<((*iter_mcP)->initialFourMomentum()).e()
                <<left<<setw(12)<<((*iter_mcP)->initialFourMomentum()).phi()
                <<left<<setw(12)<<((*iter_mcP)->initialFourMomentum()).cosTheta()
                <<left<<setw(12)<<((*iter_mcP)->initialFourMomentum()).theta()
                <<left<<setw(12)<<m_mcParticle_pt[ii]
                <<endl;
            //  if (m_evt == 83){
            ofstream outoneevt("evtput.txt",ios::app);
 
            outoneevt<<left<<setw(7)<<m_evt
                //  <<left<<setw(6)<<m_ID_track
                //  <<left<<setw(6)<<m_ID_layer<<
                <<left << setw( 5) << (*iter_mcP)->trackIndex()
                <<left<<setw(10)<<((*iter_mcP)->initialPosition()).x()
                <<left<<setw(10)<<((*iter_mcP)->initialPosition()).y()
                <<left<<setw(10)<<((*iter_mcP)->initialPosition()).z()
                <<left<<setw(10)<<((*iter_mcP)->initialFourMomentum()).px()
                <<left<<setw(10)<<((*iter_mcP)->initialFourMomentum()).py()
                <<left<<setw(12)<<((*iter_mcP)->initialFourMomentum()).pz()
                <<left<<setw(12)<<((*iter_mcP)->initialFourMomentum()).e()
                <<left<<setw(12)<<((*iter_mcP)->initialFourMomentum()).phi()
                <<left<<setw(12)<<((*iter_mcP)->initialFourMomentum()).cosTheta()
                <<left<<setw(12)<<((*iter_mcP)->initialFourMomentum()).theta()
                <<left<<setw(12)<<m_mcParticle_pt[ii]
                <<endl;
            outoneevt.close();
            //   }
            ii++;
        }
        Nparticle=ii;
        mcP_tuple->write();
    }
    return StatusCode::SUCCESS;
}

finalize()

StatusCode CgemSimCheck::finalize

(

)

Definition at line 461 of file CgemSimCheck.cxx.

{
    MsgStream log(msgSvc(), name());
    log << MSG::INFO << "in finalize()" << endreq;
 
    return StatusCode::SUCCESS;
}

initialize()

StatusCode CgemSimCheck::initialize

(

)

Definition at line 147 of file CgemSimCheck.cxx.

{
    MsgStream log(msgSvc(), name());
    log << MSG::INFO << "in initialize()" << endreq;
 
    StatusCode sc;
    ICgemGeomSvc* ISvcCgem;
    sc = service("CgemGeomSvc", ISvcCgem);
    if(sc != StatusCode::SUCCESS)
    {
        log << MSG::ERROR << "can not use CgemGeomSvc" << endreq;
        return StatusCode::FAILURE;
    }
 
    //  ofstream outoneevt("evtput.txt"); 
 
    int postfixlen = m_postfix.length();
    char *foldername = (char *)malloc((postfixlen + 6) * sizeof(char));
 
    INTupleSvc* ntupleSvc;
    sc = service("NTupleSvc", ntupleSvc);
 
    free(foldername);
    foldername = (char *)malloc((postfixlen + 12) * sizeof(char));
    sprintf(foldername, "FILE135/Digi%s", m_postfix.c_str());
    NTuplePtr nt(ntupleSvc, foldername);
    if ( nt ) m_tuple = nt;
    else{
        m_tuple = ntupleSvc->book(foldername, CLID_ColumnWiseTuple, "mdcTrack");
        if(m_tuple){
            m_tuple->addItem("run", m_run);
            m_tuple->addItem("evt", m_evt);
            m_tuple->addItem("nhit", m_nHit, 0, 100000); 
            m_tuple->addItem("X_nstrip", m_Xnstrip,0,30000); 
            m_tuple->addItem("V_nstrip", m_Vnstrip,0,30000); 
 
            m_tuple->addIndexedItem("hittrackID",m_nHit, m_ID_track);
            m_tuple->addIndexedItem("CgemlayerID",m_nHit, m_ID_layer);
            m_tuple->addIndexedItem("Readout_sheetID", m_nHit,m_ID_sheet);
            //    m_tuple->addIndexedItem("X_stripID", m_nHit,m_X_ID_strip);
            //    m_tuple->addIndexedItem("V_stripID", m_nHit,m_V_ID_strip);
            m_tuple->addIndexedItem("Read_stripID", m_nHit,m_ID_strip);
            m_tuple->addIndexedItem("Deposit_Energy", m_nHit,m_E_deposit);
            m_tuple->addIndexedItem("Ex", m_Xnstrip,m_E_X);
            m_tuple->addIndexedItem("Ev", m_Vnstrip,m_E_V);
            m_tuple->addIndexedItem("Globletime", m_nHit,m_globle_time);
        }
    }
 
 
    free(foldername);
    foldername = (char *)malloc((postfixlen + 12) * sizeof(char));
    sprintf(foldername, "FILE135/McTruth%s", m_postfix.c_str());
    NTuplePtr nt1(ntupleSvc, foldername);
    if ( nt1 ) mc_tuple = nt1;
    else{
        mc_tuple = ntupleSvc->book(foldername, CLID_ColumnWiseTuple, "mdcTrack");
        if(mc_tuple){
            // mc_tuple->addItem("run", m_run);
            // mc_tuple->addItem("evt", m_evt);
            mc_tuple->addItem("MC_nhit", m_mc_nHit, 0, 100); 
 
            mc_tuple->addIndexedItem("hittrackID",m_mc_nHit,  m_mc_ID_track);
            mc_tuple->addIndexedItem("CgemlayerID",m_mc_nHit, m_mc_ID_layer);
            mc_tuple->addIndexedItem("Deposit_Energy", m_mc_nHit,m_mc_E_deposit);
            mc_tuple->addIndexedItem("X_pre_point",   m_mc_nHit, m_mc_XYZ_pre_X );
            mc_tuple->addIndexedItem("Y_pre_point",   m_mc_nHit, m_mc_XYZ_pre_Y );
            mc_tuple->addIndexedItem("Z_pre_point",   m_mc_nHit, m_mc_XYZ_pre_Z );
            mc_tuple->addIndexedItem("X_post_point",  m_mc_nHit, m_mc_XYZ_post_X );
            mc_tuple->addIndexedItem("Y_post_point",  m_mc_nHit, m_mc_XYZ_post_Y );
            mc_tuple->addIndexedItem("Z_post_point",  m_mc_nHit, m_mc_XYZ_post_Z );
            mc_tuple->addIndexedItem("P_X_pre_point", m_mc_nHit, m_mc_P_pre_X);
            mc_tuple->addIndexedItem("P_Y_pre_point", m_mc_nHit, m_mc_P_pre_Y);
            mc_tuple->addIndexedItem("P_Z_pre_point", m_mc_nHit, m_mc_P_pre_Z);
            mc_tuple->addIndexedItem("P_X_post_point",m_mc_nHit, m_mc_P_post_X);
            mc_tuple->addIndexedItem("P_Y_post_point",m_mc_nHit, m_mc_P_post_Y);
            mc_tuple->addIndexedItem("P_Z_post_point",m_mc_nHit, m_mc_P_post_Z);
        }
    }
 
    free(foldername);
    foldername = (char *)malloc((postfixlen + 12) * sizeof(char));
    sprintf(foldername, "FILE135/McPar%s", m_postfix.c_str());
    NTuplePtr nt2(ntupleSvc, foldername);
    if ( nt2 ) mcP_tuple = nt2;
    else{
        mcP_tuple = ntupleSvc->book(foldername, CLID_ColumnWiseTuple, "mdcTrack");
        if(mcP_tuple){
            // mcP_tuple->addItem("run", m_run);
            // mcP_tuple->addItem("evt", m_evt);
            mcP_tuple->addItem("nParticle", Nparticle, 0, 1000); 
 
            mcP_tuple->addIndexedItem("trkindex",    Nparticle,  m_trkindex);
            mcP_tuple->addIndexedItem("x",  Nparticle,  m_mcParticle_x);
            mcP_tuple->addIndexedItem("y",  Nparticle,  m_mcParticle_y);
            mcP_tuple->addIndexedItem("z",  Nparticle,  m_mcParticle_z);
            mcP_tuple->addIndexedItem("px", Nparticle,  m_mcParticle_px);
            mcP_tuple->addIndexedItem("py", Nparticle,  m_mcParticle_py);
            mcP_tuple->addIndexedItem("pz", Nparticle,  m_mcParticle_pz);
            mcP_tuple->addIndexedItem("E",  Nparticle,  m_mcParticle_E);
            mcP_tuple->addIndexedItem("phi",  Nparticle,  m_mcParticle_phi);
            mcP_tuple->addIndexedItem("costheta",  Nparticle,  m_mcParticle_costheta);
            mcP_tuple->addIndexedItem("theta",  Nparticle,  m_mcParticle_theta);
            mcP_tuple->addIndexedItem("pt",  Nparticle,  m_mcParticle_pt);
        }
    }
    return StatusCode::SUCCESS;
}

---

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

• CgemSimCheck.h
• CgemSimCheck.cxx