KalFitAlg Class Reference

#include <KalFitAlg.h>

Inheritance diagram for KalFitAlg:

Public Member Functions
Main member functions
	KalFitAlg (const std::string &name, ISvcLocator *pSvcLocator)
	constructor
	~KalFitAlg (void)
	destructor
StatusCode	initialize ()
	initialize
StatusCode	execute ()
	event function
StatusCode	finalize ()
StatusCode	beginRun ()
void	hist_def (void)
	hist definition
void	clean (void)
	KalFitAlg (const std::string &name, ISvcLocator *pSvcLocator)
	constructor
	~KalFitAlg (void)
	destructor
StatusCode	initialize ()
	initialize
StatusCode	execute ()
	event function
StatusCode	finalize ()
StatusCode	beginRun ()
void	hist_def (void)
	hist definition
void	clean (void)
Set up the description of the Mdc
void	set_Mdc (void)
	Set up the wires, layers and superlayers...
void	setMaterial_Mdc (void)
	Initialize the material for Mdc.
void	setCylinder_Mdc (void)
	Initialize the cylinders (walls and cathodes) for Mdc.
void	setDchisqCut (void)
void	setCalibSvc_init (void)
	initialize for the services
void	setGeomSvc_init (void)
void	setMagneticFieldSvc_init (void)
void	getEventStarTime (void)
void	set_Mdc (void)
	Set up the wires, layers and superlayers...
void	setMaterial_Mdc (void)
	Initialize the material for Mdc.
void	setCylinder_Mdc (void)
	Initialize the cylinders (walls and cathodes) for Mdc.
void	setDchisqCut (void)
void	setCalibSvc_init (void)
	initialize for the services
void	setGeomSvc_init (void)
void	setMagneticFieldSvc_init (void)
void	getEventStarTime (void)

Kalman filter method related member functions
int	usage_
int	choice_
int	pathl_
int	wsag_
	flag to take account the wire sag into account
int	back_
	flag to perform smoothing
int	eventno
int	Tds_back_no
double	pT_
	value of the pT cut for backward filter
int	lead_
	leading mass assumption
int	mhyp_
double	pe_cut_
	value of the momentum cut to decide refit
double	pmu_cut_
double	ppi_cut_
double	pk_cut_
double	pp_cut_
double	pt_cut_
double	theta_cut_
int	muls_
int	loss_
int	lr_
int	activeonly_
int	tofflag_
int	tof_hyp_
int	enhance_
	flag to enhance the error matrix at the inner hit of Mdc (cosmic)
double	fac_h1_
double	fac_h2_
double	fac_h3_
double	fac_h4_
double	fac_h5_
double	matrixg_
double	gain1_
double	gain2_
double	gain3_
double	gain4_
double	gain5_
int	steplev_
int	numfcor_
int	numf_
int	inner_steps_
int	outer_steps_
int	numf_in_
int	numf_out_
int	fitnocut_
int	drifttime_choice_
int	i_back_
	mass assumption for backward filter (if <0 means use leading mass)
int	i_front_
int	debug_
	Debug flag for the track finder part.
int	debug_kft_
int	ntuple_
	Fill ntuples of KalFit.
string	matfile_
string	cylfile_
double	dchi2cutf_
double	dchi2cuts_
double	dchi2cut_mid1_
double	dchi2cut_mid2_
double	dchi2cut_inner_
double	dchi2cut_outer_
double	dchi2cut_layid2_
double	dchi2cut_layid3_
double	fstrag_
	factor of energy loss straggling for electron
int	resolution_
int	iqual_front_ [5]
int	iqual_back_
int	tprop_
	propagation correction
int	eventNo
int	m_usevtxdb
int	m_csmflag
double	m_dangcut
double	m_dphicut
double	m_alpha
void	filter_fwd_anal (KalFitTrack &trk, int l_mass, int way, HepSymMatrix &Eakal)
	Kalman filter (forward) in Mdc.
void	filter_fwd_calib (KalFitTrack &trk, int l_mass, int way, HepSymMatrix &Eakal)
void	init_matrix (MdcRec_trk &trk, HepSymMatrix &Ea)
void	init_matrix (int k, MdcRec_trk &trk, HepSymMatrix &Ea)
void	start_seed (KalFitTrack &track, int lead_, int way, MdcRec_trk &trk)
void	smoother_anal (KalFitTrack &trk, int way)
	Kalman filter (smoothing or backward part)
void	smoother_calib (KalFitTrack &trk, int way)
void	innerwall (KalFitTrack &trk, int l_mass, int way)
	Take the inner walls (eloss and mult scat) into account.
void	innerwall (KalFitTrack &trk, int l_mass, int way, int begin, int end)
void	innerwall (KalFitTrack &track, int l_mass, int way, double r1, double r2, int &index)
void	fillTds (MdcRec_trk &TrasanTRK, KalFitTrack &track, RecMdcKalTrack *trk, int l_mass)
	with results got at the inner Mdc hit
void	fillTds_lead (MdcRec_trk &TrasanTRK, KalFitTrack &track, RecMdcKalTrack *trk, int l_mass)
void	fillTds_back (KalFitTrack &track, RecMdcKalTrack *trk, MdcRec_trk &TrasanTRK, int l_mass)
	with results got at the outer Mdc hit
void	fillTds_back (KalFitTrack &track, RecMdcKalTrack *trk, MdcRec_trk &TrasanTRK, int l_mass, RecMdcKalHelixSegCol *segcol)
void	fillTds_back (KalFitTrack &track, RecMdcKalTrack *trk, MdcRec_trk &TrasanTRK, int l_mass, RecMdcKalHelixSegCol *segcol, int smoothflag)
	for smoother process
void	fillTds_ip (MdcRec_trk &TrasanTRK, KalFitTrack &track, RecMdcKalTrack *trk, int l_mass)
	with results got at (0,0,0)
void	sameas (RecMdcKalTrack *trk, int l_mass, int imain)
	complete the RecMdcKalTrackCol
void	complete_track (MdcRec_trk &TrasanTRK, MdcRec_trk_add &TrasanTRK_add, KalFitTrack &track_lead, RecMdcKalTrack *kaltrk, RecMdcKalTrackCol *kalcol, RecMdcKalHelixSegCol *segcol, int flagsmooth)
void	complete_track (MdcRec_trk &TrasanTRK, MdcRec_trk_add &TrasanTRK_add, KalFitTrack &track_lead, RecMdcKalTrack *kaltrk, RecMdcKalTrackCol *kalcol, RecMdcKalHelixSegCol *segcol)
void	kalman_fitting_anal (void)
void	kalman_fitting_calib (void)
void	kalman_fitting_csmalign (void)
void	kalman_fitting_MdcxReco_Csmc_Sew (void)
void	clearTables ()
int	getWallMdcNumber (const HepPoint3D &point)
void	extToAnyPoint (KalFitTrack &trk, const HepPoint3D &point)
void	setBesFromGdml (void)
void	makeGemHitsCol ()
void	fromFHitToInnerWall (KalFitTrack &track, int way)
void	fitGemHits (KalFitTrack &track, int hypo, int way)
KalFitTrack	Cgem_filter_anal (KalFitTrack &track, int hypo, int way)
void	residual (KalFitTrack &track)
void	filter_fwd_anal (KalFitTrack &trk, int l_mass, int way, HepSymMatrix &Eakal)
	Kalman filter (forward) in Mdc.
void	filter_fwd_calib (KalFitTrack &trk, int l_mass, int way, HepSymMatrix &Eakal)
void	init_matrix (MdcRec_trk &trk, HepSymMatrix &Ea)
void	init_matrix (int k, MdcRec_trk &trk, HepSymMatrix &Ea)
void	start_seed (KalFitTrack &track, int lead_, int way, MdcRec_trk &trk)
void	smoother_anal (KalFitTrack &trk, int way)
	Kalman filter (smoothing or backward part)
void	smoother_calib (KalFitTrack &trk, int way)
void	innerwall (KalFitTrack &trk, int l_mass, int way)
	Take the inner walls (eloss and mult scat) into account.
void	innerwall (KalFitTrack &trk, int l_mass, int way, int begin, int end)
void	innerwall (KalFitTrack &track, int l_mass, int way, double r1, double r2, int &index)
void	fillTds (MdcRec_trk &TrasanTRK, KalFitTrack &track, RecMdcKalTrack *trk, int l_mass)
	with results got at the inner Mdc hit
void	fillTds_lead (MdcRec_trk &TrasanTRK, KalFitTrack &track, RecMdcKalTrack *trk, int l_mass)
void	fillTds_back (KalFitTrack &track, RecMdcKalTrack *trk, MdcRec_trk &TrasanTRK, int l_mass)
	with results got at the outer Mdc hit
void	fillTds_back (KalFitTrack &track, RecMdcKalTrack *trk, MdcRec_trk &TrasanTRK, int l_mass, RecMdcKalHelixSegCol *segcol)
void	fillTds_back (KalFitTrack &track, RecMdcKalTrack *trk, MdcRec_trk &TrasanTRK, int l_mass, RecMdcKalHelixSegCol *segcol, int smoothflag)
	for smoother process
void	fillTds_ip (MdcRec_trk &TrasanTRK, KalFitTrack &track, RecMdcKalTrack *trk, int l_mass)
	with results got at (0,0,0)
void	sameas (RecMdcKalTrack *trk, int l_mass, int imain)
	complete the RecMdcKalTrackCol
void	complete_track (MdcRec_trk &TrasanTRK, MdcRec_trk_add &TrasanTRK_add, KalFitTrack &track_lead, RecMdcKalTrack *kaltrk, RecMdcKalTrackCol *kalcol, RecMdcKalHelixSegCol *segcol, int flagsmooth)
void	complete_track (MdcRec_trk &TrasanTRK, MdcRec_trk_add &TrasanTRK_add, KalFitTrack &track_lead, RecMdcKalTrack *kaltrk, RecMdcKalTrackCol *kalcol, RecMdcKalHelixSegCol *segcol)
void	kalman_fitting_anal (void)
void	kalman_fitting_calib (void)
void	kalman_fitting_csmalign (void)
void	kalman_fitting_MdcxReco_Csmc_Sew (void)
void	clearTables ()
int	getWallMdcNumber (const HepPoint3D &point)
void	extToAnyPoint (KalFitTrack &trk, const HepPoint3D &point)
void	setBesFromGdml (void)
void	makeGemHitsCol ()
void	fromFHitToInnerWall (KalFitTrack &track, int way)
void	fitGemHits (KalFitTrack &track, int hypo, int way)
KalFitTrack	Cgem_filter_anal (KalFitTrack &track, int hypo, int way)
void	residual (KalFitTrack &track)

Detailed Description

Definition at line 61 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Constructor & Destructor Documentation

KalFitAlg() [1/2]

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

constructor

Constructor.

Definition at line 99 of file KalFitAlg.cxx.

                                                                   :
    Algorithm(name, pSvcLocator), m_mdcCalibFunSvc_(0),m_MFSvc_(0),
    _wire(0), _layer(0), _superLayer(0),
    pathl_(1), wsag_(4), back_(1), pT_(0.0), lead_(2), mhyp_(31),
    pe_cut_(2.0), pmu_cut_(2.0), ppi_cut_(2.0), pk_cut_(2.0), pp_cut_(2.0),   
    muls_(1), loss_(1), enhance_(0),drifttime_choice_(0),choice_(0),
    fac_h1_(1),fac_h2_(1),fac_h3_(1),fac_h4_(1),fac_h5_(1),
    i_back_(-1), debug_kft_(0), debug_(0), ntuple_(0),eventno(-1),
    Tds_back_no(0),m_nt1(0),m_nt2(0),m_nt3(0),m_nt4(0),m_nt5(0),
    iqual_back_(1),tprop_(1),
    dchi2cut_inner_(0),dchi2cut_outer_(0),
    dchi2cut_mid1_(0),dchi2cut_mid2_(0),
    dchi2cut_layid2_(0),dchi2cut_layid3_(0),m_usevtxdb(0),m_dangcut(10),m_dphicut(10),
    nTotalTrks(0)
{
    declareProperty("dchi2cut_layid2",dchi2cut_layid2_ = 10);
    declareProperty("dchi2cut_layid3",dchi2cut_layid3_ = 10);
    declareProperty("dchi2cut_inner",dchi2cut_inner_ = 10);
    declareProperty("dchi2cut_mid1",dchi2cut_mid1_ = 10);
    declareProperty("dchi2cut_mid2",dchi2cut_mid2_ = 10);
    declareProperty("dchi2cut_outer",dchi2cut_outer_ = 10);
    declareProperty("gain1",gain1_ = 1.);
    declareProperty("gain2",gain2_ = 1.);
    declareProperty("gain3",gain3_ = 1.);
    declareProperty("gain4",gain4_ = 1.);
    declareProperty("gain5",gain5_ = 1.);
    declareProperty("fitnocut",fitnocut_ = 5);
    declareProperty("inner_steps",inner_steps_ = 3);
    declareProperty("outer_steps",outer_steps_ = 3);
    declareProperty("choice",choice_ = 0);
    declareProperty("numfcor",numfcor_ = 0);
    declareProperty("numf",numf_ = 0);
    declareProperty("steplev",steplev_ = 2);
    declareProperty("usage",usage_=0);
    declareProperty("i_front",i_front_=1);
    declareProperty("lead",lead_=2);
    declareProperty("muls",muls_=1);
    declareProperty("loss",loss_=1);
    declareProperty("matrixg",matrixg_=100.0);
    declareProperty("lr",lr_=1);  
    declareProperty("debug_kft",debug_kft_=0);
    declareProperty("debug",debug_=0);  
    declareProperty("ntuple",ntuple_=0);  
    declareProperty("activeonly",activeonly_=0);  
    declareProperty("matfile",matfile_="geomdc_material.dat"); 
    declareProperty("cylfile",cylfile_="geomdc_cylinder.dat"); 
    declareProperty("dchi2cutf",dchi2cutf_=1000.0);
    declareProperty("dchi2cuts",dchi2cuts_=1000.0);
    declareProperty("pt",pT_=0.0);
    declareProperty("pe_cut",pe_cut_=2.0);
    declareProperty("pmu_cut",pmu_cut_=2.0);
    declareProperty("ppi_cut",ppi_cut_=2.0);
    declareProperty("pk_cut",pk_cut_=2.0);
    declareProperty("pp_cut",pp_cut_=2.0); 
    declareProperty("wsag",wsag_=4);
    declareProperty("back",back_=1);
    declareProperty("i_back",i_back_=1);
    declareProperty("tofflag",tofflag_=1);
    declareProperty("tof_hyp",tof_hyp_=1);
    declareProperty("resolution",resolution_=1);
    declareProperty("fstrag",fstrag_=0.9);
    declareProperty("drifttime_choice",drifttime_choice_=0);
    declareProperty("tprop",tprop_=1);
    declareProperty("pt_cut",pt_cut_= 0.2);
    declareProperty("theta_cut",theta_cut_= 0.8);
    declareProperty("usevtxdb",m_usevtxdb= 0);
    declareProperty("cosmicflag",m_csmflag= 0);
    declareProperty("dangcut",m_dangcut=10.);
    declareProperty("dphicut",m_dphicut=10.);
    declareProperty("useNCGem",useNCGem_=0);
    declareProperty("nInnerCFiber",nInnerCFiber_=0);
    declareProperty("SigRphiGem",myRphiResGem=0.033);
    declareProperty("SigZGem",   myZResGem=0.04);
    declareProperty("UseGemPos3D", myUseGemPos3D=false);
    declareProperty("testCDC", testCDC=0);
    declareProperty("ifProdNt10", ifProdNt10=false);
    declareProperty("ifProdNt11", ifProdNt11=false);
    declareProperty("ifProdNt12", ifProdNt12=false);
 
    for(int i=0; i<5; i++) nFailedTrks[i]=0;
}

~KalFitAlg() [1/2]

KalFitAlg::~KalFitAlg

(

void

)

destructor

Definition at line 182 of file KalFitAlg.cxx.

{
    MsgStream log(msgSvc(), name());
    log << MSG::INFO <<" Start cleaning, delete  Mdc geometry objects" << endreq;
    clean();
    log << MSG::INFO << "End cleaning " << endreq;
}

KalFitAlg() [2/2]

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

constructor

~KalFitAlg() [2/2]

KalFitAlg::~KalFitAlg

(

void

)

destructor

Member Function Documentation

beginRun() [1/2]

StatusCode KalFitAlg::beginRun

(

)

Definition at line 333 of file KalFitAlg.cxx.

{
    MsgStream log(msgSvc(), name());  
    log << MSG::INFO << "in beginRun()" << endreq;
    log << MSG::INFO << "Present Parameters: muls: " << muls_ <<"  loss:  "
        << " activeonly "<< activeonly_ << endreq;
 
    // initialize the MdcGeomSvc
    setGeomSvc_init();
    // Wires, Layers and SuperLayers of Mdc :
    set_Mdc();
 
    IMagneticFieldSvc* IMFSvc;
    StatusCode sc = service ("MagneticFieldSvc",IMFSvc);
    if(sc!=StatusCode::SUCCESS) {
        log << MSG::ERROR << "Unable to open Magnetic field service"<<endreq;
    }
 
    // Nominal magnetic field :
    if (KalFitTrack::numfcor_){
        KalFitTrack::Bznom_ = (IMFSvc->getReferField())*10000; //unit is KGauss
        if(0 == KalFitTrack::Bznom_)   KalFitTrack::Bznom_ = -10;
 
        if(4 == debug_){  
            std::cout<<" beginRun, referField from MagneticFieldSvc:"<< (IMFSvc->getReferField())*10000 <<std::endl;
            std::cout<<" magnetic field: "<<KalFitTrack::Bznom_<<std::endl;
        }
    }
 
    return StatusCode::SUCCESS;  
}

beginRun() [2/2]

StatusCode KalFitAlg::beginRun

(

)

Cgem_filter_anal() [1/2]

KalFitTrack KalFitAlg::Cgem_filter_anal	(	KalFitTrack &	track,
		int	hypo,
		int	way
	)

—readin clusters of this track

—set the start and stop point of fit

—update track

Definition at line 7251 of file KalFitAlg.cxx.

{
 
    ///---readin clusters of this track
    SmartDataPtr<Event::EventHeader> eventHeader(eventSvc(),"/Event/EventHeader");
    if (!eventHeader) {
        cout << "Could not find Event Header" << endl;
    }
    int eventNo = eventHeader->eventNumber();
    int runNo = eventHeader->runNumber();
    SmartDataPtr<RecMdcTrackCol> recMdcTrack(eventSvc(),"/Event/Recon/RecMdcTrackCol");
    if (!recMdcTrack) {
       cout << "Could not find RecMdcTrackCol" << endl;
    }
    RecMdcTrackCol::iterator itrk = recMdcTrack->begin();
    ClusterRefVec clusterRefVec;
    for(; itrk != recMdcTrack->end(); itrk++){
        if((*itrk)->trackId() == track.trasan_id() && (*itrk)->getNcluster() > 0) {
            clusterRefVec = (*itrk)->getVecClusters();
            break;
        }
        else {
        if(4 == debug_) cout<<"run:"<<runNo<<" , Event:"<<eventNo<<" , track:"<<track.trasan_id()<<" has no cluster!"<<endl;
        }
    }
 
    if(debug_==4){ cout<<"wall size"<<_BesKalmanFitWalls.size()<<endl;}
 
    ///---set the start and stop point of fit
    ClusterRefVec::iterator itCluster;
    ClusterRefVec::iterator itStartFlag;
    ClusterRefVec::iterator itStopFlag;
    int step;
    int index=0;
    double lastR;
    double R_o_cgem=_BesKalmanFitWalls[0].radius();
    if(way<0){
        itStartFlag = clusterRefVec.begin();
        itStopFlag  = clusterRefVec.end();
        lastR=0;
        step = 1;
    }
    else {
        itStartFlag = clusterRefVec.end()-1;
        itStopFlag  = clusterRefVec.begin()-1;
        lastR=R_o_cgem;
        step = -1;
        double pathl;
        track.pivot_numf(track.x(track.intersect_cylinder(R_o_cgem)),pathl);
        if(KalFitElement::muls()) track.msgasmdc(pathl, way);
        if(KalFitElement::loss()) track.eloss(pathl, _BesKalmanFitMaterials[0], way);
    }
 
    ///---update track
    for(itCluster = itStartFlag; itCluster !=itStopFlag; itCluster = itCluster + step){
        int layer  = (*itCluster)->getlayerid();
        CgemGeoLayer* CgemLayer = m_CgemGeomSvc_->getCgemLayer(layer);
        double dmR   = CgemLayer->getMiddleROfGapD()/10;
        innerwall(track,hypo,way,lastR,dmR,index);
        lastR=dmR;
        track.update_hits(*itCluster, dmR,  way, m_csmflag);
    }
    KalFitTrack track_first(track);
    if(way<0){
        innerwall(track,hypo,way,lastR,R_o_cgem,index);
    }
    else
    {
        innerwall(track,hypo,way,lastR,0,index);
    }
 
    return track_first;
}

Referenced by complete_track().

Cgem_filter_anal() [2/2]

KalFitTrack KalFitAlg::Cgem_filter_anal	(	KalFitTrack &	track,
		int	hypo,
		int	way
	)

clean() [1/2]

void KalFitAlg::clean

(

void

)

delete C++ objects, necessary to clean before begin_run or inside destructor

Definition at line 190 of file KalFitAlg.cxx.

{
    // delete all Mdc objects :
    _BesKalmanFitWalls.clear();
    _BesKalmanFitMaterials.clear();
    m_innerWall.clear();
    m_CGEM.clear();
    m_CGEMMaterials.clear();
    if(_wire)free(_wire);
    if(_layer)free(_layer);
    if(_superLayer)free(_superLayer);
}

Referenced by initialize(), and ~KalFitAlg().

clean() [2/2]

void KalFitAlg::clean

(

void

)

delete C++ objects, necessary to clean before begin_run or inside destructor

clearTables() [1/2]

void KalFitAlg::clearTables

(

)

Definition at line 6229 of file KalFitAlg.cxx.

                             {
 
    if(debug_ == 4) cout<<"Begining to clear Tables ...."<<endl;
    vector<MdcRec_trk>* mdcMgr = MdcRecTrkCol::getMdcRecTrkCol();                 
    vector<MdcRec_trk_add>* mdc_addMgr = MdcRecTrkAddCol::getMdcRecTrkAddCol(); 
    vector<MdcRec_wirhit>* whMgr = MdcRecWirhitCol::getMdcRecWirhitCol();  
    vector<MdcRec_trk>::iterator tit=mdcMgr->begin();
    for( ; tit != mdcMgr->end(); tit++) {
        vector<MdcRec_wirhit*>::iterator vit= tit->hitcol.begin() ;
        for(; vit != tit->hitcol.end(); vit++) {
            delete (*vit);
        }
    }
 
    mdcMgr->clear();
    mdc_addMgr->clear();
    whMgr->clear();
 
    //   delete mdcMgr;
    //   delete mdc_addMgr;
    //   delete whMgr;
    //   mdcMgr = 0;
    //   mdc_addMgr = 0;
    //   whMgr = 0;
 
}

Referenced by execute().

clearTables() [2/2]

void KalFitAlg::clearTables

(

)

complete_track() [1/4]

void KalFitAlg::complete_track	(	MdcRec_trk &	TrasanTRK,
		MdcRec_trk_add &	TrasanTRK_add,
		KalFitTrack &	track_lead,
		RecMdcKalTrack *	kaltrk,
		RecMdcKalTrackCol *	kalcol,
		RecMdcKalHelixSegCol *	segcol
	)

fill tds with results got at (0,0,0)

Definition at line 5813 of file KalFitAlg.cxx.

{
    static int nmass = KalFitTrack::nmass();
    int way(1);
    MsgStream log(msgSvc(), name());
    KalFitTrack track_first(track_lead);
    KalFitTrack track_ip(track_lead);
 
    if (debug_ == 4){
        cout << "track_first  pivot "<<track_first.pivot()<< " helix "<<track_first.a()<<endl;
    }
    if(usage_==1)  innerwall(track_ip, lead_, way); 
    // Fill Tds
    fillTds_ip(TrasanTRK, track_ip, kaltrk, lead_);
 
    if (debug_ == 4) {
        cout << "after inner wall, track_ip  pivot "<<track_first.pivot()<< " helix "<<track_first.a()<<endl;
    }
 
    fillTds_lead(TrasanTRK, track_first, kaltrk, lead_);
 
    // Refit for different mass assumptions :  
    double pp = track_lead.momentum().mag();
 
    //w  if (!KalFitDSSD::cosmic_)
    if(!(i_front_<0)){
 
        for(int l_mass = 0, flg = 1; l_mass < nmass;
                l_mass++, flg <<= 1) {
 
            if (!(mhyp_ & flg))  continue;
            if (l_mass == lead_) continue;
 
            // Check the mom. to decide of the refit with this mass assumption
            if ((lead_ != 0 && l_mass==0 && pp > pe_cut_) || 
                    (lead_ != 1 && l_mass==1 && pp > pmu_cut_) ||
                    (lead_ != 2 && l_mass==2 && pp > ppi_cut_) ||
                    (lead_ != 3 && l_mass==3 && pp > pk_cut_) ||
                    (lead_ != 4 && l_mass==4 && pp > pp_cut_)) 
                continue;
 
            if(debug_ == 4) {
                cout<<"complete_track..REFIT ASSUMPION " << l_mass << endl;
            }
 
            // Initialisation :
            double chiSq = 0;
            int nhits = 0;
 
            // Initialisation : (x, a, ea)
            HepPoint3D x_trasan(TrasanTRK.pivot[0],
                    TrasanTRK.pivot[1],
                    TrasanTRK.pivot[2]);
 
            HepVector a_trasan(5);
            for(int i = 0; i < 5; i++){
                a_trasan[i] = TrasanTRK.helix[i];
            }
 
            HepSymMatrix ea_trasan(5);
            for(int i = 0, k = 0; i < 5; i++) {
                for(int j = 0; j <= i; j++) {
                    ea_trasan[i][j] = matrixg_*TrasanTRK.error[k++];
                    ea_trasan[j][i] = ea_trasan[i][j];
                }
            }
 
            KalFitTrack track(x_trasan,a_trasan, ea_trasan, l_mass, chiSq, nhits);
            track.HitsMdc(track_lead.HitsMdc());    
 
            double fiTerm = TrasanTRK.fiTerm;
            track.pivot(track.x(fiTerm));
 
            HepSymMatrix Eakal(5,0);
 
            double costheta = track_lead.a()[4] / sqrt(1.0 + track_lead.a()[4]*track_lead.a()[4]);
            if( (1.0/fabs(track_lead.a()[2]) < pt_cut_ ) && (fabs(costheta)> theta_cut_) ) {
                choice_ = 6;
            }
 
            init_matrix(choice_, TrasanTRK, Eakal);
 
            filter_fwd_calib(track, l_mass, way, Eakal);
 
            KalFitTrack track_z(track);
            ///fill tds  with results got at (0,0,0)  
            innerwall(track_z, l_mass, way);     
            fillTds_ip(TrasanTRK, track_z, kaltrk, l_mass);  
            // Fill tds
            fillTds(TrasanTRK, track, kaltrk, l_mass);     
        }
    }  //end of if (!(i_front<0))
 
    // Refit with an enhancement of the error matrix at Mdc level :
 
    if (enhance_) {
        HepPoint3D x_first(0, 0, 0);
        HepVector a_first(kaltrk->getFHelix());
        HepSymMatrix ea_first(kaltrk->getFError());
        HepVector fac(5);
        fac[0]=fac_h1_; fac[1]=fac_h2_; fac[2]=fac_h3_; fac[3]=fac_h4_; fac[4]=fac_h5_;
 
        for(int i = 0; i < 5; i++)
            for(int j = 0; j <= i; j++)
                ea_first[i][j] = fac[i]*fac[j]*ea_first[i][j];
        KalFitTrack track(x_first, a_first, ea_first, 2, 0, 0);
    }
 
    // Backward filter 
    // Attention, the initial error matrix of track_back is the error matrix
    // that after filter_fwd_calib(...) course of track_lead. So one thing need
    // more consideration that how to chose the inital error matrix of this smoother,
    // to put it by hand or use the error matrix after filter_fwd_calib. I think
    // it should be to refer R.G.Brown's book.
 
    KalFitTrack track_back(track_lead);
 
    //track_back(track);
 
 
    if (debug_ == 4) {
        cout << " Backward fitting flag:" << back_<< endl;
        cout << "track_back pivot " << track_back.pivot() 
            << " track_lead kappa " << track_lead.a()[2]
            <<endl;
    }
 
    if (back_ && track_lead.a()[2] != 0 && 
            1/fabs(track_lead.a()[2]) > pT_) {
        track_back.HitsMdc(track_lead.HitsMdc());
 
        if (KalFitTrack::tofall_) {
 
            double p_kaon(0), p_proton(0);
 
            if (!(kaltrk->getStat(0,3))) {
                p_kaon = 1 / fabs(kaltrk->getZHelixK()[2]) * 
                    sqrt(1 + kaltrk->getZHelixK()[4]*kaltrk->getZHelixK()[4]);
                track_back.p_kaon(p_kaon);
            } else {
                p_kaon = 1 / fabs(track_back.a()[2]) *
                    sqrt(1 + track_back.a()[4]*track_back.a()[4]);
                track_back.p_kaon(p_kaon);    
            }
            if (!(kaltrk->getStat(0,4))) {
                p_proton = 1 / fabs(kaltrk->getZHelixP()[2]) * 
                    sqrt(1 + kaltrk->getZHelixP()[4]*kaltrk->getZHelixP()[4]);
                track_back.p_proton(p_proton);
            } else {
                p_proton = 1 / fabs(track_back.a()[2]) *
                    sqrt(1 + track_back.a()[4]*track_back.a()[4]);
                track_back.p_proton(p_proton);
            }
 
        }
 
 
        if (!(i_back_<0)) {
            for(int l_mass = 0; l_mass < nmass; l_mass++) {
                KalFitTrack track_seed(track_back);
                track_seed.chgmass(l_mass);     
                smoother_calib(track_seed, -way); 
                // fill TDS  for backward filter :
                fillTds_back(track_seed, kaltrk, TrasanTRK, l_mass,segcol);
            }
        } else {
 
            smoother_calib(track_back, -way); 
            // fill TDS  for backward filter , for leading particle hypothesis :
            fillTds_back(track_back, kaltrk, TrasanTRK, lead_,segcol);
            // fillTds_helixsegs(track_back,TrasanTRK);
        }
    }
 
    /*
    // Take care of the pointers (use lead. hyp results by default)
    for(int pid = 0; pid < nmass;
    pid++) {
    if (pid == lead_) continue;
    if (kaltrk->getStat(1,pid)) 
    sameas(kaltrk, pid, lead_);
    }
    */
 
    //check: before register into TDS
 
    log << MSG::DEBUG << "registered MDC Kalmantrack:"
        << "Track Id: " << kaltrk->getTrackId()
        << " Mass of the fit: "<< kaltrk->getMass(2)<< endreq
        << "Length of the track: "<< kaltrk->getLength(2)
        << "  Tof of the track: "<< kaltrk->getTof(2) << endreq
        << "Chisq of the fit: "<< kaltrk->getChisq(0,2)
        <<"  "<< kaltrk->getChisq(1,2) << endreq
        << "Ndf of the fit: "<< kaltrk->getNdf(0,2)
        <<"  "<< kaltrk->getNdf(1,2) << endreq
        << "Helix " << kaltrk->getZHelix()[2]
        <<endreq;
 
    kalcol->push_back(kaltrk);
    track_lead.HitsMdc().clear();
    track_back.HelixSegs().clear();
    //  ??ATTENTION!! should track_back.HelixSegs() be cleared ??
}

complete_track() [2/4]

void KalFitAlg::complete_track	(	MdcRec_trk &	TrasanTRK,
		MdcRec_trk_add &	TrasanTRK_add,
		KalFitTrack &	track_lead,
		RecMdcKalTrack *	kaltrk,
		RecMdcKalTrackCol *	kalcol,
		RecMdcKalHelixSegCol *	segcol
	)

complete_track() [3/4]

void KalFitAlg::complete_track	(	MdcRec_trk &	TrasanTRK,
		MdcRec_trk_add &	TrasanTRK_add,
		KalFitTrack &	track_lead,
		RecMdcKalTrack *	kaltrk,
		RecMdcKalTrackCol *	kalcol,
		RecMdcKalHelixSegCol *	segcol,
		int	flagsmooth
	)

fill tds with results got at (0,0,0)

Definition at line 5612 of file KalFitAlg.cxx.

{   
    static int nmass = KalFitTrack::nmass();
    int way(1);
    MsgStream log(msgSvc(), name());
    KalFitTrack track_first(track_lead);
    //fromFHitToInnerWall(track_lead, way);
    // cout << "m_esti" << m_esti1_r[0] << endl;
    //cout<<"fitGemHits for pion"<<endl;
    //if(useNCGem_>0) fitGemHits(track_lead, lead_, way);
    if(useNCGem_>0)track_first=Cgem_filter_anal(track_lead, lead_, way);
    KalFitTrack track_ip(track_lead);
    //cout<<"__FUNCTION__: track_lead.nLayerUsed = "<<track_lead.nLayerUsed()<<endl;
    //cout<<"__FUNCTION__: track_ip.nLayerUsed   = "<<track_ip.nLayerUsed()<<endl;
    //innerwall(track_ip, lead_, way,95,99); 
    // Fill Tds
    fillTds_ip(TrasanTRK, track_ip, kaltrk, lead_);
    // std::cout<<"track_first nster"<<track_first.nster()<<std::endl;
 
    fillTds_lead(TrasanTRK, track_first, kaltrk, lead_);
    // Refit for different mass assumptions :  
    double pp = track_lead.momentum().mag();
 
    if(!(i_front_<0)){
        //cout << "!!!!i_front" << i_front_<< endl;
        for(int l_mass = 0, flg = 1; l_mass < nmass;
                l_mass++, flg <<= 1) {
 
            if (!(mhyp_ & flg)) continue;
            if (l_mass == lead_) continue;
 
            // Check the mom. to decide of the refit with this mass assumption
            if ((lead_ != 0 && l_mass==0 && pp > pe_cut_) || 
                    (lead_ != 1 && l_mass==1 && pp > pmu_cut_) ||
                    (lead_ != 2 && l_mass==2 && pp > ppi_cut_) ||
                    (lead_ != 3 && l_mass==3 && pp > pk_cut_) ||
                    (lead_ != 4 && l_mass==4 && pp > pp_cut_)) 
                continue;
            if(debug_ == 4) cout<<"complete_track..REFIT ASSUMPION " << l_mass << endl;
            // Initialisation :
            double chiSq = 0;
            int nhits = 0;
 
            // Initialisation : (x, a, ea)
            HepPoint3D x_trasan(TrasanTRK.pivot[0],
                    TrasanTRK.pivot[1],
                    TrasanTRK.pivot[2]);
            HepVector a_trasan(5);
            for(int i = 0; i < 5; i++)
                a_trasan[i] = TrasanTRK.helix[i];
 
            HepSymMatrix ea_trasan(5);
            for(int i = 0, k = 0; i < 5; i++) {
                for(int j = 0; j <= i; j++) {
                    ea_trasan[i][j] = matrixg_*TrasanTRK.error[k++];
                    ea_trasan[j][i] = ea_trasan[i][j];
                }
            }
 
            KalFitTrack track(x_trasan,a_trasan, ea_trasan, l_mass, chiSq, nhits);
            track.HitsMdc(track_lead.HitsMdc());    
            track.trasan_id(TrasanTRK.id);
            double fiTerm = TrasanTRK.fiTerm;
            track.pivot(track.x(fiTerm));
            HepSymMatrix Eakal(5,0);
 
            double costheta = track.a()[4] / sqrt(1.0 + track.a()[4]*track.a()[4]);
            if( (1.0/fabs(track.a()[2]) < pt_cut_ ) && (fabs(costheta)> theta_cut_) ) {
                choice_ = 6;
            }
 
            init_matrix(choice_,TrasanTRK, Eakal);
            filter_fwd_anal(track, l_mass, way, Eakal);
            KalFitTrack track_z(track);
            //fromFHitToInnerWall(track_z, way);
            //cout<<"fitGemHits for i="<<l_mass<<endl;
            //if(useNCGem_>0) fitGemHits(track_z, l_mass, way);
            if(useNCGem_>0) Cgem_filter_anal(track_z, l_mass, way);
            ///fill tds  with results got at (0,0,0)  
            //innerwall(track_z, l_mass, way,95,99);     
            fillTds_ip(TrasanTRK, track_z, kaltrk, l_mass);  
            // Fill tds
            fillTds(TrasanTRK, track, kaltrk, l_mass);     
            if(ifProdNt12){
                if(l_mass==1)residual(track_z);
            }
        }
    } // end of //end of if (!(i_front<0))
 
 
    // Refit with an enhancement of the error matrix at Mdc level :
    if (enhance_) {
 
        HepPoint3D x_first(0, 0, 0);
        HepVector a_first(kaltrk->getFHelix());
        HepSymMatrix ea_first(kaltrk->getFError());
        HepVector fac(5);
        fac[0]=fac_h1_; fac[1]=fac_h2_; fac[2]=fac_h3_; fac[3]=fac_h4_; fac[4]=fac_h5_;
        for(int i = 0; i < 5; i++)
            for(int j = 0; j <= i; j++)
                ea_first[i][j] = fac[i]*fac[j]*ea_first[i][j];
        KalFitTrack track(x_first, a_first, ea_first, 2, 0, 0);
    }
 
    // Backward filter :  
    KalFitTrack track_back(track_lead);
    if (debug_ == 4) {
        cout << " Backward fitting flag:" << back_<< endl;
        cout << "track_back pivot " << track_back.pivot() 
            << " track_lead kappa " << track_lead.a()[2]
            <<endl;
    }
 
    if (back_ && track_lead.a()[2] != 0 && 
            1/fabs(track_lead.a()[2]) > pT_) {
        track_back.HitsMdc(track_lead.HitsMdc());
 
        if (KalFitTrack::tofall_) {
            double p_kaon(0), p_proton(0);
            if (!(kaltrk->getStat(0,3))) {
                p_kaon = 1 / fabs(kaltrk->getZHelixK()[2]) * 
                    sqrt(1 + kaltrk->getZHelixK()[4]*kaltrk->getZHelixK()[4]);
                track_back.p_kaon(p_kaon);
            } else {
                p_kaon = 1 / fabs(track_back.a()[2]) *
                    sqrt(1 + track_back.a()[4]*track_back.a()[4]);
                track_back.p_kaon(p_kaon);    
            }
            if (!(kaltrk->getStat(0,4))) {
                p_proton = 1 / fabs(kaltrk->getZHelixP()[2]) * 
                    sqrt(1 + kaltrk->getZHelixP()[4]*kaltrk->getZHelixP()[4]);
                track_back.p_proton(p_proton);
            } else {
                p_proton = 1 / fabs(track_back.a()[2]) *
                    sqrt(1 + track_back.a()[4]*track_back.a()[4]);
                track_back.p_proton(p_proton);
            }
        }
 
        if (!(i_back_<0)) {
            //cout<<" *** in smoothing process ***"<<endl;
            for(int l_mass = 0; l_mass < nmass; l_mass++) {
                //cout<<" --- in hypothesis "<<l_mass<<" :"<<endl;
                KalFitTrack track_seed(track_back);
                track_seed.chgmass(l_mass);     
                //cout<<"---------------"<<endl;//wangll
                //cout<<"smooth track "<<l_mass<<endl;//wangll
                //cout<<"  pivot :"<<track_seed.pivot()<<endl;//wangll
                //cout<<"  helix :"<<track_seed.a()<<endl;//wangll
 
                if(useNCGem_>0) Cgem_filter_anal(track_seed, l_mass, -way);
                smoother_anal(track_seed, -way); 
                // if( usage_ == 1) smoother_calib(track_seed, -way);
                //cout<<"fillTds_back 1"<<endl;
                // fill TDS  for backward filter :
                fillTds_back(track_seed, kaltrk, TrasanTRK, l_mass, segcol, 1);
                //cout<<"nHits: "<<kaltrk->getVecHelixSegs().size()<<endl;
            }
        } else {
            if(useNCGem_>0) Cgem_filter_anal(track_back, lead_, -way);
            smoother_anal(track_back, -way);
            //smoother_calib(track_back, -way);
            // smoother(track_back, -way); 
            // fill TDS  for backward filter :
            //cout<<"fillTds_back 2"<<endl;
            fillTds_back(track_back, kaltrk, TrasanTRK, lead_, segcol, 1);
        }
    }
 
    // Take care of the pointers (use lead. hyp results by default)
    for(int pid = 0; pid < nmass;
            pid++) {
        if (pid == lead_) continue;
        if (kaltrk->getStat(1,pid)) 
            sameas(kaltrk, pid, lead_);
    }
 
 
    //check: before register into TDS
 
    log << MSG::DEBUG << "registered MDC Kalmantrack:"
        << "Track Id: " << kaltrk->getTrackId()
        << " Mass of the fit: "<< kaltrk->getMass(2)<< endreq
        << "Length of the track: "<< kaltrk->getLength(2)
        << "  Tof of the track: "<< kaltrk->getTof(2) << endreq
        << "Chisq of the fit: "<< kaltrk->getChisq(0,2)
        <<"  "<< kaltrk->getChisq(1,2) << endreq
        << "Ndf of the fit: "<< kaltrk->getNdf(0,2)
        <<"  "<< kaltrk->getNdf(1,2) << endreq
        << "Helix " << kaltrk->getZHelix()[2]
        <<endreq;
 
    kalcol->push_back(kaltrk);
    track_lead.HitsMdc().clear();
}

Referenced by kalman_fitting_anal(), kalman_fitting_calib(), kalman_fitting_csmalign(), and kalman_fitting_MdcxReco_Csmc_Sew().

complete_track() [4/4]

void KalFitAlg::complete_track	(	MdcRec_trk &	TrasanTRK,
		MdcRec_trk_add &	TrasanTRK_add,
		KalFitTrack &	track_lead,
		RecMdcKalTrack *	kaltrk,
		RecMdcKalTrackCol *	kalcol,
		RecMdcKalHelixSegCol *	segcol,
		int	flagsmooth
	)

execute() [1/2]

StatusCode KalFitAlg::execute

(

)

event function

• 
  

Definition at line 761 of file KalFitAlg.cxx.

{
    MsgStream log(msgSvc(), name());
    log << MSG::INFO << "in execute()" << endreq;
    if(testOutput) std::cout<<"begin to deal with EVENT  ..."<<(++eventno)<<std::endl;
    for(int i=0; i<5; i++) iqual_front_[i] = 1;
    iqual_back_ = 1;
 
 
    /*
       MdcID mdcId;
       SmartDataPtr<RecMdcKalTrackCol> recmdckaltrkCol(eventSvc(),"/Event/Recon/RecMdcKalTrackCol");
       SmartDataPtr<RecMdcKalHelixSegCol> recSegCol(eventSvc(),"/Event/Recon/RecMdcKalHelixSegCol");
       if(recmdckaltrkCol) {
       cout<<"------------------------ new event ---------------------"<<endl;
       cout<<"recmdckaltrkCol->size()="<<recmdckaltrkCol->size()<<endl;
       cout<<"recSegCol.size()="<<recSegCol->size()<<endl;
       cout<<"--------------------------------------------------------"<<endl;
       RecMdcKalTrack::setPidType(RecMdcKalTrack::electron);
       RecMdcKalTrackCol::iterator KalTrk= recmdckaltrkCol->begin();
       int i_trk=0;
       for(;KalTrk !=recmdckaltrkCol->end();KalTrk++){
       cout<<"*** track "<<i_trk++<<" ***"<<endl;
       HelixSegRefVec gothelixsegs = (*KalTrk)->getVecHelixSegs();
       for(int i=0;i<5;i++) cout<<"pid "<<i<<" nSegs="<<((*KalTrk)->getVecHelixSegs(i)).size()<<endl;
       HelixSegRefVec::iterator iter_hit = gothelixsegs.begin();
       if(iter_hit == gothelixsegs.end())cout<<"iter_hit == gothelixsegs.end()"<<endl;
       int nhitofthistrk=0;
       for( ; iter_hit != gothelixsegs.end(); iter_hit++){
       nhitofthistrk++;
    //cout<<"layerId: "<<(*iter_hit)->getLayerId()<<endl;
    //cout<<"Identifier: "<<(*iter_hit)->getMdcId()<<endl;
    //cout<<"layerId: "<<mdcId.layer((*iter_hit)->getMdcId())<<endl;
    //cout<<"getDT: "<<(*iter_hit)->getDT()<<endl;
    }
    iter_hit=gothelixsegs.begin();
    //for(int m=0; m<nhitofthistrk/5;m++){
    //  identifier = (*iter_hit) -> getMdcId();
    //}
    cout<<"nhitofthistrk="<<nhitofthistrk<<endl;
    }
    }
    else cout<<"did not find /Event/Recon/RecMdcKalTrackCol"<<endl;
    */
 
 
 
 
    /// 
    IMagneticFieldSvc* IMFSvc; 
    StatusCode sc = service ("MagneticFieldSvc",IMFSvc);
    if(sc!=StatusCode::SUCCESS) {
        log << MSG::ERROR << "Unable to open Magnetic field service"<<endreq; 
    }
 
    // Nominal magnetic field : 
    if (KalFitTrack::numfcor_){
        KalFitTrack::Bznom_ = (IMFSvc->getReferField())*10000; //unit is KGauss
        if(0 == KalFitTrack::Bznom_)   KalFitTrack::Bznom_ = -10;
 
        if(4 == debug_){
            std::cout<<" execute, referField from MagneticFieldSvc: "<< (IMFSvc->getReferField())*10000 <<std::endl;
            std::cout<<" magnetic field: "<<KalFitTrack::Bznom_<<std::endl;
        }
    }
 
    RecMdcKalTrackCol* kalcol = new RecMdcKalTrackCol;
 
    IDataProviderSvc* evtSvc = NULL;
    Gaudi::svcLocator()->service("EventDataSvc", evtSvc);
    if (evtSvc) {
        log << MSG::INFO << "makeTds:event Svc has been found" << endreq;
    } else {
        log << MSG::FATAL << "makeTds:Could not find eventSvc" << endreq;
        return StatusCode::SUCCESS;
    }
 
    StatusCode kalsc;
    IDataManagerSvc *dataManSvc;
    dataManSvc= dynamic_cast<IDataManagerSvc*>(evtSvc);
    DataObject *aKalTrackCol;
    evtSvc->findObject("/Event/Recon/RecMdcKalTrackCol",aKalTrackCol);
    if(aKalTrackCol != NULL) {
        dataManSvc->clearSubTree("/Event/Recon/RecMdcKalTrackCol");
        evtSvc->unregisterObject("/Event/Recon/RecMdcKalTrackCol");
    }
 
    kalsc = evtSvc->registerObject("/Event/Recon/RecMdcKalTrackCol", kalcol);
    if( kalsc.isFailure() ) {
        log << MSG::FATAL << "Could not register RecMdcKalTrack" << endreq;
        return StatusCode::SUCCESS;
    }
    log << MSG::INFO << "RecMdcKalTrackCol registered successfully!" <<endreq;
 
    DataObject *aKalHelixSegCol;
    evtSvc->findObject("/Event/Recon/RecMdcKalHelixSegCol", aKalHelixSegCol);
    if(aKalHelixSegCol != NULL){
        dataManSvc->clearSubTree("/Event/Recon/RecMdcKalHelixSegCol");
        evtSvc->unregisterObject("/Event/Recon/RecMdcKalHelixSegCol");
    }
    RecMdcKalHelixSegCol *helixsegcol = new RecMdcKalHelixSegCol;  
    kalsc = evtSvc->registerObject("/Event/Recon/RecMdcKalHelixSegCol", helixsegcol);
    if( kalsc.isFailure()){
        log<< MSG::FATAL << "Could not register RecMdcKalHelixSeg" <<endreq;
        return StatusCode::SUCCESS;
    }
    log << MSG::INFO << "RecMdcKalHelixSegCol register successfully!" <<endreq;
 
 
    /*IMdcGeomSvc* geosvc;
      StatusCode sc = service("MdcGeomSvc", geosvc);
      if (sc ==  StatusCode::SUCCESS) {
      } else {
      return sc;
      }*/
 
    ISvcLocator* svcLocator = Gaudi::svcLocator();
    ICgemGeomSvc* ISvc;
    StatusCode Cgem_sc=svcLocator->service("CgemGeomSvc", ISvc);
    m_CgemGeomSvc_=dynamic_cast<CgemGeomSvc *>(ISvc);
    if (!Cgem_sc.isSuccess()) log<< MSG::INFO << "KalFitAlg::execute(): Could not open CGEM geometry file" << endreq;
    //myNCgemLayers = myCgemGeomSvc->getNumberOfCgemLayer();
    //if(myPrintFlag) cout<<"CgemClusterCreate::initialize() "<<myNCgemLayers<<" Cgem layers"<<endl;
 
    MdcGeomSvc* const geosvc = dynamic_cast<MdcGeomSvc*>(imdcGeomSvc_);
    if(!geosvc) {
        std::cout<<"ERROR OCCUR when dynamic_cast in KalFitAlg::execute ...!!"<<std::endl; 
    }
 
    SmartDataPtr<Event::EventHeader> eventHeader(eventSvc(),"/Event/EventHeader");
    if (!eventHeader) {
        log << MSG::WARNING << "Could not find Event Header" << endreq;
        return StatusCode::FAILURE;
    }
    int eventNo = eventHeader->eventNumber();
    int runNo = eventHeader->runNumber();
    if(runNo>0) wsag_=4;
    else wsag_=0;
 
    if(testOutput) cout<<endl<<"$$$$$$$$$$$   run="<<runNo<<",  evt="<<eventNo<<"    $$$$$$$$$$$$$$$$$"<<endl<<endl;
 
    double t0=0.;
    SmartDataPtr<RecEsTimeCol> estimeCol(eventSvc(),"/Event/Recon/RecEsTimeCol");
    if (estimeCol && estimeCol->size()) {
        RecEsTimeCol::iterator iter_evt = estimeCol->begin();
        t0 =  (*iter_evt)->getTest();
        // t0Stat = (*iter_evt)->getStat();
    }else{
        log << MSG::WARNING << "Could not find EvTimeCol" << endreq;
        return StatusCode::SUCCESS;
    }
 
 
    if(debug_==4) {
        std::cout<<"in KalFitAlg , we get the event start time = "<<t0<<std::endl;
    } 
    KalFitTrack::setT0(t0);
 
    SmartDataPtr<MdcDigiCol> mdcDigiCol(evtSvc,"/Event/Digi/MdcDigiCol");
    if (sc!=StatusCode::SUCCESS) {
        log << MSG::FATAL << "Could not find MdcDigiCol!" << endreq;
        return StatusCode::SUCCESS;
    }
    KalFitTrack::setMdcDigiCol(mdcDigiCol);
 
    // register RecMdcTrack and MdcRecHit collection 
 
    if((ntuple_&16)&&(ntuple_&1)) {
        // McTruth infor,Retrieve MC track truth
        // bool mcstat = true;
        // more research needed ...
 
        m_evtid = eventHeader->eventNumber();
        bool mcstat = true;
 
        SmartDataPtr<McParticleCol> mcPartCol(eventSvc(),"/Event/MC/McParticleCol");
        if (!mcPartCol) {
            log << MSG::WARNING << "Could not find McParticle" << endreq;
            mcstat = false;
        }
 
        if(mcstat) {
            McParticleCol::iterator i_mcTrk = mcPartCol->begin();
            for (;i_mcTrk != mcPartCol->end(); i_mcTrk++) {
                if(!(*i_mcTrk)->primaryParticle()) continue;
                const HepLorentzVector& mom((*i_mcTrk)->initialFourMomentum());
                const HepLorentzVector& pos = (*i_mcTrk)->initialPosition();
                log << MSG::DEBUG << "MCINFO:particleId=" << (*i_mcTrk)->particleProperty()
                    << " theta=" << mom.theta() <<" phi="<< mom.phi()
                    <<" px="<< mom.px() <<" py="<< mom.py() <<" pz="<< mom.pz()
                    << endreq;
                double charge = 0.0;
                int pid = (*i_mcTrk)->particleProperty();
                int mother_id = ((*i_mcTrk)->mother()).particleProperty();
                if( pid >0 ) { 
                    charge = m_particleTable->particle( pid )->charge();
                } else if ( pid <0 ) {
                    charge = m_particleTable->particle( -pid )->charge();
                    charge *= -1;
                } else {
                    log << MSG::WARNING << "wrong particle id, please check data" <<endreq;
                }
                HepPoint3D pos2(pos.x(),pos.y(),pos.z());
                Hep3Vector mom2(mom.px(),mom.py(),mom.pz());
 
                Helix mchelix(pos2, mom2, charge);
                log << MSG::DEBUG << "charge of the track " << charge << endreq;
                if( debug_ == 4) cout<< "helix: "<<mchelix.a()<<endl;
                mchelix.pivot( HepPoint3D(0,0,0) );
                for( int j =0; j<5; j++) {
                    m_mchelix[j] = mchelix.a()[j];
                }
                m_mcpid = pid;
                m_mcptot = sqrt(1+pow(m_mchelix[4],2))/m_mchelix[2];
                if(testOutput)
                {
                    cout<<"MC pid, mother_id = "<<pid<<", "<<mother_id<<endl;
                    cout<<"              p4 = "<<(*i_mcTrk)->initialFourMomentum()<<endl;
                    cout<<"        start from "<<(*i_mcTrk)->initialPosition()<<endl;
                    cout<<"            end at "<<(*i_mcTrk)->finalPosition()<<endl;
                    cout<<"            Helix: "<<mchelix.a()<<endl;
                    cout<<"mc ptot, theta, phi, R = "<<m_mcptot<<", "<<mom2.theta()/acos(-1.)*180<<", "<<mom2.phi()/acos(-1.)*180<<", "<<mchelix.radius()<<endl;
                }
            }   
        }
    }
 
    Identifier mdcid;
 
    //retrieve  RecMdcTrackCol from TDS
    SmartDataPtr<RecMdcTrackCol> newtrkCol(eventSvc(),"/Event/Recon/RecMdcTrackCol");
    if (!newtrkCol) {
        log << MSG::FATAL << "Could not find RecMdcTrackCol" << endreq;
        return( StatusCode::SUCCESS);
    }
    log << MSG::INFO << "Begin to make MdcRecTrkCol and MdcRecWirhitCol"<<endreq;
 
    vector<MdcRec_trk>* mtrk_mgr = MdcRecTrkCol::getMdcRecTrkCol();
    mtrk_mgr->clear(); 
    vector<MdcRec_trk_add>* mtrkadd_mgr = MdcRecTrkAddCol::getMdcRecTrkAddCol();
    mtrkadd_mgr->clear();    
    vector<MdcRec_wirhit>* mhit_mgr = MdcRecWirhitCol::getMdcRecWirhitCol();
    mhit_mgr->clear();
 
    double trkx1,trkx2,trky1,trky2,trkz1,trkz2,trkthe1,trkthe2,trkphi1,trkphi2,trkp1,trkp2,trkr1,trkr2,trkkap1,trkkap2,trktanl1,trktanl2; 
    Hep3Vector csmp3[2];
    double csmphi[2];
    int status_temp=0;
    RecMdcTrackCol::iterator iter_trk = newtrkCol->begin();
    for(int kj = 1; iter_trk != newtrkCol->end(); iter_trk++,kj++) {
        if(kj<3){
            csmp3[kj-1]=(*iter_trk)->p3();
            csmphi[kj-1] = (*iter_trk)->phi();
        }
        if(ntuple_&2) {
            //check trackcol, track level
            for( int j = 0, ij = 0; j<5; j++) {
                m_trkhelix[j] = (*iter_trk)->helix()[j];
                if(ntuple_&32) {
                    for(int k=0; k<=j; k++,ij++) {
                        m_trkerror[ij] = (*iter_trk)->err()[j][k];
                    }
                }
            }
            m_trkptot = sqrt(1+pow(m_trkhelix[4],2))/m_trkhelix[2];
            if(ntuple_&32){
                m_trksigp = sqrt(pow((m_trkptot/m_trkhelix[2]),2)*m_trkerror[5]+
                        pow((m_trkhelix[4]/m_trkptot),2)*pow((1/m_trkhelix[2]),4)*m_trkerror[14]-
                        2*m_trkhelix[4]*m_trkerror[12]*pow((1/m_trkhelix[2]),3));
            }
            m_trkndf =  (*iter_trk)->ndof();
            m_trkchisq =  (*iter_trk)->chi2();
 
            if (debug_ == 4) cout<<"Ea from RecMdcTrackCol..." <<(*iter_trk)->err()<<endl;
 
            StatusCode sc3 = m_nt3->write();
            if( sc3.isFailure() ) cout<<"Ntuple3 filling failed!"<<endl;
        }
        //end of track level check and prepare evt check
        if(ntuple_&4) {
            /*
               if(kj == 1) {
               trkphi1 = (*iter_trk)->getFi0();
               trkr1 = (*iter_trk)->getDr();
               trkz1 = (*iter_trk)->getDz();    
               trkkap1 = (*iter_trk)->getCpa(); 
               trktanl1 = (*iter_trk)->getTanl();   
               trkx1 = trkr1*cos(trkphi1);
               trky1 = trkr1*sin(trkphi1);
               trkp1 = sqrt(1+trktanl1*trktanl1)/trkkap1;
               trkthe1 = M_PI/2-atan(trktanl1);
               } else if(kj == 2) {
               trkphi2 = (*iter_trk)->getFi0();
               trkr2 = (*iter_trk)->getDr();
               trkz2 = (*iter_trk)->getDz();    
               trkkap2 = (*iter_trk)->getCpa(); 
               trktanl2 = (*iter_trk)->getTanl();   
               trkx2 = trkr2*cos(trkphi2);
               trky2 = trkr2*sin(trkphi2);
               trkp2 = sqrt(1+trktanl2*trktanl2)/trkkap1;
               trkthe2 = M_PI/2-atan(trktanl2);
               }
               */
        }
        //end prepare   
 
        log << MSG::DEBUG << "retrieved MDC tracks:"
            << "   Nhits " <<(*iter_trk)->getNhits()
            << "   Nster " <<(*iter_trk)->nster() <<endreq;
        // so ,use this to get the hits vector belong to this track ... 
        HitRefVec gothits = (*iter_trk)->getVecHits();
 
        MdcRec_trk* rectrk = new MdcRec_trk;
 
        rectrk->id = (*iter_trk)->trackId();
        rectrk->chiSq = (*iter_trk)->chi2();
        rectrk->ndf = (*iter_trk)->ndof();
        rectrk->fiTerm = (*iter_trk)->getFiTerm();
        rectrk->nhits = (*iter_trk)->getNhits();
        rectrk->nster = (*iter_trk)->nster();
        rectrk->nclus = 0;
        rectrk->stat = (*iter_trk)->stat();
        status_temp = (*iter_trk)->stat();
        MdcRec_trk_add* trkadd = new MdcRec_trk_add;
        trkadd->id = (*iter_trk)->trackId(); 
        trkadd->quality = 0;
        trkadd->kind = 1;
        trkadd->decision = 0;
        trkadd->body = rectrk;
        rectrk->add = trkadd;
 
        for ( int i=0; i<5; i++) {
            rectrk->helix[i] = (*iter_trk)->helix()[i];
            if( i<3 ) rectrk->pivot[i] = (*iter_trk)->getPivot()[i];
            for( int j = 1; j<i+2;j++) {
                rectrk->error[i*(i+1)/2+j-1] = (*iter_trk)->err()(i+1,j);
            }
        }
        std::sort(gothits.begin(),  gothits.end(),  order_rechits);
        HitRefVec::iterator it_gothit = gothits.begin();
        for( ; it_gothit != gothits.end(); it_gothit++) {
 
            if( (*it_gothit)->getStat() != 1 ) {
                if(activeonly_) {
                    log<<MSG::WARNING<<"this hit is not used in helix fitting!"<<endreq; 
                    continue;
                }
            }
 
            log << MSG::DEBUG << "retrieved hits in MDC tracks:"
                << "   hits DDL " <<(*it_gothit)->getDriftDistLeft()
                << "   hits DDR " <<(*it_gothit)->getDriftDistRight()
                << "   error DDL " <<(*it_gothit)->getErrDriftDistLeft()
                << "   error DDR " <<(*it_gothit)->getErrDriftDistRight()
                << "   id of hit "<<(*it_gothit)->getId() 
                << "   track id of hit "<<(*it_gothit)->getTrkId()
                << "   hits ADC " <<(*it_gothit)->getAdc() << endreq;
 
            MdcRec_wirhit* whit = new MdcRec_wirhit;
            whit->id = (*it_gothit)->getId();
            whit->ddl = (*it_gothit)->getDriftDistLeft();
            whit->ddr = (*it_gothit)->getDriftDistRight();
            whit->erddl = (*it_gothit)->getErrDriftDistLeft();
            whit->erddr = (*it_gothit)->getErrDriftDistRight();
            whit->pChiSq = (*it_gothit)->getChisqAdd();
            whit->lr = (*it_gothit)->getFlagLR();
            whit->stat = (*it_gothit)->getStat();
            mdcid = (*it_gothit)->getMdcId();
            int layid =  MdcID::layer(mdcid);
            int localwid = MdcID::wire(mdcid);
            int w0id = geosvc->Layer(layid)->Wirst();
            int wid = w0id + localwid;
            log << MSG::INFO
                << "lr from PR: "<<whit->lr
                << " layerId = " << layid
                << " wireId = " << localwid
                << endreq;
 
            const MdcGeoWire * const wirgeo = geosvc->Wire(wid); 
 
            //std::cout<<"the track id of *it_gothit... "<<(*it_gothit)->getTrackId()<<std::endl; 
            whit->rechitptr = *it_gothit;
            whit->geo = wirgeo;
            whit->dat = 0;
            whit->trk = rectrk;
            whit->tdc = (*it_gothit)->getTdc();
            whit->adc= (*it_gothit)->getAdc();
            rectrk->hitcol.push_back(whit);
            mhit_mgr->push_back(*whit);
        }
        mtrk_mgr->push_back(*rectrk);
        mtrkadd_mgr->push_back(*trkadd);
 
        delete rectrk;
        delete trkadd;
    }
 
    // check trkcol: evt level
    if(ntuple_&4) {
        m_trkdelx = trkx1 - trkx2;
        m_trkdely = trky1 - trky2;
        m_trkdelz = trkz1 - trkz2;
        m_trkdelthe = trkthe1 + trkthe2;
        m_trkdelphi = trkphi1- trkphi2;
        m_trkdelp = trkp1 - trkp2;
        StatusCode sc4 = m_nt4->write();
        if( sc4.isFailure() ) cout<<"Ntuple4 filling failed!"<<endl;
    }
 
    if(debug_ == 4) { std::cout<<"before refit,ntrk,nhits,nadd..."<<mtrk_mgr->size()
        <<"********"<<mhit_mgr->size()<<"****"<<mtrkadd_mgr->size()<<endl;
    }
 
    if(useNCGem_>0) makeGemHitsCol();
 
    // Actual fitter procedure :
    //cout << "m_trackid" << m_trackid << endl;
    //cout << "m_qua" << m_qua << endl;
    //cout << "m_esti" << m_esti1_r[0] << endl;
    if(usage_ == 0) kalman_fitting_anal();
    if(usage_ == 1) kalman_fitting_calib();
    double mdang = 180.0 - csmp3[0].angle(csmp3[1].unit())*180.0/M_PI;
    double mdphi = 180.0 - fabs(csmphi[0]-csmphi[1])*180.0/M_PI;
    //std::cout<<"before refit,ntrk,nhits,nadd..."<<mtrk_mgr->size()<<" , "<<mhit_mgr->size()<<" , "<<mtrkadd_mgr->size()<<endl;
    if(usage_ == 2 && (mtrk_mgr->size())==2 && fabs(mdang)<m_dangcut && fabs(mdphi)<m_dphicut) kalman_fitting_csmalign();
    if(usage_ == 3 && (mtrk_mgr->size())==1 && status_temp==-1) kalman_fitting_MdcxReco_Csmc_Sew();
 
    log << MSG::DEBUG <<"after kalman_fitting(),but in execute...."<<endreq;
    clearTables();   
 
 
    ///*  
    // --- test for songxy
    MdcID mdcId;
    SmartDataPtr<RecMdcKalTrackCol> recmdckaltrkCol(eventSvc(),"/Event/Recon/RecMdcKalTrackCol");
    //cout<<"------------------------ new event ---------------------"<<endl;
    //cout<<"recmdckaltrkCol->size()="<<recmdckaltrkCol->size()<<endl;
    //cout<<"--------------------------------------------------------"<<endl;
    RecMdcKalTrack::setPidType(RecMdcKalTrack::electron);
    RecMdcKalTrackCol::iterator KalTrk= recmdckaltrkCol->begin();
    int i_trk=0;
    for(;KalTrk !=recmdckaltrkCol->end();KalTrk++){
        //cout<<"*** track "<<i_trk++<<" ***"<<endl;
        for(int hypo=0; hypo<5; hypo++)
        {
            if((*KalTrk)->getStat(0,hypo)==1) nFailedTrks[hypo]++;
        }
        HelixSegRefVec gothelixsegs = (*KalTrk)->getVecHelixSegs();
        HelixSegRefVec::iterator iter_hit = gothelixsegs.begin();
        //if(iter_hit == gothelixsegs.end())cout<<"iter_hit == gothelixsegs.end()"<<endl;
        int nhitofthistrk=0;
        for( ; iter_hit != gothelixsegs.end(); iter_hit++){
            nhitofthistrk++;
            //cout<<"layerId: "<<(*iter_hit)->getLayerId()<<endl;
            //cout<<"Identifier: "<<(*iter_hit)->getMdcId()<<endl;
            //cout<<"layerId: "<<mdcId.layer((*iter_hit)->getMdcId())<<endl;
            //cout<<"getDT: "<<(*iter_hit)->getDT()<<endl;
        }
        iter_hit=gothelixsegs.begin();
        //for(int m=0; m<nhitofthistrk/5;m++){
        //  identifier = (*iter_hit) -> getMdcId();
        //}
    }
    // */   
 
    // --- test for getStat(2, pid)
    /*
       SmartDataPtr<RecMdcKalTrackCol> recmdckaltrkCol(eventSvc(),"/Event/Recon/RecMdcKalTrackCol");
       SmartDataPtr<RecMdcTrackCol> mdcTrkCol(eventSvc(),"/Event/Recon/RecMdcTrackCol");
    //RecMdcKalTrack::setPidType(RecMdcKalTrack::electron);
    RecMdcKalTrackCol::iterator KalTrk= recmdckaltrkCol->begin();
    int i_trk=0;
    for(RecMdcTrackCol::iterator mdcTrk = mdcTrkCol->begin(); KalTrk !=recmdckaltrkCol->end(); KalTrk++, mdcTrk++){
    cout<<"*** track "<<i_trk++<<" ***"<<endl;
    cout<<"trackId mdc: "<<(*mdcTrk)->trackId()<<endl;
    cout<<"trackId kal: "<<(*KalTrk)->trackId()<<endl;
    bool KalIsValid = true;
    for(int i_pid=0; i_pid<5; i_pid++) {
    cout<<"pid "<<i_pid<<" state 0 : "<<(*KalTrk)->getStat(0, i_pid)<<endl;
    cout<<"pid "<<i_pid<<" state 1 : "<<(*KalTrk)->getStat(1, i_pid)<<endl;
    if((*KalTrk)->getStat(0, i_pid)==1) {
    KalIsValid = false;
    switch(i_pid) {
    case 0: RecMdcKalTrack::setPidType(RecMdcKalTrack::electron);
    break;
    case 1: RecMdcKalTrack::setPidType(RecMdcKalTrack::muon);
    break;
    case 2: RecMdcKalTrack::setPidType(RecMdcKalTrack::pion);
    break;
    case 3: RecMdcKalTrack::setPidType(RecMdcKalTrack::kaon);
    break;
    case 4: RecMdcKalTrack::setPidType(RecMdcKalTrack::proton);
    break;
    }
    cout<<"Helix Kal: "<<(*KalTrk)->helix()<<endl;
    cout<<"Helix Kal err: "<<(*KalTrk)->err()<<endl;
    }
    }
    if(!KalIsValid) {
    cout<<"Helix Mdc: "<<(*mdcTrk)->helix()<<endl;
    cout<<"Helix Mdc err: "<<(*mdcTrk)->err()<<endl;
    }
    }
    */
    if(ifProdNt11)
    {
        SmartDataPtr<Event::CgemMcHitCol> cgemMcHitCol(eventSvc(), "/Event/MC/CgemMcHitCol");
        if (!cgemMcHitCol){
            log << MSG::WARNING << "Could not retrieve Cgem MC truth" << endreq;
            return StatusCode::FAILURE;
        }
        m_evt4=eventHeader->eventNumber();
        Event::CgemMcHitCol::iterator iter_truth = cgemMcHitCol->begin();
        int jj=0;
        double dprex,dprey,dprez,dpostx,dposty,dpostz;
        int layer;
        for(; iter_truth != cgemMcHitCol->end(); ++iter_truth){
            layer = (*iter_truth)->GetLayerID();
            dprex = (*iter_truth)->GetPositionXOfPrePoint();
            dprey = (*iter_truth)->GetPositionYOfPrePoint();
            dprez = (*iter_truth)->GetPositionZOfPrePoint();
            dpostx = (*iter_truth)->GetPositionXOfPostPoint();
            dposty = (*iter_truth)->GetPositionYOfPostPoint();
            dpostz = (*iter_truth)->GetPositionZOfPostPoint();
 
            double midx=0;
            double midy=0;
            CgemGeoLayer* CgemLayer = m_CgemGeomSvc_->getCgemLayer(layer);
            double diR   = CgemLayer->getInnerROfGapD();
            double dmR   = CgemLayer->getMiddleROfGapD();
            double doR   = CgemLayer->getOuterROfGapD();
            if((dprex >=0&&dprey>=0)||(dprex <0&&dprey>=0)){
                //m_dtphi[jj] = acos(dprex/dr_layer[layer]);
                m_dtphi[jj] = acos(dprex/diR);
                m_dtv[jj]   = dprez;
                //m_dtpostphi[jj] = acos(dpostx/dor_layer[layer]);
                m_dtpostphi[jj] = acos(dpostx/doR);
                m_dtpostz[jj]= dpostz;
            }
            if((dprex <0&&dprey<0)||(dprex >=0&&dprey<0)){
                //m_dtphi[jj] = -acos(dprex/dr_layer[layer]);
                m_dtphi[jj] = -acos(dprex/diR);
                m_dtv[jj]   = dprez;
                //m_dtpostphi[jj] = -acos(dpostx/dor_layer[layer]);
                m_dtpostphi[jj] = -acos(dpostx/doR);
                m_dtpostz[jj]= dpostz;
            }
            midx=(dprex+dpostx)/2;
            midy=(dprey+dposty)/2;
            if((midx>=0&&midy>=0)||(midx<0&&midy>=0)){
                //m_dtphi[jj]=acos(midx/dmr_layer[layer]);
                m_dtphi[jj]=acos(midx/dmR);
            }
            if((midx<0&&midy<0)||(midx>=0&&midy<0)){
                //m_dtphi[jj]=-acos(midx/dmr_layer[layer]);
                m_dtphi[jj]=-acos(midx/dmR);
            }
            m_dtv[jj]   = (m_dtv[jj]+m_dtpostz[jj])/20;
            m_tlayer[jj] = layer;
            jj++;
        }
        m_ntruth = jj;
 
        m_nt11->write();
    }
 
 
 
    return StatusCode::SUCCESS;
}

execute() [2/2]

StatusCode KalFitAlg::execute

(

)

event function

extToAnyPoint() [1/2]

void KalFitAlg::extToAnyPoint	(	KalFitTrack &	trk,
		const HepPoint3D &	point
	)

extToAnyPoint() [2/2]

void KalFitAlg::extToAnyPoint	(	KalFitTrack &	trk,
		const HepPoint3D &	point
	)

fillTds() [1/2]

void KalFitAlg::fillTds	(	MdcRec_trk &	TrasanTRK,
		KalFitTrack &	track,
		RecMdcKalTrack *	trk,
		int	l_mass
	)

with results got at the inner Mdc hit

Definition at line 1333 of file KalFitAlg.cxx.

                                          {
 
    HepPoint3D IP(0,0,0);
    track.pivot(IP);
    // Fit quality
    int iqual(1);
    int trasster = TrasanTRK.nster, trakster = track.nster(),
        trasax(TrasanTRK.nhits-trasster), trakax(track.nchits()-trakster);
    if (TrasanTRK.nhits-track.nchits()>fitnocut_ || 
            TrasanTRK.helix[2]*track.a()[2]<0)
        iqual = 0;
 
    if (debug_ == 4) {
        cout<< "trasster trakster trasax trakax  TrasK      trackK  iqual"<<endl
            <<trasster<<"        "<<trakster<<"        "<<trasax<<"        "<<trakax
            <<"   "<<TrasanTRK.helix[2]<<"   "<<track.a()[2]<<"   "<<iqual<<endl;  
        cout<<"FillTds> track.chiSq..."<<track.chiSq()<<" nchits "<<track.nchits()
            <<" nster "<<track.nster()<<" iqual "<<iqual<<" track.Ea "<< track.Ea()<<endl; 
 
        cout<<"fillTds>.....track.Ea[2][2] "<<track.Ea()[2][2]<<endl;
        cout << " TRASAN stereo = " << trasster
            << " and KalFitTrack = " << trakster << std::endl;
        cout << " TRASAN axial = " << trasax 
            << " and KalFitTrack = " << trakax << std::endl;
 
        if (!iqual) {
            cout << "...there is a problem during fit !! " << std::endl;
            if (trasster-trakster>5) 
                cout << " because stereo " << trasster-trakster << std::endl;
            if (trasax-trakax >5)   
                cout << " because axial " << std::endl;
            if (TrasanTRK.helix[2]*track.a()[2]<0)
                cout << " because kappa sign " << std::endl;
        }
    }
    // Protection : if any problem, we keep the original information !!!!
    if (track.nchits() > 5 && track.nster() > 1 && 
            track.nchits()-track.nster() > 2 && track.chiSq() > 0 &&
            track.Ea()[0][0] > 0 && track.Ea()[1][1] > 0 && 
            track.Ea()[2][2] > 0 && track.Ea()[3][3] > 0 && 
            track.Ea()[4][4] > 0 && iqual) {
        if(debug_ == 4) cout<<"fillTds>.....going on "<<endl;
        trk->setStat(0,0,l_mass);
        trk->setMass(track.mass(),l_mass);
 
        // chisq & ndf 
        trk->setChisq(track.chiSq(),0,l_mass);
        trk->setNdf(track.nchits()-5,0,l_mass);
        trk->setNhits(track.nchits(),l_mass);
 
        trk->setFHelix(track.a(),l_mass);
        trk->setFError(track.Ea(),l_mass);
 
    } else {
 
        if(debug_) cout<<"ALARM: FillTds Not refit with KalFilter!!!"<<endl;
        // NOT refit with Kalman filter :
        trk->setStat(1,0,l_mass);
        trk->setMass(KalFitTrack::mass(l_mass),l_mass);
        // chisq & ndf (0 : filter ; 1 : smoother;)
        trk->setChisq(TrasanTRK.chiSq,0,l_mass);
        trk->setNdf(TrasanTRK.nhits-5,0,l_mass);
        // nhits  
        trk->setNhits(TrasanTRK.nhits,l_mass);
        double a_trasan[5], ea_trasan[15];
        for( int i =0 ; i <5; i++){
            a_trasan[i] = TrasanTRK.helix[i];
        }
        for( int j =0 ; j <15; j++){
            ea_trasan[j] = TrasanTRK.error[j];
        }
        trk->setFHelix(a_trasan, l_mass);
        trk->setFError(ea_trasan,l_mass);
    }
}

Referenced by complete_track().

fillTds() [2/2]

void KalFitAlg::fillTds	(	MdcRec_trk &	TrasanTRK,
		KalFitTrack &	track,
		RecMdcKalTrack *	trk,
		int	l_mass
	)

with results got at the inner Mdc hit

fillTds_back() [1/6]

void KalFitAlg::fillTds_back	(	KalFitTrack &	track,
		RecMdcKalTrack *	trk,
		MdcRec_trk &	TrasanTRK,
		int	l_mass
	)

with results got at the outer Mdc hit

right???

Definition at line 1643 of file KalFitAlg.cxx.

{
 
    HepPoint3D IP(0,0,0);
    //track.pivot(IP);
 
    // Fit quality
    int iqual(1);
 
    if ((trk->getNdf(0,l_mass))-(track.ndf_back()-5)>5)   iqual = 0;
 
    if(debug_ == 4) cout<< "fillTds_back> mass "<<trk->getMass(2)<<" ndf[0] "<<trk->getNdf(0,2)<<endl;
    if(debug_ == 4) cout<<"ndf_back  "<< track.ndf_back() << " chi2_back " << track.chiSq_back()<<endl;
 
    if (track.ndf_back() > 5 && track.chiSq_back() > 0 &&
            track.Ea()[0][0] > 0 && track.Ea()[1][1] > 0 && 
            track.Ea()[2][2] > 0 && track.Ea()[3][3] > 0 && 
            track.Ea()[4][4] > 0 && fabs(track.a()[0]) < DBL_MAX && 
            fabs(track.a()[1]) < DBL_MAX && fabs(track.a()[2]) < DBL_MAX && 
            fabs(track.a()[3]) < DBL_MAX && fabs(track.a()[4]) < DBL_MAX &&
            iqual) {
 
        // chisq ( for backward filter)
 
        trk->setStat(0,1,l_mass);
        trk->setChisq(track.chiSq_back(),1,l_mass);
        trk->setNdf(track.ndf_back()-5,1,l_mass);
        trk->setLength(track.pathip(),l_mass);
        if(debug_ == 4) cout<<"l_mass "<<l_mass<<" path set as "<<track.pathip()<<endl;      
        trk->setTof(track.tof(),l_mass);
 
        if (KalFitTrack::tofall_){
            if(l_mass == 3) trk->setTof(track.tof_kaon(),l_mass);
            if(l_mass == 4) trk->setTof(track.tof_proton(),l_mass);
        }
 
        // Path length in each MDC layer :
        if (pathl_) 
            for (int i = 0; i<43; i++) {
                trk->setPathl(track.pathl()[i],i);
            }
 
        trk->setLHelix(track.a(),l_mass);
        trk->setLError(track.Ea(),l_mass);
        trk->setLPivot(track.pivot(),l_mass);
 
        trk->setLPoint(track.point_last(),l_mass);  
        trk->setPathSM(track.getPathSM(),l_mass);
        trk->setTof(track.getTofSM(),l_mass);
        trk->setFiTerm(track.getFiTerm(),l_mass);
 
        if(4 == debug_){
            std::cout<<" last pivot: "<< trk->getLPivot(0)<<std::endl;
            std::cout<<" pathl in SM: "<< trk->getPathSM(0)<<std::endl;
            std::cout<<" fiTerm: "<< trk->getFiTerm(0)<<std::endl;    
            std::cout<<" last point: "<< trk->getLPoint(0)<<std::endl;
        }
 
    } else {
        if(debug_) cout<<"ALARM: FillTds_back Not refit with KalFilter!!!"<<endl;
        // NOT refit with Kalman filter :
        trk->setStat(1,1,l_mass);
        HepPoint3D piv(TrasanTRK.pivot[0],
                TrasanTRK.pivot[1],
                TrasanTRK.pivot[2]);
 
        HepVector a(5);
        for(int i = 0; i < 5; i++)
            a[i] = TrasanTRK.helix[i];
 
        HepSymMatrix ea(5);
        for(int i = 0, k = 0; i < 5; i++) {
            for(int j = 0; j <= i; j++) {
                ea[i][j] = matrixg_*TrasanTRK.error[k++];
                ea[j][i] = ea[i][j];
            }
        }
 
        KalFitTrack track_rep(piv, a, ea, lead_, 
                TrasanTRK.chiSq, TrasanTRK.nhits);
        double fiTerm = TrasanTRK.fiTerm;
 
        double fi0 = track_rep.phi0();
        HepPoint3D  xc(track_rep.kappa()/fabs(track_rep.kappa())* 
                track_rep.center() );
        double x = xc.x();
        double y = xc.y();
        double phi_x;
        if( fabs( x ) > 1.0e-10 ){
            phi_x = atan2( y, x );
            if( phi_x < 0 ) phi_x += 2*M_PI;
        } else {
            phi_x = ( y > 0 ) ? M_PI_4: 3.0*M_PI_4;
        }
        if(debug_ == 4) cout<<"fiterm "<<fiTerm<<" fi0 "<<fi0<<" phi_x "<<phi_x<<endl;
        double dphi = fabs( fiTerm + fi0 - phi_x );
        if( dphi >= 2*M_PI ) dphi -= 2*M_PI;
        double tanl = track_rep.tanl();
        double cosl_inv = sqrt( tanl*tanl + 1.0 );
        if(debug_ == 4) { 
            cout<<"tanl= "<<tanl<<" radius "<<track_rep.radius()<<" dphi "<<dphi<<endl;
            cout<<" cosl_inv  "<<cosl_inv<<"  radius_numf  "<<track_rep.radius_numf()<<endl;
        }
        double track_len(fabs( track_rep.radius() * dphi * cosl_inv ));
        double light_speed( 29.9792458 );     // light speed in cm/nsec
        double pt( 1.0 / track_rep.kappa() );
        double p( pt * sqrt( 1.0 + tanl*tanl ) );
 
        // chisq (2 : for backward filter)
        trk->setStat(1,1,l_mass);
        trk->setChisq(TrasanTRK.chiSq,1,l_mass);
        if(debug_ == 4) {
            std::cout<<".....fillTds_back...chiSq..."<< TrasanTRK.chiSq<<endl;
            std::cout<<"...track_len..."<<track_len<<" ndf[1] "<< trk->getNdf(0,l_mass)<<endl;
        }
        trk->setNdf(TrasanTRK.nhits-5,1,l_mass);
        trk->setLength(track_len,l_mass);
        double mass_over_p( KalFitTrack::mass(l_mass)/ p );
        double beta( 1.0 / sqrt( 1.0 + mass_over_p * mass_over_p ) );
        trk->setTof(track_len / ( light_speed * beta ), l_mass) ;
 
        track_rep.pivot(IP);
 
        trk->setLHelix(track_rep.a(),l_mass);      
        trk->setLError(track_rep.Ea(),l_mass);
        trk->setLPivot(track.pivot(),l_mass);
 
        /// right???
        trk->setLPoint(track.point_last(),l_mass);
        trk->setPathSM(track.getPathSM(),l_mass);
        trk->setTof(track.getTofSM(),l_mass);
        trk->setFiTerm(track.getFiTerm(),l_mass);
    }
 
    // test--------
    if(debug_ == 4) {
 
        std::cout<<" last point: "<< trk->getLPoint(0)<<std::endl;
        std::cout<<" pathl in SM: "<< trk->getPathSM(0)<<std::endl;
        std::cout<<" fiTerm: "<< trk->getFiTerm(0)<<std::endl;
 
        cout<<"Now let us see results after smoothering at IP:........."<<endl;
        cout << " dr = " << track.a()[0] 
            << ", Er_dr = " << sqrt(track.Ea()[0][0]) << std::endl;
        cout<< " phi0 = " << track.a()[1] 
            << ", Er_phi0 = " << sqrt(track.Ea()[1][1]) << std::endl;
        cout << " PT = " << 1/track.a()[2] 
            << ", Er_kappa = " << sqrt(track.Ea()[2][2]) << std::endl;
        cout << " dz = " << track.a()[3] 
            << ", Er_dz = " << sqrt(track.Ea()[3][3]) << std::endl;
        cout << " tanl = " << track.a()[4] 
            << ", Er_tanl = " << sqrt(track.Ea()[4][4]) << std::endl;
        cout << " Ea = " << track.Ea() <<endl;
    }
    // test end ----------
}

Referenced by complete_track().

fillTds_back() [2/6]

void KalFitAlg::fillTds_back	(	KalFitTrack &	track,
		RecMdcKalTrack *	trk,
		MdcRec_trk &	TrasanTRK,
		int	l_mass
	)

with results got at the outer Mdc hit

fillTds_back() [3/6]

void KalFitAlg::fillTds_back	(	KalFitTrack &	track,
		RecMdcKalTrack *	trk,
		MdcRec_trk &	TrasanTRK,
		int	l_mass,
		RecMdcKalHelixSegCol *	segcol
	)

right???

Definition at line 1801 of file KalFitAlg.cxx.

{
 
    HepPoint3D IP(0,0,0);
 
    // attention  the pivot problem of the HelixSeg ... ???
    track.pivot(IP);
    // Fit quality
    //int iqual(1);
    //if ((trk->getNdf(0,2))-(track.ndf_back()-5)>5)
    // form getNdf(0,2) to getNdf(0,1) for muon hypothesis  
 
    if ((trk->getNdf(0,l_mass))-(track.ndf_back()-5)>5){
        iqual_back_ = 0;
    }
    if(usage_>1){
        for(int i=0; i<5; i++) iqual_front_[i] = 1;
        iqual_back_ = 1;
    }
    if(debug_ == 4){ 
        std::cout<< "fillTds_back> mass "<<trk->getMass(2)<<" ndf[0][l_mass] "<<trk->getNdf(0,l_mass)<<endl;
        std::cout<<"ndf_back  "<< track.ndf_back() << " chi2_back " << track.chiSq_back()<<endl;
        std::cout<<"track.ndf_back(), track.chiSq_back(), track.Ea()[5][5], track.a()[5], iqual_front_, iqual_back_: "<<track.ndf_back()<<" , "<<track.chiSq_back()<<" , "<<track.Ea()<<" , "<<track.a()<<" , "<<iqual_front_[l_mass]<<" , "<<iqual_back_<<std::endl;
    } 
 
    if (track.ndf_back() > 5 && track.chiSq_back() > 0 &&
            track.Ea()[0][0] > 0 && track.Ea()[1][1] > 0 && 
            track.Ea()[2][2] > 0 && track.Ea()[3][3] > 0 && 
            track.Ea()[4][4] > 0 && fabs(track.a()[0]) < DBL_MAX && 
            fabs(track.a()[1]) < DBL_MAX && fabs(track.a()[2]) < DBL_MAX && 
            fabs(track.a()[3]) < DBL_MAX && fabs(track.a()[4]) < DBL_MAX && iqual_front_[l_mass] && iqual_back_){ 
 
        // chisq ( for backward filter)
        //std::cout<<"begin to fillTds_back track no. : "<<(++Tds_back_no)<<std::endl;
 
 
        HelixSegRefVec helixsegrefvec;
        for (vector<KalFitHelixSeg>::iterator it = track.HelixSegs().begin(); it!=track.HelixSegs().end();it ++)
        {
 
            //std::cout<<" alpha of KalFitHelixSeg: "<<it->alpha()<<std::endl;   
            //std::cout<<" doca1 of KalFitHelixSeg: "<<(it->approach(*(it->HitMdc()),false))<<std::endl;
 
            it->pivot(IP);
 
            //std::cout<<" doca2 of KalFitHelixSeg: "<<(it->approach(*(it->HitMdc()),false))<<std::endl;
 
            RecMdcKalHelixSeg* helixseg = new RecMdcKalHelixSeg;
            helixseg->setResIncl(it->residual_include());
            helixseg->setResExcl(it->residual_exclude());    
            if(debug_ == 4) { 
                std::cout<<"helixseg->Res_inc ..."<<helixseg->getResIncl()<<std::endl;
            }
            helixseg->setDrIncl(it->a_include()[0]);  
            helixseg->setFi0Incl(it->a_include()[1]);  
            helixseg->setCpaIncl(it->a_include()[2]);  
            helixseg->setDzIncl(it->a_include()[3]);  
            helixseg->setTanlIncl(it->a_include()[4]);
 
 
            helixseg->setDrExcl(it->a_exclude()[0]);
            helixseg->setFi0Excl(it->a_exclude()[1]);         
            helixseg->setCpaExcl(it->a_exclude()[2]);                
            helixseg->setDzExcl(it->a_exclude()[3]);                     
            helixseg->setTanlExcl(it->a_exclude()[4]);                   
 
            helixseg->setHelixIncl(it->a_include());
            helixseg->setErrorIncl(it->Ea_include());
 
            //Helix temp(IP, it->a(), it->Ea());
 
            //std::cout<<" doca3 of KalFitHelixSeg: "<<(temp.approach(*(it->HitMdc()),false))<<std::endl;
 
            helixseg->setHelixExcl(it->a_exclude());
            helixseg->setErrorExcl(it->Ea_exclude());
            helixseg->setLayerId(it->layer());
 
            if(debug_ == 4) {
                std::cout<<"KalFitHelixSeg track id .."<<it->HitMdc()->rechitptr()->getTrkId()<<std::endl; 
                std::cout<<"helixseg a: "<<it->a()<<std::endl;
                std::cout<<"helixseg a_excl: "<<helixseg->getHelixExcl()<<std::endl;
                std::cout<<"helixseg a_incl: "<<helixseg->getHelixIncl()<<std::endl;
 
                std::cout<<"helixseg Ea: "<<it->Ea()<<std::endl;
                std::cout<<"helixseg Ea_excl: "<<helixseg->getErrorExcl()<<std::endl;
                std::cout<<"helixseg Ea_incl: "<<helixseg->getErrorIncl()<<std::endl;
 
                std::cout<<"helixseg layer: "<<it->layer()<<std::endl;
            }    
 
 
            helixseg->setTrackId(it->HitMdc()->rechitptr()->getTrkId());
            helixseg->setMdcId(it->HitMdc()->rechitptr()->getMdcId());
            helixseg->setFlagLR(it->HitMdc()->LR());
            helixseg->setTdc(it->HitMdc()->rechitptr()->getTdc());
            helixseg->setAdc(it->HitMdc()->rechitptr()->getAdc());
            helixseg->setZhit(it->HitMdc()->rechitptr()->getZhit());
            helixseg->setTof(it->tof());
            helixseg->setDocaIncl(it->doca_include());
            helixseg->setDocaExcl(it->doca_exclude());
            helixseg->setDD(it->dd());
            helixseg->setEntra(it->HitMdc()->rechitptr()->getEntra());
            helixseg->setDT(it->dt());
            segcol->push_back(helixseg);
            SmartRef<RecMdcKalHelixSeg> refhelixseg(helixseg);
            helixsegrefvec.push_back(refhelixseg);
 
            if(ntuple_&8){
                m_docaInc = helixseg -> getDocaIncl();
                m_docaExc = helixseg -> getDocaExcl();
                m_residualInc = helixseg -> getResIncl();
                m_residualExc = helixseg -> getResExcl();
                m_dd = helixseg -> getDD();
                m_lr = helixseg->getFlagLR();
                m_tdrift = helixseg -> getDT();
                m_layerid = helixseg -> getLayerId();
                m_yposition= it->HitMdc()->wire().fwd().y();
                m_eventNo = eventNo;
                StatusCode sc6 = m_nt6->write();
                if( sc6.isFailure() ) cout<<"Ntuple6 helixseg filling failed!"<<endl;
 
            }
        }
 
        trk->setVecHelixSegs(helixsegrefvec, l_mass); 
        if(debug_ == 4) {
            std::cout<<"trk->getVecHelixSegs size..."<<(trk->getVecHelixSegs()).size()<<std::endl;
        }
        trk->setStat(0,1,l_mass);
        trk->setChisq(track.chiSq_back(),1,l_mass);
        trk->setNdf(track.ndf_back()-5,1,l_mass);
        //   add setNhits ,maybe some problem
        trk->setNhits(track.ndf_back(),l_mass);
        if(!(track.ndf_back()==track.HelixSegs().size())) {
            std::cout<<"THEY ARE NOT EQUALL!!!"<<std::endl;
        } 
        trk->setLength(track.pathip(),l_mass);
        if(debug_ == 4) {
            std::cout<<"l_mass "<<l_mass<<" path set as "<<track.pathip()<<endl;      
        }   
        trk->setTof(track.tof(),l_mass);
        if (KalFitTrack::tofall_){
            if(l_mass == 3) trk->setTof(track.tof_kaon(),l_mass);
            if(l_mass == 4) trk->setTof(track.tof_proton(),l_mass);
        }
        // Path length in each MDC layer :
        if (pathl_) 
            for (int i = 0; i<43; i++) {
                trk->setPathl(track.pathl()[i],i);
            }
        trk->setLHelix(track.a(),l_mass);
        trk->setLError(track.Ea(),l_mass);
        trk->setLPivot(track.pivot(),l_mass);
 
        trk->setLPoint(track.point_last(),l_mass);
        trk->setPathSM(track.getPathSM(),l_mass);
        trk->setTof(track.getTofSM(),l_mass);
        trk->setFiTerm(track.getFiTerm(),l_mass);
        double a_trasan[5], ea_trasan[15];
        for( int i =0 ; i <5; i++){
            a_trasan[i] = TrasanTRK.helix[i];
        }
        for( int j =0 ; j <15; j++){
            ea_trasan[j] = TrasanTRK.helix[j];
        }
        trk->setTHelix(a_trasan);
        trk->setTError(ea_trasan);
 
        if(4 == debug_){
            std::cout<<" last pivot: "<< trk->getLPivot(0)<<std::endl;
            std::cout<<" pathl in SM: "<< trk->getPathSM(0)<<std::endl;
            std::cout<<" fiTerm: "<< trk->getFiTerm(0)<<std::endl;
            std::cout<<" last point: "<< trk->getLPoint(0)<<std::endl;
        }
 
    } else {
 
        if(debug_) cout<<"ALARM: FillTds_back Not refit with KalFilter!!!"<<endl;
        // NOT refit with Kalman filter :
        trk->setStat(1,1,l_mass);
 
        HepPoint3D piv(TrasanTRK.pivot[0],
                TrasanTRK.pivot[1],
                TrasanTRK.pivot[2]);
 
        HepVector a(5);
        for(int i = 0; i < 5; i++)
            a[i] = TrasanTRK.helix[i];
 
        HepSymMatrix ea(5);
        for(int i = 0, k = 0; i < 5; i++) {
            for(int j = 0; j <= i; j++) {
                ea[i][j] = matrixg_*TrasanTRK.error[k++];
                ea[j][i] = ea[i][j];
            }
        }
 
        KalFitTrack track_rep(piv, a, ea, lead_, 
                TrasanTRK.chiSq, TrasanTRK.nhits);
        double fiTerm = TrasanTRK.fiTerm;
 
        double fi0 = track_rep.phi0();
        HepPoint3D  xc(track_rep.kappa()/fabs(track_rep.kappa())* 
                track_rep.center() );
        double x = xc.x();
        double y = xc.y();
        double phi_x;
        if( fabs( x ) > 1.0e-10 ){
            phi_x = atan2( y, x );
            if( phi_x < 0 ) phi_x += 2*M_PI;
        } else {
            phi_x = ( y > 0 ) ? M_PI_4: 3.0*M_PI_4;
        }
        if(debug_ == 4) cout<<"fiterm "<<fiTerm<<" fi0 "<<fi0<<" phi_x "<<phi_x<<endl;
        double dphi = fabs( fiTerm + fi0 - phi_x );
        if( dphi >= 2*M_PI ) dphi -= 2*M_PI;
        double tanl = track_rep.tanl();
        double cosl_inv = sqrt( tanl*tanl + 1.0 );
        if(debug_ == 4) { 
            cout<<"tanl= "<<tanl<<" radius "<<track_rep.radius()<<" dphi "<<dphi<<endl;
            cout<<" cosl_inv  "<<cosl_inv<<"  radius_numf  "<<track_rep.radius_numf()<<endl;
        }
        double track_len(fabs( track_rep.radius() * dphi * cosl_inv ));
        double light_speed( 29.9792458 );     // light speed in cm/nsec
        double pt( 1.0 / track_rep.kappa() );
        double p( pt * sqrt( 1.0 + tanl*tanl ) );
 
 
        // chisq (2 : for backward filter)
 
        trk->setStat(1,1,l_mass);
        trk->setChisq(TrasanTRK.chiSq,1,l_mass);
        if(debug_ == 4) { 
            std::cout<<".....fillTds_back...chiSq..."<< TrasanTRK.chiSq<<std::endl;
            std::cout<<"...track_len..."<<track_len<<" ndf[1] "<< trk->getNdf(0,l_mass)<<std::endl;
        }    
        trk->setNdf(TrasanTRK.nhits-5,1,l_mass);
        trk->setLength(track_len,l_mass);
        double mass_over_p( KalFitTrack::mass(l_mass)/ p );
        double beta( 1.0 / sqrt( 1.0 + mass_over_p * mass_over_p ) );
        trk->setTof(track_len / ( light_speed * beta ), l_mass) ;
 
        track_rep.pivot(IP);
 
        trk->setLHelix(track_rep.a(),l_mass);         
        trk->setLError(track_rep.Ea(),l_mass);
        trk->setLPivot(track.pivot(),l_mass);
 
        /// right???
        trk->setLPoint(track.point_last(),l_mass);
        trk->setPathSM(track.getPathSM(),l_mass);
        trk->setTof(track.getTofSM(),l_mass);
        trk->setFiTerm(track.getFiTerm(),l_mass);
        trk->setTHelix(track_rep.a());         
        trk->setTError(track_rep.Ea());
 
    }
 
    // test--------
    if(debug_ == 4) {
        cout<<"Now let us see results after smoothering at IP:........."<<endl;
        cout << " dr = " << track.a()[0] 
            << ", Er_dr = " << sqrt(track.Ea()[0][0]) << std::endl;
        cout<< " phi0 = " << track.a()[1] 
            << ", Er_phi0 = " << sqrt(track.Ea()[1][1]) << std::endl;
        cout << " PT = " << 1/track.a()[2] 
            << ", Er_kappa = " << sqrt(track.Ea()[2][2]) << std::endl;
        cout << " dz = " << track.a()[3] 
            << ", Er_dz = " << sqrt(track.Ea()[3][3]) << std::endl;
        cout << " tanl = " << track.a()[4] 
            << ", Er_tanl = " << sqrt(track.Ea()[4][4]) << std::endl;
        cout << " Ea = " << track.Ea() <<endl;
    }
    // test end ----------
}

fillTds_back() [4/6]

void KalFitAlg::fillTds_back	(	KalFitTrack &	track,
		RecMdcKalTrack *	trk,
		MdcRec_trk &	TrasanTRK,
		int	l_mass,
		RecMdcKalHelixSegCol *	segcol
	)

fillTds_back() [5/6]

void KalFitAlg::fillTds_back	(	KalFitTrack &	track,
		RecMdcKalTrack *	trk,
		MdcRec_trk &	TrasanTRK,
		int	l_mass,
		RecMdcKalHelixSegCol *	segcol,
		int	smoothflag
	)

for smoother process

right???

Definition at line 2079 of file KalFitAlg.cxx.

{
 
    HepPoint3D IP(0,0,0);
 
    // attention  the pivot problem of the HelixSeg ... ???
    //track.pivot(IP);
    // Fit quality
    //int iqual(1);
    //if ((trk->getNdf(0,2))-(track.ndf_back()-5)>5)
    // form getNdf(0,2) to getNdf(0,1) for muon hypothesis  
 
    iqual_back_ = 1;
    if ((trk->getNdf(0,l_mass))-(track.ndf_back()-5)>5){
        iqual_back_ = 0;
    }
 
    if(debug_ == 4){ 
        std::cout<< "fillTds_back> mass "<<trk->getMass(2)<<" ndf[0][l_mass] "<<trk->getNdf(0,l_mass)<<endl;
        std::cout<<"ndf_back  "<< track.ndf_back() << " chi2_back " << track.chiSq_back()<<endl;
    } 
 
 
    if (track.ndf_back() > 5 && track.chiSq_back() > 0 &&
            track.Ea()[0][0] > 0 && track.Ea()[1][1] > 0 && 
            track.Ea()[2][2] > 0 && track.Ea()[3][3] > 0 && 
            track.Ea()[4][4] > 0 && fabs(track.a()[0]) < DBL_MAX && 
            fabs(track.a()[1]) < DBL_MAX && fabs(track.a()[2]) < DBL_MAX && 
            fabs(track.a()[3]) < DBL_MAX && fabs(track.a()[4]) < DBL_MAX && iqual_front_[l_mass] && iqual_back_){ 
 
        // chisq ( for backward filter)
        //std::cout<<"begin to fillTds_back track no. : "<<(++Tds_back_no)<<std::endl;
 
 
        HelixSegRefVec helixsegrefvec;
        for (vector<KalFitHelixSeg>::iterator it = track.HelixSegs().begin(); it!=track.HelixSegs().end();it ++)
        {
 
            //std::cout<<" alpha of KalFitHelixSeg: "<<it->alpha()<<std::endl;   
            //std::cout<<" doca1 of KalFitHelixSeg: "<<(it->approach(*(it->HitMdc()),false))<<std::endl;
 
            it->pivot(IP);
 
            //std::cout<<" doca2 of KalFitHelixSeg: "<<(it->approach(*(it->HitMdc()),false))<<std::endl;
 
            RecMdcKalHelixSeg* helixseg = new RecMdcKalHelixSeg;
            helixseg->setResIncl(it->residual_include());
            helixseg->setResExcl(it->residual_exclude());    
            if(debug_ == 4) { 
                std::cout<<"helixseg->Res_inc ..."<<helixseg->getResIncl()<<std::endl;
            }
            //  helixseg->setDrIncl(it->a_include()[0]);  
            //  helixseg->setFi0Incl(it->a_include()[1]);  
            //  helixseg->setCpaIncl(it->a_include()[2]);  
            //  helixseg->setDzIncl(it->a_include()[3]);  
            //  helixseg->setTanlIncl(it->a_include()[4]);
            //
            //
            //      helixseg->setDrExcl(it->a_exclude()[0]);
            //      helixseg->setFi0Excl(it->a_exclude()[1]);         
            //  helixseg->setCpaExcl(it->a_exclude()[2]);                
            //  helixseg->setDzExcl(it->a_exclude()[3]);                     
            //  helixseg->setTanlExcl(it->a_exclude()[4]);                   
 
            helixseg->setHelixIncl(it->a_include());
            //helixseg->setErrorIncl(it->Ea_include());
 
            //Helix temp(IP, it->a(), it->Ea());
 
            //std::cout<<" doca3 of KalFitHelixSeg: "<<(temp.approach(*(it->HitMdc()),false))<<std::endl;
 
            helixseg->setHelixExcl(it->a_exclude());
            //helixseg->setErrorExcl(it->Ea_exclude());
            //helixseg->setLayerId(it->layer());
 
            if(debug_ == 4) {
                std::cout<<"KalFitHelixSeg track id .."<<it->HitMdc()->rechitptr()->getTrkId()<<std::endl; 
                std::cout<<"helixseg a: "<<it->a()<<std::endl;
                std::cout<<"helixseg a_excl: "<<helixseg->getHelixExcl()<<std::endl;
                std::cout<<"helixseg a_incl: "<<helixseg->getHelixIncl()<<std::endl;
 
                std::cout<<"helixseg Ea: "<<it->Ea()<<std::endl;
                std::cout<<"helixseg Ea_excl: "<<helixseg->getErrorExcl()<<std::endl;
                std::cout<<"helixseg Ea_incl: "<<helixseg->getErrorIncl()<<std::endl;
 
                std::cout<<"helixseg layer: "<<it->layer()<<std::endl;
            }    
 
 
            helixseg->setTrackId(it->HitMdc()->rechitptr()->getTrkId());
            helixseg->setMdcId(it->HitMdc()->rechitptr()->getMdcId());
            helixseg->setFlagLR(it->HitMdc()->LR());
            helixseg->setTdc(it->HitMdc()->rechitptr()->getTdc());
            helixseg->setAdc(it->HitMdc()->rechitptr()->getAdc());
            helixseg->setZhit(it->HitMdc()->rechitptr()->getZhit());
            helixseg->setTof(it->tof());
            helixseg->setDocaIncl(it->doca_include());
            helixseg->setDocaExcl(it->doca_exclude());
            helixseg->setDD(it->dd());
            helixseg->setEntra(it->HitMdc()->rechitptr()->getEntra());
            helixseg->setDT(it->dt());
            //cout<<"setDT( "<<it->dt()<<" )"<<endl;
            segcol->push_back(helixseg);
            SmartRef<RecMdcKalHelixSeg> refhelixseg(helixseg);
            helixsegrefvec.push_back(refhelixseg);
            if(ntuple_&8){
                m_docaInc = helixseg -> getDocaIncl();
                m_docaExc = helixseg -> getDocaExcl();
                m_residualInc = helixseg -> getResIncl();
                m_residualExc = helixseg -> getResExcl();
                m_dd = helixseg -> getDD();
                m_lr = helixseg->getFlagLR();
                m_tdrift = helixseg -> getDT();
                m_layerid = helixseg -> getLayerId();
                m_yposition= it->HitMdc()->wire().fwd().y();
                m_eventNo = eventNo;
                StatusCode sc6 = m_nt6->write();
                if( sc6.isFailure() ) cout<<"Ntuple6 helixseg filling failed!"<<endl;
 
            }
        }
 
        trk->setVecHelixSegs(helixsegrefvec, l_mass);
        //cout<<"setVecHelixSegs with Kalman hits"<<endl;
        if(debug_ == 4) {
            std::cout<<"trk->getVecHelixSegs size..."<<(trk->getVecHelixSegs()).size()<<std::endl;
        }
        trk->setStat(0,1,l_mass);
        trk->setChisq(track.chiSq_back(),1,l_mass);
        trk->setNdf(track.ndf_back()-5,1,l_mass);
        //   add setNhits ,maybe some problem
        trk->setNhits(track.ndf_back(),l_mass);
        if(!(track.ndf_back()==track.HelixSegs().size())) {
            std::cout<<"THEY ARE NOT EQUALL!!!"<<std::endl;
        } 
        trk->setLength(track.pathip(),l_mass);
        if(debug_ == 4) {
            std::cout<<"l_mass "<<l_mass<<" path set as "<<track.pathip()<<endl;      
        }   
        trk->setTof(track.tof(),l_mass);
        if (KalFitTrack::tofall_){
            if(l_mass == 3) trk->setTof(track.tof_kaon(),l_mass);
            if(l_mass == 4) trk->setTof(track.tof_proton(),l_mass);
        }
        // Path length in each MDC layer :
        if (pathl_) 
            for (int i = 0; i<43; i++) {
                trk->setPathl(track.pathl()[i],i);
            }
        trk->setLHelix(track.a(),l_mass);
        trk->setLError(track.Ea(),l_mass);
        trk->setLPivot(track.pivot(),l_mass);
 
        trk->setLPoint(track.point_last(),l_mass);
        trk->setPathSM(track.getPathSM(),l_mass);
        trk->setTof(track.getTofSM(),l_mass);
        trk->setFiTerm(track.getFiTerm(),l_mass);
        double a_trasan[5], ea_trasan[15];
        for( int i =0 ; i <5; i++){
            a_trasan[i] = TrasanTRK.helix[i];
        }
        for( int j =0 ; j <15; j++){
            ea_trasan[j] = TrasanTRK.helix[j];
        }
        trk->setTHelix(a_trasan);
        trk->setTError(ea_trasan);
 
        if(4 == debug_){
            std::cout<<" last pivot: "<< trk->getLPivot(0)<<std::endl;
            std::cout<<" pathl in SM: "<< trk->getPathSM(0)<<std::endl;
            std::cout<<" fiTerm: "<< trk->getFiTerm(0)<<std::endl;
            std::cout<<" last point: "<< trk->getLPoint(0)<<std::endl;
        }
 
    } else {
 
        if(debug_) cout<<"ALARM: FillTds_back Not refit with KalFilter!!!"<<endl;
        // NOT refit with Kalman filter :
        trk->setStat(1,1,l_mass);
 
        HepPoint3D piv(TrasanTRK.pivot[0],
                TrasanTRK.pivot[1],
                TrasanTRK.pivot[2]);
 
        HepVector a(5);
        for(int i = 0; i < 5; i++)
            a[i] = TrasanTRK.helix[i];
 
        HepSymMatrix ea(5);
        for(int i = 0, k = 0; i < 5; i++) {
            for(int j = 0; j <= i; j++) {
                ea[i][j] = matrixg_*TrasanTRK.error[k++];
                ea[j][i] = ea[i][j];
            }
        }
 
        KalFitTrack track_rep(piv, a, ea, lead_, 
                TrasanTRK.chiSq, TrasanTRK.nhits);
        double fiTerm = TrasanTRK.fiTerm;
 
        double fi0 = track_rep.phi0();
        HepPoint3D  xc(track_rep.kappa()/fabs(track_rep.kappa())* 
                track_rep.center() );
        double x = xc.x();
        double y = xc.y();
        double phi_x;
        if( fabs( x ) > 1.0e-10 ){
            phi_x = atan2( y, x );
            if( phi_x < 0 ) phi_x += 2*M_PI;
        } else {
            phi_x = ( y > 0 ) ? M_PI_4: 3.0*M_PI_4;
        }
        if(debug_ == 4) cout<<"fiterm "<<fiTerm<<" fi0 "<<fi0<<" phi_x "<<phi_x<<endl;
        double dphi = fabs( fiTerm + fi0 - phi_x );
        if( dphi >= 2*M_PI ) dphi -= 2*M_PI;
        double tanl = track_rep.tanl();
        double cosl_inv = sqrt( tanl*tanl + 1.0 );
        if(debug_ == 4) { 
            cout<<"tanl= "<<tanl<<" radius "<<track_rep.radius()<<" dphi "<<dphi<<endl;
            cout<<" cosl_inv  "<<cosl_inv<<"  radius_numf  "<<track_rep.radius_numf()<<endl;
        }
        //double track_len(fabs( track_rep.radius() * dphi * cosl_inv ));
        double track_len(fabs( track_rep.radius() * fiTerm * cosl_inv )); // 2010-11-26 added by wangll
        //cout<<"track radius : "<<track_rep.radius()<<"  "<<track.radius()<<endl;
        double light_speed( 29.9792458 );     // light speed in cm/nsec
        double pt( 1.0 / track_rep.kappa() );
        double p( pt * sqrt( 1.0 + tanl*tanl ) );
 
 
        // chisq (2 : for backward filter)
 
        trk->setStat(1,1,l_mass);
        trk->setChisq(TrasanTRK.chiSq,1,l_mass);
        if(debug_ == 4) { 
            std::cout<<".....fillTds_back...chiSq..."<< TrasanTRK.chiSq<<std::endl;
            std::cout<<"...track_len..."<<track_len<<" ndf[1] "<< trk->getNdf(0,l_mass)<<std::endl;
        }    
        trk->setNdf(TrasanTRK.nhits-5,1,l_mass);
        trk->setLength(track_len,l_mass);
        double mass_over_p( KalFitTrack::mass(l_mass)/ p );
        double beta( 1.0 / sqrt( 1.0 + mass_over_p * mass_over_p ) );
        trk->setTof(track_len / ( light_speed * beta ), l_mass) ;
 
        //track_rep.pivot(IP);
        HepPoint3D LPiovt = track_rep.x(fiTerm);
        track_rep.pivot(LPiovt);
 
        trk->setLHelix(track_rep.a(),l_mass);         
        trk->setLError(track_rep.Ea(),l_mass);
        //trk->setLPivot(track.pivot(),l_mass); // commented 2010-09-02
        //trk->setLPivot(IP, l_mass); // add 2010-09-02
        trk->setLPivot(LPiovt, l_mass); // add 2010-11-25
 
        /// right???
        trk->setLPoint(track.point_last(),l_mass);
        //trk->setPathSM(track.getPathSM(),l_mass);// commented 2010-11-25 by wangll
        trk->setPathSM(track_len,l_mass);// added 2010-11-25 by wangll
        //trk->setTof(track.getTofSM(),l_mass);// commented 2010-11-25 by wangll
        // trk->setFiTerm(track.getFiTerm(),l_mass); // commented 2010-11-25 by wangll
        trk->setFiTerm(fiTerm,l_mass); // added by wangll 2010-11-25
        trk->setTHelix(track_rep.a());         
        trk->setTError(track_rep.Ea());
 
        /*
        // --- check track id   by wangll 2010-08-15
        if(l_mass==lead_) {
        //cout<<" ----- bad smooth track -----"<<endl;
        //cout<<"l_mass = "<<l_mass<<endl;
        int trkId = trk->trackId();
        //
        // cout<<"track id = "<<trkId<<endl;
        // cout<<"THelix: "<<trk->getTHelix()<<endl;
        // cout<<"FHelix: "<<trk->getFHelix()<<endl;
        // cout<<"size of VecHelixSegs: "<<trk->getVecHelixSegs().size()<<endl;
        // 
        SmartDataPtr<RecMdcTrackCol> mdcTrkCol(eventSvc(),"/Event/Recon/RecMdcTrackCol");
        //int nMdcTrk = mdcTrkCol.size();
        //cout<<"number of Mdc Tracks: "<<nMdcTrk<<endl;
        RecMdcTrackCol::iterator iter_mdcTrk = mdcTrkCol->begin();
        bool findMdcTrk = false;
        for(; iter_mdcTrk != mdcTrkCol->end(); iter_mdcTrk++) {
        if(trkId==(*iter_mdcTrk)->trackId()) {
        findMdcTrk = true;
        break;
        }
        }
        if(findMdcTrk) {
        HitRefVec mdcVecHits = (*iter_mdcTrk)->getVecHits();
        int nHits = mdcVecHits.size();
        //cout<<"number of Mdc Hits: "<<nHits<<endl;
        HelixSegRefVec helixsegrefvec;
        HitRefVec::iterator iter_mdcHit = mdcVecHits.begin();
        for(int iii=0; iter_mdcHit!=mdcVecHits.end(); iter_mdcHit++,iii++) {
        RecMdcKalHelixSeg* helixseg = new RecMdcKalHelixSeg;
        //cout<<"hit "<<iii<<endl;
        //cout<<"getMdcId: "<<(*iter_mdcHit)->getMdcId()<<endl;
        //cout<<"getAdc: "<<(*iter_mdcHit)->getAdc()<<endl;
        //cout<<"getTdc: "<<(*iter_mdcHit)->getTdc()<<endl;
        //cout<<"getDriftT: "<<(*iter_mdcHit)->getDriftT()<<endl;
        //cout<<"getZhit: "<<(*iter_mdcHit)->getZhit()<<endl;
        //cout<<"getFlagLR: "<<(*iter_mdcHit)->getFlagLR()<<endl;
        //cout<<"getDriftDistLeft: "<<(*iter_mdcHit)->getDriftDistLeft()<<endl;
        //cout<<"getDriftDistRight: "<<(*iter_mdcHit)->getDriftDistRight()<<endl;
        //cout<<"getDoca: "<<(*iter_mdcHit)->getDoca()<<endl;
        //cout<<"getEntra: "<<(*iter_mdcHit)->getEntra()<<endl;
        // 
        helixseg->setMdcId((*iter_mdcHit)->getMdcId());
        helixseg->setAdc((*iter_mdcHit)->getAdc());
        helixseg->setTdc((*iter_mdcHit)->getTdc());
        helixseg->setZhit((*iter_mdcHit)->getZhit());
        helixseg->setFlagLR((*iter_mdcHit)->getFlagLR());
        if((*iter_mdcHit)->getFlagLR()==0) helixseg->setDD((*iter_mdcHit)->getDriftDistLeft());
        if((*iter_mdcHit)->getFlagLR()==1) helixseg->setDD((*iter_mdcHit)->getDriftDistRight());
        helixseg->setDocaIncl((*iter_mdcHit)->getDoca());
        helixseg->setEntra((*iter_mdcHit)->getEntra());
        helixseg->setDT((*iter_mdcHit)->getDriftT());
        segcol->push_back(helixseg);
        SmartRef<RecMdcKalHelixSeg> refhelixseg(helixseg);
        helixsegrefvec.push_back(refhelixseg);
        }
        trk->setVecHelixSegs(helixsegrefvec); 
        cout<<"setVecHelixSegs with Mdc hits"<<endl;
        }
        else cout<<"not find the Mdc Track!";       
        //cout<<"size of VecHelixSegs: "<<trk->getVecHelixSegs().size()<<endl;
        }
        */
 
    }
 
    // test--------
    if(debug_ == 4) {
        cout<<"Now let us see results after smoothering at IP:........."<<endl;
        cout << " dr = " << track.a()[0] 
            << ", Er_dr = " << sqrt(track.Ea()[0][0]) << std::endl;
        cout<< " phi0 = " << track.a()[1] 
            << ", Er_phi0 = " << sqrt(track.Ea()[1][1]) << std::endl;
        cout << " PT = " << 1/track.a()[2] 
            << ", Er_kappa = " << sqrt(track.Ea()[2][2]) << std::endl;
        cout << " dz = " << track.a()[3] 
            << ", Er_dz = " << sqrt(track.Ea()[3][3]) << std::endl;
        cout << " tanl = " << track.a()[4] 
            << ", Er_tanl = " << sqrt(track.Ea()[4][4]) << std::endl;
        cout << " Ea = " << track.Ea() <<endl;
    }
    // test end ----------
}

fillTds_back() [6/6]

void KalFitAlg::fillTds_back	(	KalFitTrack &	track,
		RecMdcKalTrack *	trk,
		MdcRec_trk &	TrasanTRK,
		int	l_mass,
		RecMdcKalHelixSegCol *	segcol,
		int	smoothflag
	)

for smoother process

fillTds_ip() [1/2]

void KalFitAlg::fillTds_ip	(	MdcRec_trk &	TrasanTRK,
		KalFitTrack &	track,
		RecMdcKalTrack *	trk,
		int	l_mass
	)

with results got at (0,0,0)

Definition at line 1503 of file KalFitAlg.cxx.

{
    HepPoint3D IP(0,0,0);
    track.pivot(IP);
 
    if (debug_ == 4&& l_mass==lead_) {
        cout << "fillTds_IP>......"<<endl;
        cout << " dr = " << track.a()[0] 
            << ", Er_dr = " << sqrt(track.Ea()[0][0]) << std::endl;
        cout << " phi0 = " << track.a()[1] 
            << ", Er_phi0 = " << sqrt(track.Ea()[1][1]) << std::endl;
        cout << " PT = " << 1/track.a()[2] 
            << ", Er_kappa =" << sqrt(track.Ea()[2][2]) << std::endl;
        cout << " dz = " << track.a()[3] 
            << ", Er_dz = " << sqrt(track.Ea()[3][3]) << std::endl;
        cout << " tanl = " << track.a()[4] 
            << ", Er_tanl = " << sqrt(track.Ea()[4][4]) << std::endl;
    }
 
    if (TrasanTRK.nhits-track.nchits()>fitnocut_ ||
            TrasanTRK.helix[2]*track.a()[2]<0)
        iqual_front_[l_mass] = 0;
 
 
    if (track.nchits() > 5 && track.nster() > 1 &&
            track.nchits()-track.nster() > 2 && track.chiSq() > 0 &&
            track.Ea()[0][0] > 0 && track.Ea()[1][1] > 0 &&
            track.Ea()[2][2] > 0 && track.Ea()[3][3] > 0 &&
            track.Ea()[4][4] > 0 && iqual_front_[l_mass]) {
 
        // fill track information
        double dr    = track.a()[0];
        double phi0  = track.a()[1];
        double kappa = track.a()[2];
        double dz    = track.a()[3];
        double tanl  = track.a()[4];
 
        // vertex of the track
        double vx = dr*cos(phi0); 
        double vy = dr*sin(phi0);
        double vz = dz;
 
        // see Belle note148 for the formulas
        // initial momentum of the track
        if(0==kappa) kappa = 10e-10;
        double px = -sin(phi0)/fabs(kappa);
        double py = cos(phi0)/fabs(kappa);
        double pz = tanl/fabs(kappa);
 
        trk->setX(vx, l_mass);
        trk->setY(vy, l_mass);
        trk->setZ(vz, l_mass);
        trk->setPx(px, l_mass);
        trk->setPy(py, l_mass);
        trk->setPz(pz, l_mass);
 
        const HepPoint3D poca(dr*cos(phi0),dr*sin(phi0),dz); 
        trk->setPoca(poca,l_mass);
 
        trk->setZHelix(track.a(),l_mass);
        trk->setZError(track.Ea(),l_mass);
 
 
        //set charge
        int charge=0;
        if (kappa > 0.0000000001)
            charge = 1;
        else if (kappa < -0.0000000001)
            charge = -1;
        trk->setCharge(charge,l_mass);
 
        //set theta
        double ptot = sqrt(px*px+py*py+pz*pz);
        trk->setTheta(acos(pz/ptot),l_mass);
    }
 
    else{
        //cout<<"copy Mdc Helix in fillTds_ip()"<<endl;
 
        // fill track information
        double dr    = TrasanTRK.helix[0];
        double phi0  = TrasanTRK.helix[1];
        double kappa = TrasanTRK.helix[2];
        double dz    = TrasanTRK.helix[3];
        double tanl  = TrasanTRK.helix[4];
 
        double vx = dr*cos(phi0); 
        double vy = dr*sin(phi0);
        double vz = dz;
 
        if(0==kappa) kappa = 10e-10;
        double px = -sin(phi0)/fabs(kappa);
        double py = cos(phi0)/fabs(kappa);
        double pz = tanl/fabs(kappa);
 
        trk->setX(vx, l_mass);
        trk->setY(vy, l_mass);
        trk->setZ(vz, l_mass);
 
        trk->setPx(px, l_mass);
        trk->setPy(py, l_mass);
        trk->setPz(pz, l_mass);
 
        const HepPoint3D poca(dr*cos(phi0),dr*sin(phi0),dz); 
 
        trk->setPoca(poca,l_mass);               
        //trk->setZHelix(TrasanTRK.helix,l_mass);
        //trk->setZError(TrasanTRK.error,l_mass);
        double a_trasan[5], ea_trasan[15];
        for( int i =0 ; i <5; i++){
            a_trasan[i] = TrasanTRK.helix[i];
        }
        for( int j =0 ; j <15; j++){
            ea_trasan[j] = TrasanTRK.error[j];
        }
        trk->setZHelix(a_trasan,l_mass);
        trk->setZError(ea_trasan,l_mass);
 
        //set charge
        int charge=0;
        if (kappa > 0.0000000001)
            charge = 1;
        else if (kappa < -0.0000000001)
            charge = -1;
        trk->setCharge(charge,l_mass);
 
        //set theta
        double ptot = sqrt(px*px+py*py+pz*pz);
        trk->setTheta(acos(pz/ptot),l_mass);
    }
 
    if(4==debug_) {
        RecMdcKalTrack::setPidType(RecMdcKalTrack::electron);
        std::cout<<"px: "<<trk->px()<<" py: "<<trk->py()<<" pz: "<<trk->pz()<<std::endl;
        std::cout<<"vx: "<<trk->x()<<" vy: "<<trk->y()<<" vz: "<<trk->z()<<std::endl;
    }
}

Referenced by complete_track().

fillTds_ip() [2/2]

void KalFitAlg::fillTds_ip	(	MdcRec_trk &	TrasanTRK,
		KalFitTrack &	track,
		RecMdcKalTrack *	trk,
		int	l_mass
	)

with results got at (0,0,0)

fillTds_lead() [1/2]

void KalFitAlg::fillTds_lead	(	MdcRec_trk &	TrasanTRK,
		KalFitTrack &	track,
		RecMdcKalTrack *	trk,
		int	l_mass
	)

Definition at line 1411 of file KalFitAlg.cxx.

                                          {
 
    HepPoint3D IP(0,0,0);
    track.pivot(IP);    
    // Fit quality
    // int iqual(1);
    int trasster = TrasanTRK.nster, trakster = track.nster(),
        trasax(TrasanTRK.nhits-trasster), trakax(track.nchits()-trakster);
    if (TrasanTRK.nhits-track.nchits()>fitnocut_ || 
            TrasanTRK.helix[2]*track.a()[2]<0)
        iqual_front_[l_mass] = 0;
    if (debug_ == 4) {
 
        cout<<"Nhit from PR "<<TrasanTRK.nhits<<"  nhit  "<<track.nchits()<<endl;
        cout<< "trasster trakster trasax trakax  TrasK      trackK  iqual"<<endl
            <<trasster<<"        "<<trakster<<"        "<<trasax<<"        "<<trakax
            <<"   "<<TrasanTRK.helix[2]<<"   "<<track.a()[2]<<"   "<<iqual_front_[l_mass]<<endl;  
        cout<<"FillTds_lead> track.chiSq..."<<track.chiSq()<<" nchits "<<track.nchits()
            <<" nster "<<track.nster()<<" iqual_front_[l_mass] "<<iqual_front_[l_mass]<<"  track.Ea "<<track.Ea()<<endl; 
 
        cout << " TRASAN stereo = " << trasster
            << " and KalFitTrack = " << trakster << std::endl;
        cout << " TRASAN axial = " << trasax 
            << " and KalFitTrack = " << trakax << std::endl;
 
        if (!iqual_front_[l_mass]) {
            cout << "...there is a problem during fit !! " << std::endl;
            if (trasster-trakster>5) 
                cout << " because stereo " << trasster-trakster << std::endl;
            if (trasax-trakax >5)   
                cout << " because axial " << std::endl;
            if (TrasanTRK.helix[2]*track.a()[2]<0)
                cout << " because kappa sign " << std::endl;
        }
    }
    // Protection : if any problem, we keep the original information !!!!
    if (track.nchits() > 5 && track.nster() > 1 && 
            track.nchits()-track.nster() > 2 && track.chiSq() > 0 &&
            track.Ea()[0][0] > 0 && track.Ea()[1][1] > 0 && 
            track.Ea()[2][2] > 0 && track.Ea()[3][3] > 0 && 
            track.Ea()[4][4] > 0 && iqual_front_[l_mass]) {
 
        trk->setStat(0,0,l_mass);
        trk->setMass(track.mass(),l_mass);
        trk->setChisq(track.chiSq(),0,l_mass);
        trk->setNdf(track.nchits()-5,0,l_mass);
        trk->setNhits(track.nchits(),l_mass);
        //trkid
        trk->setTrackId(TrasanTRK.id);
 
        if (debug_ == 4) cout<<" trasan id...1 "<<TrasanTRK.id<<endl;    
 
        trk->setFHelix(track.a(),l_mass);
        trk->setFError(track.Ea(),l_mass);
 
    } else {
 
        //cout<<"copy Mdc Helix in fillTds_lead()"<<endl;
 
        if(debug_) cout<<"ALARM: FillTds_forMdc Not refit with KalFilter!!!"<<endl;
        // NOT refit with Kalman filter :
        trk->setStat(1,0,l_mass);
        trk->setMass(KalFitTrack::mass(l_mass),l_mass);
 
        // chisq & ndf 
        trk->setChisq(TrasanTRK.chiSq,0,l_mass);
        trk->setNdf(TrasanTRK.nhits-5,0,l_mass);
        //trkid
        trk->setTrackId(TrasanTRK.id);
 
        if (debug_ ==4) cout<<" trasan id...2 "<<TrasanTRK.id<<endl;    
 
        // nhits 
        trk->setNhits(TrasanTRK.nhits,l_mass);
        double a_trasan[5], ea_trasan[15];
        for( int i =0 ; i <5; i++){
            a_trasan[i] = TrasanTRK.helix[i];
        }
        for( int j =0 ; j <15; j++){
            ea_trasan[j] = TrasanTRK.error[j];
        }
        trk->setFHelix(a_trasan,l_mass);
        trk->setFError(ea_trasan,l_mass);
        // trk->setFHelix(TrasanTRK.helix,l_mass);
        // trk->setFError(TrasanTRK.error,l_mass);
    }
}

Referenced by complete_track().

fillTds_lead() [2/2]

void KalFitAlg::fillTds_lead	(	MdcRec_trk &	TrasanTRK,
		KalFitTrack &	track,
		RecMdcKalTrack *	trk,
		int	l_mass
	)

filter_fwd_anal() [1/2]

void KalFitAlg::filter_fwd_anal	(	KalFitTrack &	trk,
		int	l_mass,
		int	way,
		HepSymMatrix &	Eakal
	)

Kalman filter (forward) in Mdc.

get the doca from another other independent method

Definition at line 2803 of file KalFitAlg.cxx.

{
 
    //cout<<"**********************"<<endl;//wangll
    //cout<<"filter pid type "<<l_mass<<endl;//wangll
    // retrieve Mdc  geometry information
 
    IMdcGeomSvc* igeomsvc;
    StatusCode sc = Gaudi::svcLocator()->service("MdcGeomSvc", igeomsvc);
    if(sc==StatusCode::FAILURE) cout << "GeoSvc failing!!!!!!!SC=" << sc << endl; 
    MdcGeomSvc* geomsvc = dynamic_cast<MdcGeomSvc*>(igeomsvc);
    if(!geomsvc){
        std::cout<<"ERROR OCCUR when dynamic_cast in KalFitTrack.cxx !!"<<std::endl;
    }
 
    Hep3Vector x0inner(track.pivot());
    HepVector pos_old(3,0);
    double r0kal_prec(0);
    int  nhits_read(0);
    int nhit = track.HitsMdc().size();
    if(debug_ == 4) cout<<"filter_fwd..........111 nhit="<<nhit<<endl;
    for( int i=0 ; i < nhit; i++ ) {
        KalFitHitMdc& HitMdc = track.HitMdc(i);
        // veto on some hits :
        if (HitMdc.chi2()<0) continue;    
        const KalFitWire& Wire = HitMdc.wire();
        int layerf = Wire.layer().layerId();
 
        //std::cout<<"in layer: "<<layerf<<std::endl;
 
        int wireid = Wire.geoID();
        nhits_read++;
        HepPoint3D fwd(Wire.fwd());
        HepPoint3D bck(Wire.bck());
        Hep3Vector wire = (CLHEP::Hep3Vector)fwd -(CLHEP::Hep3Vector)bck;
        Helix work = *(Helix*)&track;
        work.ignoreErrorMatrix();
        work.pivot((fwd + bck) * .5);
 
        //std::cout<<" (fwd + bck) * .5: "<<(fwd + bck)*.5<<std::endl;
        //std::cout<<" track.x(0): "<<track.x(0)<<std::endl;
        //std::cout<<" work.x(0): "<<work.x(0)<<std::endl;
        //std::cout<<" bck: "<<bck<<std::endl;
 
        HepPoint3D x0kal = (work.x(0).z() - bck.z())/ wire.z() * wire + bck;
 
        if(4 == debug_) std::cout<<" x0kal before sag: "<<x0kal<<std::endl;
 
        // Modification to take account of the wire sag :
        /*
           if (wsag_==1) {
           double A(1.2402E-6);
           if (nhits_read != 1 && r0kal_prec > RMW && x0kal.perp() < RMW)
           A = 8.5265E-7;
           HepPoint3D x0kal_up(x0kal);
           double length = sqrt(wire.x()*wire.x()+wire.z()*wire.z());
           double zp = (x0kal.z() - bck.z())*length/wire.z();
 
           x0kal_up.setX(wire.x()*(x0kal.z()-bck.z())/wire.z()+bck.x());
           x0kal_up.setY((A*(zp-length)+wire.y()/length)*zp+bck.y());
           double slopex = wire.x()/wire.z();
           double slopey = (A*(2*zp-length)*length+wire.y())/wire.z();
 
           x0kal = x0kal_up;
           wire.setX(slopex);
           wire.setY(slopey);
           wire.setZ(1);
 
           } else if (wsag_ == 2 || wsag_ == 3){
           double slopex = wire.x()/wire.z();
           double slopey(0), zinit(x0kal.z());
           double pos[3], yb_sag(0), yf_sag(0);
           int wire_ID = Wire.geoID();
           if (wsag_ == 2)
           calcdc_sag2_(&wire_ID, &zinit, pos, &slopey, &yb_sag, &yf_sag);
 
           else
           calcdc_sag3_(&wire_ID, &zinit, pos, &slopey, &yb_sag, &yf_sag);
 
           wire.setX(slopex);
           wire.setY(slopey);
           wire.setZ(1);
           x0kal.setX(pos[0]);
           x0kal.setY(pos[1]);
           } else 
           */
 
        if (wsag_ == 4){
            Hep3Vector result;
            const MdcGeoWire* geowire = geomsvc->Wire(wireid); 
            double tension = geowire->Tension();
            //std::cout<<" tension: "<<tension<<std::endl;
            double zinit(x0kal.z()), lzx(Wire.lzx());
            // double A(Wire.Acoef());
            double A = 47.35E-6/tension;
            double Zp = (zinit - bck.z())*lzx/wire.z();
 
            if(4 == debug_){
                std::cout<<" sag in filter_fwd_anal: "<<std::endl;
                std::cout<<" x0kal.x(): "<<std::setprecision(10)<<x0kal.x()<<std::endl;
                std::cout<<"zinit: "<<zinit<<" bck.z(): "<<bck.z()<<std::endl;
                std::cout<<" wire.x()*(zinit-bck.z())/wire.z(): "<<std::setprecision(10)
                                           <<(wire.x()*(zinit-bck.z())/wire.z())<<std::endl;  
                std::cout<<"bck.x(): "<<std::setprecision(10)<<bck.x()<<std::endl;
                std::cout<<" wire.x()*(zinit-bck.z())/wire.z() + bck.x(): "<<std::setprecision(10)
                                                 <<(wire.x()*(zinit-bck.z())/wire.z() + bck.x())<<std::endl;
            }
 
            result.setX(wire.x()*(zinit-bck.z())/wire.z() + bck.x());
            result.setY((A*(Zp-lzx)+wire.y()/lzx)*Zp+bck.y());
            result.setZ((A*(2*Zp-lzx)*lzx+wire.y())/wire.z());
 
            wire.setX(wire.x()/wire.z());
            wire.setY(result.z());
            wire.setZ(1);
            x0kal.setX(result.x());
            x0kal.setY(result.y());
        }
 
        if(4 == debug_) std::cout<<" x0kal after sag: "<<x0kal<<std::endl;
 
        // If x0kal is after the inner wall and x0kal_prec before :
        double r0kal = x0kal.perp();
 
        // change PIVOT :
        double pathl(0);
 
        track.pivot_numf(x0kal, pathl);
 
        if (nhits_read == 1) { 
            track.Ea(Eakal);
        } else {
            if(KalFitElement::muls()) track.msgasmdc(pathl, way);
            if(KalFitElement::loss()) track.eloss(pathl, _BesKalmanFitMaterials[0], way);
        }
 
        double dtracknew = 0.;
        double dtrack = 0.;
        double dtdc = 0.;
        // Add info hit wire :
        if(fabs(track.kappa())>0&&fabs(track.kappa())<1000.0&&fabs(track.tanl())<7.02) {
            Hep3Vector meas = track.momentum(0).cross(wire).unit();
            double diff_chi2 = track.chiSq();
            Hep3Vector IP(0,0,0);
            Helix work_bef = *(Helix*)&track;
            work_bef.ignoreErrorMatrix();
            work_bef.pivot(IP);
            int inext(-1);
            if (i+1<nhit)
                for( unsigned k=i+1 ; k < nhit; k++ )
                    if (!(track.HitMdc(k).chi2()<0)) {
                        inext = (signed) k;
                        break;
                    }
            double dchi2 = -1.0;
 
            double chi2 = track.update_hits(HitMdc,inext,meas,way,dchi2,dtrack,dtracknew,dtdc,m_csmflag);
 
            //cout << "dchi2=" <<  dchi2 << endl;    
            /// get the doca from another other independent method    
 
            /*
               std::cout<<" step0: "<<std::endl;
               KalFitTrack temp2(track);
               std::cout<<" step1: "<<std::endl;
 
               Helix       temp3(track.pivot(),track.a(),track.Ea());
               Helix       temp4(track.pivot(),track.a(),track.Ea());
 
               std::cout<<" step2: "<<std::endl;
               double doca25 = temp2.approach(HitMdc, false);
               std::cout<<" step3: "<<std::endl;
 
               temp2.pivot(IP);
               std::cout<<" a2: "<<temp2.a()<<std::endl;
 
               std::cout<<" step4: "<<std::endl;
 
               double doca26 = temp3.approach(HitMdc, false);
               std::cout<<" another doca2.6: "<<doca26<<std::endl;
 
               temp3.pivot(IP);
               std::cout<<" a3: "<<temp3.a()<<std::endl;
 
               temp4.bFieldZ(-10);
               temp4.pivot(IP);
               std::cout<<" a4: "<<temp4.a()<<std::endl;
 
               std::cout<<" step5: "<<std::endl;
 
               double doca1 = track.approach(HitMdc, false);
               double doca2 = temp2.approach(HitMdc, false);
               double doca3 = temp3.approach(HitMdc, false);
               double doca4 = temp4.approach(HitMdc, false);
 
               std::cout<<" dtrack: "<<dtrack<<std::endl;
               std::cout<<" another doca1: "<<doca1<<std::endl;
               std::cout<<" another doca2: "<<doca2<<std::endl;
               std::cout<<" another doca2.5: "<<doca25<<std::endl;
               std::cout<<" another doca3: "<<doca3<<std::endl;
               std::cout<<" another doca4: "<<doca4<<std::endl;
               */  
 
 
            if( dchi2 <0 ) {
                std::cout<<" ... ERROR OF dchi2... "<<std::endl;
            }
 
            if (ntuple_&8) {
                m_dchi2 = dchi2;
                m_masshyp = l_mass;
                m_residest = dtrack-dtdc;
                m_residnew = dtracknew -dtdc;
                m_layer =  Wire.layer().layerId();
                Helix worktemp = *(Helix*)&track;
                m_anal_dr = worktemp.a()[0];
                m_anal_phi0 = worktemp.a()[1]; 
                m_anal_kappa = worktemp.a()[2];
                m_anal_dz = worktemp.a()[3]; 
                m_anal_tanl = worktemp.a()[4]; 
                m_anal_ea_dr = worktemp.Ea()[0][0];
                m_anal_ea_phi0 = worktemp.Ea()[1][1];
                m_anal_ea_kappa = worktemp.Ea()[2][2];
                m_anal_ea_dz = worktemp.Ea()[3][3];
                m_anal_ea_tanl = worktemp.Ea()[4][4];
                StatusCode sc5 = m_nt5->write();
                if( sc5.isFailure() ) cout<<"Ntuple5 filling failed!"<<endl;     
            }
            Helix work_aft = *(Helix*)&track;
            work_aft.ignoreErrorMatrix();
            work_aft.pivot(IP);
            diff_chi2 = chi2 - diff_chi2; 
            HitMdc.chi2(diff_chi2);
        }
        r0kal_prec = r0kal;
    }
    //cout <<"filter end" << endl;
}

Referenced by complete_track(), kalman_fitting_anal(), and start_seed().

filter_fwd_anal() [2/2]

void KalFitAlg::filter_fwd_anal	(	KalFitTrack &	trk,
		int	l_mass,
		int	way,
		HepSymMatrix &	Eakal
	)

Kalman filter (forward) in Mdc.

filter_fwd_calib() [1/2]

void KalFitAlg::filter_fwd_calib	(	KalFitTrack &	trk,
		int	l_mass,
		int	way,
		HepSymMatrix &	Eakal
	)

Definition at line 3044 of file KalFitAlg.cxx.

{
 
    // retrieve Mdc  geometry information
    IMdcGeomSvc* igeomsvc;
    StatusCode sc = Gaudi::svcLocator()->service("MdcGeomSvc", igeomsvc);
    if(sc==StatusCode::FAILURE) cout << "GeoSvc failing!!!!!!!SC=" << sc << endl;
    MdcGeomSvc* geomsvc = dynamic_cast<MdcGeomSvc*>(igeomsvc);
    if(!geomsvc){
        std::cout<<"ERROR OCCUR when dynamic_cast in KalFitTrack.cxx !!"<<std::endl;
    }
 
    if(debug_ == 4) {
        std::cout<<"filter_fwd_calib starting ...the inital error Matirx is "<<track.Ea()<<std::endl;
    }
    Hep3Vector x0inner(track.pivot());
    HepVector pos_old(3,0);
    double r0kal_prec(0);
    int  nhits_read(0);
 
    unsigned int nhit = track.HitsMdc().size();
    if(debug_ == 4) cout<<"filter_fwd..........111 nhit="<<nhit<<endl;
    for( unsigned i=0 ; i < nhit; i++ ) {
 
        KalFitHitMdc& HitMdc = track.HitMdc(i);
        if(debug_ == 4)
            cout<<"filter_fwd...........222 chi2="<<HitMdc.chi2()<<endl;
        // veto on some hits :
        if (HitMdc.chi2()<0) continue;    
        const KalFitWire& Wire = HitMdc.wire();
 
        int wireid = Wire.geoID();
        nhits_read++;
 
        //    if (nhits_read == 1) track.Ea(Eakal);
        HepPoint3D fwd(Wire.fwd());
        HepPoint3D bck(Wire.bck());
        Hep3Vector wire = (CLHEP::Hep3Vector)fwd -(CLHEP::Hep3Vector)bck;
        Helix work = *(Helix*)&track;
        work.ignoreErrorMatrix();
        work.pivot((fwd + bck) * .5);
        HepPoint3D x0kal = (work.x(0).z() - bck.z())/ wire.z() * wire + bck;
 
        if(4 == debug_)
            std::cout<<" x0kal before sag: "<<x0kal<<std::endl;
 
        if (wsag_ == 4){
            Hep3Vector result;
            const MdcGeoWire* geowire = geomsvc->Wire(wireid); 
            double tension = geowire->Tension();
            //std::cout<<" tension: "<<tension<<std::endl;
            double zinit(x0kal.z()), lzx(Wire.lzx());
            // double A(Wire.Acoef());
            double A = 47.35E-6/tension;
            double Zp = (zinit - bck.z())*lzx/wire.z();
 
            if(4 == debug_){
 
                std::cout<<" sag in filter_fwd_calib: "<<std::endl;
                std::cout<<" x0kal.x(): "<<std::setprecision(10)<<x0kal.x()<<std::endl;
                std::cout<<" wire.x()*(zinit-bck.z())/wire.z(): "<<std::setprecision(10)
                                           <<(wire.x()*(zinit-bck.z())/wire.z())<<std::endl;
                std::cout<<"bck.x(): "<<std::setprecision(10)<<bck.x()<<std::endl;
                std::cout<<" wire.x()*(zinit-bck.z())/wire.z() + bck.x(): "<<std::setprecision(10)
                                                 <<(wire.x()*(zinit-bck.z())/wire.z() + bck.x())<<std::endl;
            }
 
            result.setX(wire.x()*(zinit-bck.z())/wire.z() + bck.x());
            result.setY((A*(Zp-lzx)+wire.y()/lzx)*Zp+bck.y());
            result.setZ((A*(2*Zp-lzx)*lzx+wire.y())/wire.z());
            wire.setX(wire.x()/wire.z());
            wire.setY(result.z());
            wire.setZ(1);
            x0kal.setX(result.x());
            x0kal.setY(result.y());
        }
 
        if(4 == debug_)
            std::cout<<" x0kal after sag: "<<x0kal<<std::endl;
 
        // If x0kal is after the inner wall and x0kal_prec before :
        double r0kal = x0kal.perp();
 
        // change PIVOT :
        double pathl(0);
 
        //std::cout<<" track a3: "<<track.a()<<std::endl;
        //std::cout<<" track p3: "<<sqrt(1.0+track.a()[4]*track.a()[4])/track.a()[2]<<std::endl;
 
        if (debug_ == 4)
            cout << "*** move from " << track.pivot() << " ( Kappa = "
                << track.a()[2] << ")" << endl;
        track.pivot_numf(x0kal, pathl); //see the code , the error matrix has been changed in this function ..
 
        //std::cout<<" track a4: "<<track.a()<<std::endl;    
        //std::cout<<" track p4: "<<sqrt(1.0+track.a()[4]*track.a()[4])/track.a()[2]<<std::endl;
 
 
        if (debug_ == 4)
            cout << "*** to " << track.pivot() << " ( Kappa = "
                << track.a()[2] << ")" << std::endl;
 
        if (nhits_read == 1) { 
            track.Ea(Eakal);
            if(debug_==4) cout << "filter_fwd::Ea = " << track.Ea()<<endl;
 
 
        } else {
            if(KalFitElement::muls()) track.msgasmdc(pathl, way);
            if(KalFitElement::loss()) track.eloss(pathl, _BesKalmanFitMaterials[0], way);
        }
 
 
        //std::cout<<" track a5: "<<track.a()<<std::endl;
        //std::cout<<" track p5: "<<sqrt(1.0+track.a()[4]*track.a()[4])/track.a()[2]<<std::endl;
 
        // Add info hit wire :
        if(fabs(track.kappa())>0&&fabs(track.kappa())<1000.0&&fabs(track.tanl())<7.02) {
            Hep3Vector meas = track.momentum(0).cross(wire).unit();
 
            double diff_chi2 = track.chiSq();
 
            Hep3Vector IP(0,0,0);
            Helix work_bef = *(Helix*)&track;
            work_bef.ignoreErrorMatrix();
            work_bef.pivot(IP);
            int inext(-1);
            if (i+1<nhit)
                for( unsigned k=i+1 ; k < nhit; k++ )
                    if (!(track.HitMdc(k).chi2()<0)) {
                        inext = (signed) k;
                        break;
                    }
            double dchi2 = -1.0;
 
            if (debug_ == 4) {
                std::cout<<"the value of x0kal is "<<x0kal<<std::endl;
                std::cout<<"the value of track.pivot() is "<<track.pivot()<<std::endl;
            }
 
            HepVector Va(5,0);
            HepSymMatrix Ma(5,0);
            KalFitHelixSeg  HelixSeg(&HitMdc,x0kal,Va,Ma);   
 
            if(debug_ == 4) {
                std::cout<<"HelixSeg.Ea_pre_fwd() ..."<<HelixSeg.Ea_pre_fwd()<<std::endl;
                std::cout<<"HelixSeg.a_pre_fwd() ..."<<HelixSeg.a_pre_fwd()<<std::endl;
                std::cout<<"HelixSeg.Ea_filt_fwd() ..."<<HelixSeg.Ea_filt_fwd()<<std::endl;
            }
 
            //std::cout<<" track a1: "<<track.a()<<std::endl;
            //std::cout<<" track p1: "<<sqrt(1.0+track.a()[4]*track.a()[4])/track.a()[2]<<std::endl;
 
            double chi2=0.;
            if(usage_>1) chi2=track.update_hits_csmalign(HelixSeg, inext, meas, way, dchi2, m_csmflag); 
            else   chi2 = track.update_hits(HelixSeg, inext, meas, way, dchi2, m_csmflag);
 
            //std::cout<<" track a2: "<<track.a()<<std::endl;
            //std::cout<<" track p2: "<<sqrt(1.0+track.a()[4]*track.a()[4])/track.a()[2]<<std::endl;
 
            if(debug_ ==4 )  cout<<"layer, cell, dchi2,chi2, a, p: "<<HitMdc.wire().layer().layerId()<<" , "<<HitMdc.wire().localId()<<" , "<<dchi2<<" , "<<chi2<<" , "<<track.a()<<" , "<<sqrt(1.0+track.a()[4]*track.a()[4])/track.a()[2]<<endl;
 
            if(debug_ == 4) cout<< "****inext***"<<inext<<" !!!!  dchi2=  "<< dchi2
                << " chisq= "<< chi2<< endl;
 
            if (ntuple_&8) {
                m_dchi2 = dchi2;
                m_masshyp = l_mass;
                StatusCode sc5 = m_nt5->write();
                if( sc5.isFailure() ) cout<<"Ntuple5 filling failed!"<<endl;     
            }
 
            Helix work_aft = *(Helix*)&track;
            work_aft.ignoreErrorMatrix();
            work_aft.pivot(IP);
            diff_chi2 = chi2 - diff_chi2; 
            HitMdc.chi2(diff_chi2);
 
            if(debug_ == 4) {
 
                cout << " -> after include meas = " << meas                        
                    << " at R = " << track.pivot().perp() << std::endl;           
                cout << "    chi2 = " << chi2 << ", diff_chi2 = "                  
                    << diff_chi2 << ", LR = "                                     
                    << HitMdc.LR() << ", stereo = " << HitMdc.wire().stereo()     
                    << ", layer = " << HitMdc.wire().layer().layerId() << std::endl;       
                cout<<"filter_fwd..........HitMdc.chi2... "<<HitMdc.chi2()<<endl;
            }
 
            if(dchi2>0.0 && (way!=999)) {
                track.HelixSegs().push_back(HelixSeg);
            }
        }
        r0kal_prec = r0kal;
    }
}

Referenced by complete_track(), kalman_fitting_calib(), kalman_fitting_csmalign(), kalman_fitting_MdcxReco_Csmc_Sew(), and start_seed().

filter_fwd_calib() [2/2]

void KalFitAlg::filter_fwd_calib	(	KalFitTrack &	trk,
		int	l_mass,
		int	way,
		HepSymMatrix &	Eakal
	)

finalize() [1/2]

StatusCode KalFitAlg::finalize

(

)

Definition at line 320 of file KalFitAlg.cxx.

{
    MsgStream log(msgSvc(), name());
    log << MSG::DEBUG<<"KalFitAlg:: nTotalTrks = "<<nTotalTrks<<endreq;
    log << MSG::DEBUG<<"        e: "<<nFailedTrks[0]<<" failed, "<<nTotalTrks-nFailedTrks[0]<<" successed"<<endreq;
    log << MSG::DEBUG<<"       mu: "<<nFailedTrks[1]<<" failed, "<<nTotalTrks-nFailedTrks[1]<<" successed"<<endreq;
    log << MSG::DEBUG<<"       pi: "<<nFailedTrks[2]<<" failed, "<<nTotalTrks-nFailedTrks[2]<<" successed"<<endreq;
    log << MSG::DEBUG<<"        K: "<<nFailedTrks[3]<<" failed, "<<nTotalTrks-nFailedTrks[3]<<" successed"<<endreq;
    log << MSG::DEBUG<<"        p: "<<nFailedTrks[4]<<" failed, "<<nTotalTrks-nFailedTrks[4]<<" successed"<<endreq;
    return StatusCode::SUCCESS;                                                  
}                       

finalize() [2/2]

StatusCode KalFitAlg::finalize

(

)

fitGemHits() [1/2]

void KalFitAlg::fitGemHits	(	KalFitTrack &	track,
		int	hypo,
		int	way
	)

Definition at line 6843 of file KalFitAlg.cxx.

{
    {
        //cout<<endl;
        //cout<<"--------------------------------------"<<endl;
        //cout<<"start GEM Kalman fit: hypo = "<<hypo<<endl;
        //cout<<"--------------------------------------"<<endl;
        // std::vector<double> dchi2_all;
        // std::vector<HepPoint3D> posnew;
        // std::vector<HepSymMatrix> eanew;
        // std::vector<HepVector> anew;
        //std::map<int,double> dchi2;
        std::map<double,double> esti1_r;
        std::map<double,double> esti2_r;
        std::map<double,double> esti1_phi;
        std::map<double,double> esti2_phi;
        std::map<double,double> esti1_z;
        std::map<double,double> esti2_z;
        std::map<double,double> diff1_phi;
        std::map<double,double> diff1_z;
        std::map<double,double> diff2_phi;
        std::map<double,double> diff2_z;
        std::map<double,HepPoint3D> posnew;
        std::map<double,HepSymMatrix> eanew;
        std::map<double,HepVector>  anew;
        std::map<double,double> meas_r;
        std::map<double,double> meas_phi;
        std::map<double,double> meas_z;
        std::map<double,double> meas_phierr;
        std::map<double,double> esti_phierr;
        std::map<double,double> meas_zerr;
        std::map<double,double> esti_zerr;
        int ii=0;
        if(debug_==4){ cout << "wall size" << _BesKalmanFitWalls.size() << endl;}
        for(int iLayer=2; iLayer>=0; iLayer--)
        {
            posnew.clear();
            eanew.clear();
            anew.clear();
            esti1_r.clear();
            esti2_r.clear();
            esti1_phi.clear();
            esti2_phi.clear();
            esti1_z.clear();
            esti2_z.clear();
            diff1_phi.clear();
            diff1_z.clear();
            diff2_phi.clear();
            diff2_z.clear();
            meas_r.clear();
            meas_phi.clear();
            meas_z.clear();
            meas_phierr.clear();
            meas_zerr.clear();
            esti_phierr.clear();
            esti_zerr.clear();
            //cout<<"iLayer = "<<iLayer<<endl;
            int nHits=myGemHitCol[iLayer].size();
            //cout << "nhits" << nHits << "in layer" << iLayer << endl;
 
            if (nHits <= 0) continue;
            //if(nHits!=1) continue;
 
            vector<KalFitGemHit>::iterator iter;
            int ihit=0;
            //    int ii=0;
            //cout <<"track before" << "pivot=" << track.pivot() << "a=" << track.a() << "ea=" <<track.Ea() << endl;
            innerwall(track,hypo,way,64+iLayer*(-32),88+iLayer*(-32));
            KalFitTrack track_start(track);
            //cout << "now position" << track_start.pivot().perp() << ","<< track_start.pivot().phi() << "," << track_start.pivot().z() <<endl;
            for(iter=myGemHitCol[iLayer].begin();iter!=myGemHitCol[iLayer].end();iter++ )
            {   
                //cout <<"track" << "pivot=" << track.pivot() << "a=" << track.a() << "ea=" <<track.Ea() << endl;
                track.set(track_start.pivot(),track_start.a(),track_start.Ea());
                //cout << "track start" << "pivot=" << track_start.pivot() << "a=" << track_start.a() << "ea=" << track_start.Ea() << endl;
                double rGem=(*iter).getR();
                double phiGem=(*iter).getPhi();
                double zGem=(*iter).getZ();
                HepVector v_measu=(*iter).getVecPos();
                //cout << "hit" << ihit << "r=" << rGem << "phi=" << phiGem << "z=" << zGem << endl;
                //        cout << "v_measu= "  << v_measu << endl;
                /*    
                      double rGem=(myGemHitCol[iLayer].begin())->getR();
                      double phiGem=(myGemHitCol[iLayer].begin())->getPhi();
                      double zGem=(myGemHitCol[iLayer].begin())->getZ();
                      HepVector v_measu=(myGemHitCol[iLayer].begin())->getVecPos();
                      cout<<"v_measu = "<<v_measu<<endl;
                */
                double dPhiToGem = track.intersect_cylinder(rGem);
                //cout << "dPhiToGem=" << dPhiToGem << endl;
                HepPoint3D posEstiAtGem = track.x(dPhiToGem);
                double x0=posEstiAtGem.x();
                double y0=posEstiAtGem.y();
                double pathInGem;
                //cout << "before move" << "pivot" <<track.pivot() << "a" << track.a() << "ea" << track.Ea() << endl;
                track.pivot_numf(posEstiAtGem, pathInGem);
                //cout << "posEstiAtGem=" << posEstiAtGem << endl;
                //cout << "pathInGem=" << pathInGem <<  endl;
                if(pathInGem>0)
                {
                    if(muls_) track.ms(pathInGem, _BesKalmanFitMaterials[26+32*iLayer], way);
                    if(loss_) track.eloss(pathInGem, _BesKalmanFitMaterials[26+32*iLayer], way);
                }
                //cout << "after move" << "pivot" <<track.pivot() << "a" << track.a() << "ea" << track.Ea() << endl;
                double rGemEsti=posEstiAtGem.perp();
                double phiGemEsti=posEstiAtGem.phi();
                double zGemEsti=posEstiAtGem.z();
                HepVector v_estim(2,0);
                v_estim(1)=phiGemEsti;
                v_estim(2)=zGemEsti;
                //cout<<"GEM layer "<<iLayer+1<<" :  MC   r,phi,z="<<rGem<<", "<<phiGem<<", "<<zGem<<endl;
                //cout<<"             esti   r,phi,z="<<rGemEsti<<", "<<phiGemEsti<<", "<<zGemEsti<<endl;
                double dPhi=track.intersect_cylinder(rGem);
                //cout << "dPhi=" << dPhi << endl;
                HepPoint3D pos = track.x(dPhi);
                //cout<< "assumed esti phi,z" << pos.phi() << "," << pos.z() << endl;
                const HepSymMatrix& Ea = track.Ea();
                HepVector v_a = track.a();
                double drho=v_a(1);
                double phi0=v_a(2);
                double kappa=v_a(3);
                double tl=v_a(5);
                //cout<<"v_a = "<<v_a<<endl;
                //cout<<"phi0 = "<<phi0<<endl;
                // --- derivative matrix
                HepMatrix H(2, 5, 0);
                //H(1,2)=(x0*cos(phi0)-y0*sin(phi0))/(x0*x0+y0*y0);
                //H(2,4)=1.0;
                H(1,1)=-y0*cos(phi0)/(y0*y0+x0*x0)+x0*sin(phi0)/(x0*x0+y0*y0);
                //H(1,1)=(x0*cos(phi0)-y0*sin(phi0))/(x0*x0+y0*y0);
                //H(1,2)=-y0/(y0*y0+x0*x0)*sin(phi0+dPhi)-x0/(x0*x0+y0*y0)*cos(phi0+dPhi);
                H(1,2)=-y0/(y0*y0+x0*x0)*((-1)*drho*sin(phi0)+m_alpha/kappa*(sin(phi0+dPhi)-sin(phi0)))+x0/(x0*x0+y0*y0)*(drho*cos(phi0)+m_alpha/kappa*(cos(phi0)-cos(phi0+dPhi)));
                H(1,3)=-y0/(y0*y0+x0*x0)*(-1)*m_alpha/(kappa*kappa)*(cos(phi0)-cos(phi0+dPhi))+x0/(x0*x0+y0*y0)*(-1)*m_alpha/(kappa*kappa)*(sin(phi0)-sin(phi0+dPhi));
                H(2,3)=m_alpha/(kappa*kappa)*tl*dPhi;
                H(2,4)=1.0;
                H(2,5)=-1*(m_alpha/kappa)*dPhi;
                //cout<<"H="<<H<<endl;
                HepMatrix H_T=H.T();
                //cout<<"H_T="<<H_T<<endl;
                //cout << "H*v_a=" << H*v_a <<  endl;
                //cout << "H*v_a+estim=" <<H*v_a+v_estim << endl;
                // --- error matrix of Gem hit
                HepSymMatrix V=(*iter).getErrMat();
                //cout<<"V="<<V<<endl;
                HepMatrix HEa=H*Ea;
                HepMatrix HEaH_T=HEa*H_T;
                int ierr=-1;
                HepMatrix Vinv=(V+HEaH_T).inverse(ierr);
                if(ierr!=0) cout<<"error in HEaH_T.inverse()!"<<endl;
                // --- gain matrix
                HepMatrix K=Ea*H_T*Vinv;
                // --- new error matrix
                HepSymMatrix EaNew(5,0);
                EaNew.assign(Ea-K*H*Ea);
                // --- diff
                HepVector v_diff=v_measu-v_estim;
                //cout << "v_diff before= " << v_diff <<  endl;
                double delPhi=v_diff(1);
                if(fabs(v_diff(1))>6.28) v_measu(1)=-1*v_measu(1);
                while(delPhi> M_PI) delPhi-=M_PI;
                while(delPhi<-M_PI) delPhi+=M_PI;
                v_diff(1)=delPhi;
                //v_diff=v_measu-(H*v_a+v_estim);
                //cout<<"v_diff = "<<v_diff<<endl;
                // --- new parameters
                HepVector aNew=v_a+K*v_diff;
                //cout << "matrix K=" << K << endl;
                //cout << "aNew=" << aNew << endl;
                // --- new v_estim
                KalFitTrack track_test(posEstiAtGem,aNew,EaNew,hypo,0.0,track.nchits());
                double dPhiToGem_New = track_test.intersect_cylinder(rGem);
                HepPoint3D posEstiAtGem_new = track_test.x(dPhiToGem_New);
                double phiGemEsti_new=posEstiAtGem_new.phi();
                double zGemEsti_new=posEstiAtGem_new.z();
                double x0_new = posEstiAtGem_new.x();
                double y0_new = posEstiAtGem_new.y();
                HepVector v_estim_new(2,0);
                v_estim_new(1)=phiGemEsti_new;
                v_estim_new(2)=zGemEsti_new;
                //cout<<"v_estim_new = "<<v_estim_new<<endl;
                //cout << "assumed v_estim_new =" << H*aNew+v_estim << endl;
                // --- diff between measurement and updated estimation
                v_diff=v_measu-v_estim_new;
                delPhi=v_diff(1);
                while(delPhi> M_PI) delPhi-=M_PI;
                while(delPhi<-M_PI) delPhi+=M_PI;
                //cout<<"v_diff_new = "<<v_diff<<endl;
                //cout << "H*aNew"<< H*aNew << endl;
                //cout << "test v_diff new" << v_measu-v_estim-H*aNew << endl;
                // --- new derivative matrix
                track_test.pivot_numf(posEstiAtGem_new, pathInGem);
                HepVector v_a_new = track_test.a();
                //cout << "v_a_new=" << v_a_new << endl;
                HepSymMatrix Ea_new = track_test.Ea();
                //cout << "Ea_new =" << Ea_new << endl;
                double phi0_new = v_a_new(2);
                double kappa_new=v_a_new(3);
                HepMatrix H_new(2, 5, 0);
                //H_new(1,1)=-y0_new/(x0_new*x0_new+y0_new*y0_new)*cos(phi0_new)+x0_new/(x0_new*x0_new+y0_new*y0_new)*sin(phi0_new);
                //H_new(2,4)=1.0;
                //H_new(1,1)=(x0_new*cos(phi0_new)-y0_new*sin(phi0_new))/(x0_new*x0_new+y0_new*y0_new);
 
                /* H_new(1,1)=-y0_new/(1+x0_new*x0_new)*cos(phi0_new)+x0_new/(x0_new*x0_new+y0_new*y0_new)*sin(phi0_new);
                   H_new(1,2)=-y0_new/(1+x0_new*x0_new)*sin(phi0_new+dPhiToGem_New)-x0_new/(x0_new*x0_new+y0_new*y0_new)*cos(phi0_new+dPhiToGem_New);
                   H_new(2,4)=1.0;
                   H_new(2,5)=-(-333.564095)/kappa_new*dPhiToGem_New;*/
                HepMatrix H_new_T=H_new.T();
                // --- R mactrix
                //cout<<"H_new*Ea_new*H_new_T = "<<H_new*Ea_new*H_new_T<<endl;
                //cout << "H*Ea_new*H_T=" << H*Ea_new*H_T << endl;
                //cout << "H*EaNew*H_T=" << H*EaNew*H_T<< endl;
                //cout << "H_new*Eanew*H_new_T = "<< H_new*EaNew*H_new_T << endl;
                //cout << "assumed R=" <<V-H*Ea_new*H_T << endl;
                HepSymMatrix R(2,0);
                //R.assign(V-H_new*Ea_new*H_new_T);
                R.assign(V-H*EaNew*H_T);
 
                //cout << "test track" << "pivot" << track.pivot() << "a" << track.a() << "ea" << track.Ea() << endl;
                // --- Chi^2 added
                //cout << "v_diff_T=" << v_diff.T() <<endl;
                //cout << "v_diff="   << v_diff <<endl;
                //cout << "R="<<R << endl;
                //cout << "R inverse=" << R.inverse(ierr)<< endl;
                HepVector v_dChi2=v_diff.T()*R.inverse(ierr)*v_diff;
                if(ierr!=0) cout<<"error in R.inverse()!"<<endl;
                //cout<<"v_dChi2 = "<<v_dChi2<<endl;
                //cout<< "test dchi2=" << (H*v_a).T()*R.inverse(ierr)*(H*v_a) << endl;
                double dChi2=v_dChi2(1);
 
                // --- comparison
                if(debug_==4){
                    cout<<"pivot:     "<<posEstiAtGem<<endl;
                    cout<<"new pivot: "<<posEstiAtGem<<endl;
                    cout<<"a:     "<<v_a<<endl;
                    cout<<"new a: "<<aNew<<endl;
                    cout<<"Ea:     "<<Ea<<endl;
                    cout<<"new Ea: "<<EaNew<<endl;
                    cout<<"dchi2= "<<dChi2<<endl;
                }
                /*  if(ntuple_&1){
                    m_diff[ii]=delPhi;
                    cout << v_diff(2) << endl;
                    m_diffz[ii]=v_diff(2);
                    m_phi[ii]=phiGem;
                    m_z[ii]=zGem;
                    m_Gemdchi2[ii]=dChi2;
                    m_Glayer[ii]=iLayer;
                    m_hypo[ii]=hypo;
                    m_meas_r[ii]=rGem;
                    m_meas_phi[ii]=phiGem;
                    m_meas_z[ii]=zGem;
                    m_esti1_r[ii]=rGemEsti;
                    m_esti1_phi[ii]=phiGemEsti;
                    m_esti1_z[ii]=zGemEsti;
                    m_esti2_r[ii]=rGem;
                    m_esti2_phi[ii]=phiGemEsti_new;
                    m_esti2_z[ii]=zGemEsti_new;
                    m_diff1_phi[ii]=phiGem-phiGemEsti;
                    m_diff1_z[ii]=zGem-zGemEsti;
                    m_diff2_phi[ii]=phiGem-phiGemEsti_new;
                    m_diff2_z[ii]=zGem-zGemEsti_new;
                    m_Gchi2[ii]=dChi2;
                    m_GemLayer[ii]=iLayer;
                    m_mass[ii]=hypo;
                    } */
                // --- update KalFitTrack
                //track.set(posEstiAtGem_new,v_a_new,Ea_new);
                //dchi2_all.push_back(dChi2);
                //posnew.push_back(posEstiAtGem_new);
                //anew.push_back(v_a_new);
                //eanew.push_back(Ea_new);  
                //dchi2[ii]=dChi2;
                esti1_r[dChi2]=rGemEsti;
                esti1_phi[dChi2]=phiGemEsti;
                esti1_z[dChi2]=zGemEsti;
                esti2_r[dChi2]=rGem;
                esti2_phi[dChi2]=phiGemEsti_new;
                esti2_z[dChi2]=zGemEsti_new;
                diff1_phi[dChi2]=phiGem-phiGemEsti;
                diff1_z[dChi2]=zGem-zGemEsti;
                diff2_phi[dChi2]=phiGem-phiGemEsti_new;
                diff2_z[dChi2]=zGem-zGemEsti_new;
                posnew[dChi2]=posEstiAtGem;
                anew[dChi2]=aNew;
                eanew[dChi2]=EaNew;
                meas_r[dChi2]=rGem;
                meas_phi[dChi2]=phiGem;
                //cout << "meas_phi[dChi2]" << phiGem << endl;
                meas_z[dChi2]=zGem;
                meas_phierr[dChi2]=sqrt(V[0][0]);
                //cout << "meas_phierr[dChi2]" << meas_phierr[dChi2] << endl;
                meas_zerr[dChi2]=sqrt(V[1][1]);
                //cout << "meas_zerr[dChi2]" << meas_zerr[dChi2] << endl;
                esti_phierr[dChi2]=sqrt((H*(track_start.Ea())*H_T)[0][0]);
                //cout << "esti_phierr[dChi2]" << esti_phierr[dChi2] << endl;
                esti_zerr[dChi2]=sqrt((H*(track_start.Ea())*H_T)[1][1]);
                //cout << "esti_zerr[dChi2]" << esti_zerr[dChi2] << endl;
 
                ihit++;
                //        ii++;
            }
 
            //m_Gemhits=ii;
            //m_nt7->write();
            track.set((posnew.begin())->second,(anew.begin())->second,(eanew.begin()->second));
 
            CgemGeoLayer* CgemLayer = m_CgemGeomSvc_->getCgemLayer(iLayer);
            double new_dPhiToGem = track.intersect_cylinder((CgemLayer->getInnerROfGapD())/10);
            HepPoint3D new_posEstiAtGem = track.x(new_dPhiToGem);
            double new_pathInGem;
            //cout << "new_dPhiToGem" << new_dPhiToGem  << endl;
            //cout << "before move2" << "pivot" <<track.pivot().perp() << "," << track.pivot().phi() << "," << track.pivot().z()<< "a" << track.a() << "ea" << track.Ea() << endl;
            track.pivot_numf(new_posEstiAtGem, new_pathInGem);
            //cout << "posEstiAtGem2=" << new_posEstiAtGem << endl;
            //cout << "pathInGem2=" << new_pathInGem <<  endl;
            if(new_pathInGem>0)
            {
                if(muls_) track.ms(new_pathInGem, _BesKalmanFitMaterials[26+32*iLayer], way);
                if(loss_) track.eloss(new_pathInGem, _BesKalmanFitMaterials[26+32*iLayer], way);
            }
            //cout << "after move2: " << "pivot" <<track.pivot().perp() << "," << track.pivot().phi() << "," << track.pivot().z() << "a" << track.a() << "ea" << track.Ea() << endl;
            if(iLayer>=1){
                innerwall(track,hypo,way,90+(-32)*iLayer,95+(-32)*iLayer);}
            else{
                innerwall(track,hypo,way,90+(-32)*iLayer,94+(-32)*iLayer);}
            //cout <<"!!!!ntuple" << ntuple_ << endl;
            //cout << "!!!(esti1_phi.begin())->second" << (esti1_phi.begin())->second << endl;
            //cout<<" Finish innerwall"<<endl;
            if(ntuple_&1)
            {
                //cout << "good!" << endl;
                //cout << "m_esti1_r[ii]0" << m_esti1_r[ii] << endl;
                m_esti1_r[ii]=(esti1_r.begin())->second;
                //cout << "m_esti1_r[ii]1" << m_esti1_r[ii] << endl;
                m_esti1_phi[ii]=(esti1_phi.begin())->second;
                m_esti1_z[ii]=(esti1_z.begin())->second;
                m_esti2_r[ii]=(esti2_r.begin())->second;
                m_esti2_phi[ii]=(esti2_phi.begin())->second;
                m_esti2_z[ii]=(esti2_z.begin())->second;
                m_diff1_phi[ii]=(diff1_phi.begin())->second;
                m_diff1_z[ii]=(diff1_z.begin())->second;
                m_diff2_phi[ii]=(diff2_phi.begin())->second;
                m_diff2_z[ii]=(diff2_z.begin())->second;
                m_Gchi2[ii]=(esti1_r.begin())->first;
                m_meas_r[ii]=(meas_r.begin())->second;
                m_meas_phi[ii]=(meas_phi.begin())->second;
                //cout << "m_meas_phi[ii]" << m_meas_phi[ii] << endl;
                m_meas_z[ii]=(meas_z.begin())->second;
                m_meas_phierr[ii]=(meas_phierr.begin())->second;
                m_meas_zerr[ii]=(meas_zerr.begin())->second;
                m_esti_phierr[ii]=(esti_phierr.begin())->second;
                m_esti_zerr[ii]=(esti_zerr.begin())->second;
                m_GemLayer[ii]=iLayer;
                m_mass[ii]=hypo;
            }
            //cout<<" end of ntuple_"<<endl;
            ii++; 
        }// loop layers
        //cout<<"finish layer loop"<<endl;
 
        //SmartDataPtr<Event::EventHeader> evtHeader(eventSvc(),"/Event/EventHeader");
        //m_evt3 = evtHeader->eventNumber();
        if(ifProdNt10) {
            //cout << "m_meas_phi[ii]" << m_meas_phi[0] << endl;
            if(m_meas_phi[0]>0         && m_meas_phi[0]<1.5707963)  m_qua=0;
            if(m_meas_phi[0]>1.5707963 && m_meas_phi[0]<3.1415926)  m_qua=1;
            if(m_meas_phi[0]>-3.1415926&& m_meas_phi[0]<-1.5707963) m_qua=2;
            if(m_meas_phi[0]>-1.5707963&& m_meas_phi[0]<0)          m_qua=3;
            //cout << "m_qua=" << m_qua << endl;
            m_nGemHits=ii;
        }
        //m_Gemhits=ii;
        // m_nt7->write();
        // m_nt10->write();
        posnew.clear();
        eanew.clear();
        anew.clear();
        esti1_r.clear();
        esti2_r.clear();
        esti1_phi.clear();
        esti2_phi.clear();
        esti1_z.clear();
        esti2_z.clear();
        diff1_phi.clear();
        diff1_z.clear();
        diff2_phi.clear();
        diff2_z.clear();
        meas_r.clear();
        meas_phi.clear();
        meas_z.clear();
        meas_phierr.clear();
        meas_zerr.clear();
        esti_phierr.clear();
        esti_zerr.clear();
 
    }// end of GEM Kalman fit
    //cout << "end of GEM Kalman fit" << endl;
    if(ifProdNt10)  { 
        SmartDataPtr<Event::EventHeader> evtHeader(eventSvc(),"/Event/EventHeader");
        //cout << "evtHeader" << m_evt3 << endl;
        m_evt3 = evtHeader->eventNumber();
        m_nt10->write();
    }
 
}

fitGemHits() [2/2]

void KalFitAlg::fitGemHits	(	KalFitTrack &	track,
		int	hypo,
		int	way
	)

fromFHitToInnerWall() [1/2]

void KalFitAlg::fromFHitToInnerWall	(	KalFitTrack &	track,
		int	way
	)

Definition at line 6356 of file KalFitAlg.cxx.

{
    double rMaxInnerWall=6.42005+0.00495;
    if(useNCGem_>1) { // GEM mode
        //rMaxInnerWall=m_CGEM.end()->radius();
        //rMaxInnerWall=16.7;
        rMaxInnerWall=m_innerWall[0].radius();
    }
    else { // MDC mode
        rMaxInnerWall=_BesKalmanFitWalls[0].radius();
    }
    double dPhiToInnerWall = track.intersect_cylinder(rMaxInnerWall);
    HepPoint3D posAtInnerWall = track.x(dPhiToInnerWall);
    double pathToInnerWall;
    track.pivot_numf(posAtInnerWall, pathToInnerWall);
    //cout<<"__FUNCTION__: rMaxInnerWall = "<<rMaxInnerWall<<endl;
    //cout<<"posAtInnerWall, pathToInnerWall = "<<posAtInnerWall<<", "<<pathToInnerWall<<endl;
    if(pathToInnerWall>0)
    {
        if(muls_) track.ms(pathToInnerWall, _BesKalmanFitMaterials[0], way);
        if(loss_) track.eloss(pathToInnerWall, _BesKalmanFitMaterials[0], way);
    }
    if(useNCGem_>0) m_innerWall[0].updateTrack(track, way);
 
}

fromFHitToInnerWall() [2/2]

void KalFitAlg::fromFHitToInnerWall	(	KalFitTrack &	track,
		int	way
	)

getEventStarTime() [1/2]

void KalFitAlg::getEventStarTime

(

void

)

getEventStarTime() [2/2]

void KalFitAlg::getEventStarTime

(

void

)

getWallMdcNumber() [1/2]

int KalFitAlg::getWallMdcNumber

(

const HepPoint3D &

point

)

getWallMdcNumber() [2/2]

int KalFitAlg::getWallMdcNumber

(

const HepPoint3D &

point

)

hist_def() [1/2]

void KalFitAlg::hist_def

(

void

)

hist definition

Definition at line 369 of file KalFitAlg.cxx.

{
    if(ntuple_&1) {               
        NTuplePtr  nt1(ntupleSvc(),"FILE104/n101");
        StatusCode status;
        if ( nt1 ) m_nt1 = nt1;                                                    
        else {                                                                     
            m_nt1= ntupleSvc()->book("FILE104/n101",CLID_ColumnWiseTuple,"KalFit");
            if ( m_nt1 )  { 
 
                status = m_nt1->addItem("trackid",m_trackid);
                status = m_nt1->addItem("stat",5,2,m_stat);
                status = m_nt1->addItem("ndf",5,2,m_ndf);
                status = m_nt1->addItem("chisq",5,2,m_chisq);
                status = m_nt1->addItem("length",5,m_length);
                status = m_nt1->addItem("tof",5,m_tof);
                status = m_nt1->addItem("nhits",5,m_nhits);
                status = m_nt1->addItem("zhelix",5,m_zhelix);
                status = m_nt1->addItem("zhelixe",5,m_zhelixe);
                status = m_nt1->addItem("zhelixmu",5,m_zhelixmu);
                status = m_nt1->addItem("zhelixk",5,m_zhelixk);
                status = m_nt1->addItem("zhelixp",5,m_zhelixp);
                status = m_nt1->addItem("zptot",m_zptot);
                status = m_nt1->addItem("zptote",m_zptote);
                status = m_nt1->addItem("zptotmu",m_zptotmu);
                status = m_nt1->addItem("zptotk",m_zptotk);
                status = m_nt1->addItem("zptotp",m_zptotp);
 
                status = m_nt1->addItem("zpt",m_zpt);
                status = m_nt1->addItem("zpte",m_zpte);
                status = m_nt1->addItem("zptmu",m_zptmu);
                status = m_nt1->addItem("zptk",m_zptk);
                status = m_nt1->addItem("zptp",m_zptp);
 
                status = m_nt1->addItem("fptot",m_fptot);
                status = m_nt1->addItem("fptote",m_fptote);
                status = m_nt1->addItem("fptotmu",m_fptotmu);
                status = m_nt1->addItem("fptotk",m_fptotk);
                status = m_nt1->addItem("fptotp",m_fptotp);
                status = m_nt1->addItem("fpt",m_fpt);
                status = m_nt1->addItem("fpte",m_fpte);
                status = m_nt1->addItem("fptmu",m_fptmu);
                status = m_nt1->addItem("fptk",m_fptk);
                status = m_nt1->addItem("fptp",m_fptp);
 
                status = m_nt1->addItem("lptot",m_lptot);
                status = m_nt1->addItem("lptote",m_lptote);
                status = m_nt1->addItem("lptotmu",m_lptotmu);
                status = m_nt1->addItem("lptotk",m_lptotk);
                status = m_nt1->addItem("lptotp",m_lptotp);
                status = m_nt1->addItem("lpt",m_lpt);
                status = m_nt1->addItem("lpte",m_lpte);
                status = m_nt1->addItem("lptmu",m_lptmu);
                status = m_nt1->addItem("lptk",m_lptk);
                status = m_nt1->addItem("lptp",m_lptp);
 
                status = m_nt1->addItem("zsigp",m_zsigp);
                status = m_nt1->addItem("zsigpe",m_zsigpe);
                status = m_nt1->addItem("zsigpmu",m_zsigpmu);
                status = m_nt1->addItem("zsigpk",m_zsigpk);
                status = m_nt1->addItem("zsigpp",m_zsigpp);
                status = m_nt1->addItem("fhelix",5,m_fhelix);
                status = m_nt1->addItem("fhelixe",5,m_fhelixe);
                status = m_nt1->addItem("fhelixmu",5,m_fhelixmu);
                status = m_nt1->addItem("fhelixk",5,m_fhelixk);
                status = m_nt1->addItem("fhelixp",5,m_fhelixp);
                status = m_nt1->addItem("lhelix",5,m_lhelix);
                status = m_nt1->addItem("lhelixe",5,m_lhelixe);
                status = m_nt1->addItem("lhelixmu",5,m_lhelixmu);
                status = m_nt1->addItem("lhelixk",5,m_lhelixk);
                status = m_nt1->addItem("lhelixp",5,m_lhelixp);
                status = m_nt1->addItem("rGem",4,m_rGem);
                status = m_nt1->addItem("chi2Gem",4,m_chi2Gem);
                status = m_nt1->addItem("phiGemExp",4,m_phiGemExp);
                status = m_nt1->addItem("phiGemHit",4,m_phiGemHit);
                status = m_nt1->addItem("zGemExp",4,m_zGemExp);
                status = m_nt1->addItem("zGemHit",4,m_zGemHit);
                if(ntuple_&32) {
                    status = m_nt1->addItem("zerror",15,m_zerror);
                    status = m_nt1->addItem("zerrore",15,m_zerrore);
                    status = m_nt1->addItem("zerrormu",15,m_zerrormu);
                    status = m_nt1->addItem("zerrork",15,m_zerrork);
                    status = m_nt1->addItem("zerrorp",15,m_zerrorp);
                    status = m_nt1->addItem("ferror",15,m_ferror);
                    status = m_nt1->addItem("ferrore",15,m_ferrore);
                    status = m_nt1->addItem("ferrormu",15,m_ferrormu);
                    status = m_nt1->addItem("ferrork",15,m_ferrork);
                    status = m_nt1->addItem("ferrorp",15,m_ferrorp);
                    status = m_nt1->addItem("lerror",15,m_lerror);
                    status = m_nt1->addItem("lerrore",15,m_lerrore);
                    status = m_nt1->addItem("lerrormu",15,m_lerrormu);
                    status = m_nt1->addItem("lerrork",15,m_lerrork);
                    status = m_nt1->addItem("lerrorp",15,m_lerrorp);
                }
                if((ntuple_&16)&&(ntuple_&1)) {
                    status = m_nt1->addItem("evtid",m_evtid);
                    status = m_nt1->addItem("mchelix",5,m_mchelix);
                    status = m_nt1->addItem("mcptot",m_mcptot);
                    status = m_nt1->addItem("mcpid",m_mcpid);
                }
                if( status.isFailure() ) cout<<"Ntuple1 add item failed!"<<endl;       
            }                                                                        
        }
    }
 
    if(ntuple_&4) {  
        NTuplePtr  nt2(ntupleSvc(),"FILE104/n102");
        StatusCode status2;
        if ( nt2 ) m_nt2 = nt2;                                                    
        else {                                                                     
            m_nt2= ntupleSvc()->book("FILE104/n102",CLID_ColumnWiseTuple,"KalFitComp");
            if ( m_nt2 )  {
                status2 = m_nt2->addItem("delx",m_delx);
                status2 = m_nt2->addItem("dely",m_dely);
                status2 = m_nt2->addItem("delz",m_delz);
                status2 = m_nt2->addItem("delthe",m_delthe);
                status2 = m_nt2->addItem("delphi",m_delphi);
                status2 = m_nt2->addItem("delp",m_delp);                         
                status2 = m_nt2->addItem("delpx",m_delpx);
                status2 = m_nt2->addItem("delpy",m_delpy);
                status2 = m_nt2->addItem("delpz",m_delpz);
 
                if( status2.isFailure() ) cout<<"Ntuple2 add item failed!"<<endl; 
            }
        }
    }
 
    if(ntuple_&2) {                                            
        NTuplePtr  nt3(ntupleSvc(),"FILE104/n103");
        StatusCode status3;
        if ( nt3 ) m_nt3 = nt3;                                                    
        else {                                                                     
            m_nt3= ntupleSvc()->book("FILE104/n103",CLID_ColumnWiseTuple,"PatRec");
            if ( m_nt3 )  {
                status3 = m_nt3->addItem("trkhelix",5,m_trkhelix);
                status3 = m_nt3->addItem("trkptot",m_trkptot);
                if(ntuple_&32) {
                    status3 = m_nt3->addItem("trkerror",15,m_trkerror);
                    status3 = m_nt3->addItem("trksigp",m_trksigp);
                }
                status3 = m_nt3->addItem("trkndf",m_trkndf);
                status3 = m_nt3->addItem("trkchisq",m_trkchisq);
                if( status3.isFailure() ) cout<<"Ntuple3 add item failed!"<<endl; 
            }
        }
    }  
 
    if(ntuple_&4) {                                            
        NTuplePtr  nt4(ntupleSvc(),"FILE104/n104");
        StatusCode status4;
        if ( nt4 ) m_nt4 = nt4;                                                    
        else {                                                                     
            m_nt4= ntupleSvc()->book("FILE104/n104",CLID_ColumnWiseTuple,"PatRecComp");
            if ( m_nt4 )  {
                status4 = m_nt4->addItem("trkdelx",m_trkdelx);
                status4 = m_nt4->addItem("trkdely",m_trkdely);
                status4 = m_nt4->addItem("trkdelz",m_trkdelz);
                status4 = m_nt4->addItem("trkdelthe",m_trkdelthe);
                status4 = m_nt4->addItem("trkdelphi",m_trkdelphi);
                status4 = m_nt4->addItem("trkdelp",m_trkdelp);                         
                if( status4.isFailure() ) cout<<"Ntuple4 add item failed!"<<endl; 
            }
        }
    }
    if(ntuple_&8) {                                            
        NTuplePtr  nt5(ntupleSvc(), "FILE104/n105");
        StatusCode status5;
        if ( nt5 ) m_nt5 = nt5;                                                    
        else {                                                                     
            m_nt5= ntupleSvc()->book("FILE104/n105",CLID_ColumnWiseTuple,"KalFitdChisq");
            if ( m_nt5 )  {
                status5 = m_nt5->addItem("dchi2",m_dchi2);
                status5 = m_nt5->addItem("masshyp",m_masshyp);
                status5 = m_nt5->addItem("residual_estim",m_residest);
                status5 = m_nt5->addItem("residual",m_residnew);
                status5 = m_nt5->addItem("layer",m_layer);
                status5 = m_nt5->addItem("kaldr",m_anal_dr);
                status5 = m_nt5->addItem("kalphi0",m_anal_phi0);
                status5 = m_nt5->addItem("kalkappa",m_anal_kappa);
                status5 = m_nt5->addItem("kaldz",m_anal_dz);
                status5 = m_nt5->addItem("kaltanl",m_anal_tanl);
                status5 = m_nt5->addItem("dr_ea",m_anal_ea_dr);
                status5 = m_nt5->addItem("phi0_ea",m_anal_ea_phi0);
                status5 = m_nt5->addItem("kappa_ea",m_anal_ea_kappa);
                status5 = m_nt5->addItem("dz_ea",m_anal_ea_dz);
                status5 = m_nt5->addItem("tanl_ea",m_anal_ea_tanl);
                if( status5.isFailure() ) cout<<"Ntuple5 add item failed!"<<endl; 
            }
        }
    }
    
    NTuplePtr  nt6(ntupleSvc(),"FILE104/n106");
    StatusCode status6;
    if ( nt6 ) m_nt6 = nt6;             
    else {                            
        m_nt6= ntupleSvc()->book("FILE104/n106",CLID_ColumnWiseTuple,"kal seg");
        if ( m_nt6 )  {
            status6 = m_nt6->addItem("docaInc",m_docaInc);
            status6 = m_nt6->addItem("docaExc",m_docaExc);
            status6 = m_nt6->addItem("tdr",m_tdrift);
            status6 = m_nt6->addItem("layerid", m_layerid);
            status6 = m_nt6->addItem("event", m_eventNo);
            status6 = m_nt6->addItem("residualInc",m_residualInc);
            status6 = m_nt6->addItem("residualExc",m_residualExc);
            status6 = m_nt6->addItem("lr",m_lr);
            status6 = m_nt6->addItem("dd",m_dd);
            status6 = m_nt6->addItem("y",m_yposition);
 
            if( status6.isFailure() ) cout<<"Ntuple6 add item failed!"<<endl;
        }
    }
 
    if(ifProdNt10) {
        NTuplePtr nt10(ntupleSvc(),"FILE104/n110");
        StatusCode status10;
        if ( nt10 ) m_nt10 = nt10;
        else {
            m_nt10= ntupleSvc()->book("FILE104/n110",CLID_ColumnWiseTuple,"test");
            if ( m_nt10 )  {
                status10 = m_nt10->addItem("evt",m_evt3);
                status10 = m_nt10->addItem("qua",m_qua);
                status10 = m_nt10->addItem("nhit",m_nGemHits,0,4000000);
                status10 = m_nt10->addIndexedItem("meas_r",m_nGemHits,m_meas_r);
                status10 = m_nt10->addIndexedItem("meas_phi",m_nGemHits,m_meas_phi);
                status10 = m_nt10->addIndexedItem("meas_z",m_nGemHits,m_meas_z);
                status10 = m_nt10->addIndexedItem("esti1_r",m_nGemHits,m_esti1_r);
                status10 = m_nt10->addIndexedItem("esti1_phi",m_nGemHits,m_esti1_phi);
                status10 = m_nt10->addIndexedItem("esti1_z",m_nGemHits,m_esti1_z);
                status10 = m_nt10->addIndexedItem("esti2_r",m_nGemHits,m_esti2_r);
                status10 = m_nt10->addIndexedItem("esti2_phi",m_nGemHits,m_esti2_phi);
                status10 = m_nt10->addIndexedItem("esti2_z",m_nGemHits,m_esti2_z);
                status10 = m_nt10->addIndexedItem("diff1_phi",m_nGemHits,m_diff1_phi);
                status10 = m_nt10->addIndexedItem("diff1_z",m_nGemHits,m_diff1_z);
                status10 = m_nt10->addIndexedItem("diff2_phi",m_nGemHits,m_diff2_phi);
                status10 = m_nt10->addIndexedItem("diff2_z",m_nGemHits,m_diff2_z);
                status10 = m_nt10->addIndexedItem("layer",m_nGemHits,m_GemLayer);
                status10 = m_nt10->addIndexedItem("mass",m_nGemHits,m_mass);
                status10 = m_nt10->addIndexedItem("dchi2",m_nGemHits,m_Gchi2);
                status10 = m_nt10->addIndexedItem("meas_phierr",m_nGemHits,m_meas_phierr);
                status10 = m_nt10->addIndexedItem("meas_zerr",m_nGemHits,m_meas_zerr);
                status10 = m_nt10->addIndexedItem("esti_phierr",m_nGemHits,m_esti_phierr);
                status10 = m_nt10->addIndexedItem("esti_zerr",m_nGemHits,m_esti_zerr);
                if( status10.isFailure() ) cout<<"Ntuple10 add item failed!"<<endl;
            }
        }
    }
 
    if(ifProdNt11) {
        NTuplePtr nt11(ntupleSvc(),"FILE104/n111");
        StatusCode status11;
        if ( nt11 ) m_nt11 = nt11;
        else {
            m_nt11= ntupleSvc()->book("FILE104/n111",CLID_ColumnWiseTuple,"truth");
            if ( m_nt11 )  {
                status11 = m_nt11->addItem("evt",m_evt4);
                status11 = m_nt11->addItem("ntruth",m_ntruth,0,400000);
                status11 = m_nt11->addIndexedItem("phi",m_ntruth,m_dtphi);
                status11 = m_nt11->addIndexedItem("z",m_ntruth,m_dtv);
                status11 = m_nt11->addIndexedItem("postphi",m_ntruth,m_dtpostphi);
                status11 = m_nt11->addIndexedItem("postz",m_ntruth,m_dtpostz);
                status11 = m_nt11->addIndexedItem("layer",m_ntruth,m_tlayer);
                if( status11.isFailure() ) cout<<"Ntuple11 add item failed!"<<endl;
            }
        }
    }
 
    if(ifProdNt12) {
        NTuplePtr  nt12(ntupleSvc(),"FILE104/n112");
        StatusCode status12;
        if ( nt12 ) m_nt12 = nt12;                                       
        else {                                                        
            m_nt12= ntupleSvc()->book("FILE104/n112",CLID_ColumnWiseTuple,"PatRecComp");
            if ( m_nt12 )  {
                status12 = m_nt12->addItem("evt",m_evt);
                status12 = m_nt12->addItem("track",m_track);
                status12 = m_nt12->addItem("diff_dr",m_diff_dr);
                status12 = m_nt12->addItem("diff_phi0",m_diff_phi0);
                status12 = m_nt12->addItem("diff_kappa",m_diff_kappa);
                status12 = m_nt12->addItem("diff_dz",m_diff_dz);
                status12 = m_nt12->addItem("diff_tanl",m_diff_tanl);
                status12 = m_nt12->addItem("diff_p",m_diff_p);
                if( status12.isFailure() ) cout<<"Ntuple12 add item failed!"<<endl; 
            }
        }
    }
}

Referenced by initialize().

hist_def() [2/2]

void KalFitAlg::hist_def

(

void

)

hist definition

init_matrix() [1/4]

void KalFitAlg::init_matrix	(	int	k,
		MdcRec_trk &	trk,
		HepSymMatrix &	Ea
	)

Definition at line 6036 of file KalFitAlg.cxx.

{
    if(0==k){
        for ( int i=0; i<5; i++) {
            for( int j = 1; j<i+2;j++) {
                Eakal(i+1,j) = matrixg_*(trk.error[i*(i+1)/2+j-1]);
                Eakal(j,i+1) = Eakal(i+1,j);
            }
            Eakal(1,1) = Eakal(1,1)* gain1_;
            Eakal(2,2) = Eakal(2,2)* gain2_;
            Eakal(3,3) = Eakal(3,3)* gain3_;
            Eakal(4,4) = Eakal(4,4)* gain4_;
            Eakal(5,5) = Eakal(5,5)* gain5_;
        }
    }
    //  HepSymMatrix ea_temp(5);
    //    for(int i = 0, k = 0; i < 5; i++) {
    //      for(int j = 0; j <= i; j++) {
    //        ea_temp[i][j] = matrixg_*trk.error[k++];
    //        ea_temp[j][i] = ea_temp[i][j];
    //      }
    //    }
 
    if(1==k){
        Eakal(1,1) = .2;
        Eakal(2,2) = .001;
        Eakal(3,3) = 1.0;
        Eakal(4,4) = 10.0;
        Eakal(5,5) = 0.002;
    }
 
    if(2==k){
        Eakal(1,1) = .2;
        Eakal(2,2) = 0.1;
        Eakal(3,3) = 1.0;
        Eakal(4,4) = 25.0;
        Eakal(5,5) = 0.10;
    }
 
 
    if(3==k){
        Eakal(1,1) = .2;
        Eakal(2,2) = .001;
        Eakal(3,3) = 1.0;
        Eakal(4,4) = 25.0;
        Eakal(5,5) = 0.10;
    }
 
    if(4==k){
        Eakal(1,1) = .2;
        Eakal(2,2) = .01;
        Eakal(3,3) = 0.01;
        Eakal(4,4) = 1.;
        Eakal(5,5) = .01;
    }
 
    if(5==k) {
        Eakal(1,1) = 2.;
        Eakal(2,2) = 0.1;
        Eakal(3,3) = 1.;
        Eakal(4,4) = 20.;
        Eakal(5,5) = 0.1;
    }
 
    if(6==k) {
        Eakal(1,1) = 0.01;
        Eakal(2,2) = 0.01;
        Eakal(3,3) = 0.01;
        Eakal(4,4) = 100.;
        Eakal(5,5) = 0.5;
    }
 
    if(k!=0){
        Eakal(3,3) = 0.2;
        Eakal(1,1) = 1;
        Eakal(4,4) = 1;
    }
 
    if (debug_ == 4) cout<<"initialised Eakal.. "<<Eakal<<endl;
}

init_matrix() [2/4]

void KalFitAlg::init_matrix	(	int	k,
		MdcRec_trk &	trk,
		HepSymMatrix &	Ea
	)

init_matrix() [3/4]

void KalFitAlg::init_matrix	(	MdcRec_trk &	trk,
		HepSymMatrix &	Ea
	)

Definition at line 6022 of file KalFitAlg.cxx.

{
    for ( int i=0; i<5; i++) {
        for( int j = 1; j<i+2;j++) {
            Eakal(i+1,j) = matrixg_*(trk.error[i*(i+1)/2+j-1]);
            Eakal(j,i+1) = Eakal(i+1,j);
        }
    }
 
    if (debug_ == 4) cout<<"initialised Ea.. "<<Eakal<<endl;
}

Referenced by complete_track(), kalman_fitting_anal(), kalman_fitting_calib(), kalman_fitting_csmalign(), kalman_fitting_MdcxReco_Csmc_Sew(), and start_seed().

init_matrix() [4/4]

void KalFitAlg::init_matrix	(	MdcRec_trk &	trk,
		HepSymMatrix &	Ea
	)

initialize() [1/2]

StatusCode KalFitAlg::initialize

(

)

initialize

Definition at line 204 of file KalFitAlg.cxx.

{
    MsgStream log(msgSvc(), name());
    log << MSG::INFO << "in initize()" 
        << "KalFit> Initialization for current run " << endreq;
    log << MSG::INFO << "Present Parameters: muls: " << muls_ <<"  loss:  "
        << loss_ <<" matrixg "<< matrixg_ <<" lr "<< lr_ 
        << " debug " << debug_ << " ntuple " << ntuple_
        << " activeonly "<< activeonly_ << endreq;
 
    KalFitTrack::LR(lr_);
    KalFitTrack::resol(resolution_);
    KalFitTrack::Tof_correc_ = tofflag_;
    KalFitTrack::tofall_ = tof_hyp_;
    KalFitTrack::chi2_hitf_ = dchi2cutf_;
    KalFitTrack::chi2_hits_ = dchi2cuts_;
    KalFitTrack::factor_strag_ = fstrag_;
    KalFitTrack::debug_ = debug_kft_;
    KalFitTrack::drifttime_choice_ = drifttime_choice_;
    KalFitTrack::steplev_ = steplev_;
    KalFitTrack::numfcor_ = numfcor_;
    KalFitTrack::inner_steps_ = inner_steps_;
    KalFitTrack::outer_steps_ = outer_steps_;
    KalFitTrack::tprop_ = tprop_;
 
    setDchisqCut();
    // Delete properly the geometry objects if already existing
    clean();
    log << MSG::INFO << ".....building Mdc " << endreq;
 
    // Set objects and material properties for Mdc detector :
    //setMaterial_Mdc();
    //setCylinder_Mdc();
 
    setBesFromGdml();
    // initialize the MdcCalibFunSvc 
    setCalibSvc_init(); 
    //
    //  // initialize the MdcGeomSvc
    //  setGeomSvc_init();
    //getEventStarTime();
    //  // Wires, Layers and SuperLayers of Mdc :
    //  set_Mdc();
    // define histograms and Ntuples
    hist_def();
 
 
    IMagneticFieldSvc* IMFSvc; 
    StatusCode sc = service ("MagneticFieldSvc",IMFSvc); 
    if(sc!=StatusCode::SUCCESS) { 
        log << MSG::ERROR << "Unable to open Magnetic field service"<<endreq; 
    }
    KalFitTrack::setMagneticFieldSvc(IMFSvc);
 
    // Nominal magnetic field :
    if (KalFitTrack::numfcor_){
        KalFitTrack::Bznom_ = (IMFSvc->getReferField())*10000; //unit is KGauss
        if(0 == KalFitTrack::Bznom_)   KalFitTrack::Bznom_ = -10;
 
        if(4 == debug_){
            std::cout<<" initialize, referField from MagneticFieldSvc: "<< (IMFSvc->getReferField())*10000 <<std::endl;
            std::cout<<" magnetic field: "<<KalFitTrack::Bznom_<<std::endl;
        }
 
    }
 
    // Print out of the status of the flags :
    if (ntuple_) 
        log << MSG::INFO <<" ntuple out, the option is  "<< ntuple_ <<endreq;
    if (debug_ >0 ) {
        cout << "KalFitAlg> DEBUG open,Here is the important Parameters :\n";
        cout << " Leading particule with mass hyp = " << lead_ << std::endl;
        cout << " mhyp = " << mhyp_ << std::endl;
        cout << "===== Effects taking into account : " << std::endl;
        cout << " - multiple scattering = " << muls_ << std::endl;
        cout << " - energy loss = " << loss_ << std::endl;
        if (KalFitTrack::strag_)
            cout << " - straggling for the energy loss " << std::endl;
        cout << " - nominal Bz value = " << KalFitTrack::Bznom_ << std::endl;
 
        if (KalFitTrack::numf_ > 19)
            cout << " - non uniform magnetic field treatment " 
                << KalFitTrack::numf_ << std::endl;
        cout << " - wire sag correction = " << wsag_ << std::endl;
        cout << " - Tof correction = " << KalFitTrack::Tof_correc_ << std::endl;
        cout << " - chi2 cut for each hit = " << KalFitTrack::chi2_hitf_ 
            << std::endl << " is applied after " << KalFitTrack::nmdc_hit2_ 
            << " hits included " << std::endl;
 
        if (back_){
            cout << " Backward filter is on with a pT cut value = " << pT_ << endl;
        }
        if(debug_ == 4) cout << " pathl = " << pathl_ << std::endl;
 
        if (KalFitTrack::LR_==1)
            cout << " Decision L/R from MdcRecHit " << std::endl;
    }
 
    KalFitElement::muls(muls_);
    KalFitElement::loss(loss_);
    KalFitTrack::lead(lead_);
    KalFitTrack::back(back_);
    KalFitTrack::numf(numf_);
    // Get the Particle Properties Service
    IPartPropSvc* p_PartPropSvc;
    static const bool CREATEIFNOTTHERE(true);
    StatusCode PartPropStatus = service("PartPropSvc", p_PartPropSvc, CREATEIFNOTTHERE);
    if (!PartPropStatus.isSuccess() || 0 == p_PartPropSvc) {
        log << MSG::WARNING << " Could not initialize Particle Properties Service" << endreq;
        return StatusCode::SUCCESS; 
    }
    m_particleTable = p_PartPropSvc->PDT();
 
    return StatusCode::SUCCESS; 
}

initialize() [2/2]

StatusCode KalFitAlg::initialize

(

)

initialize

innerwall() [1/6]

void KalFitAlg::innerwall	(	KalFitTrack &	track,
		int	l_mass,
		int	way,
		double	r1,
		double	r2,
		int &	index
	)

Definition at line 3261 of file KalFitAlg.cxx.

                                                                                                  {
    if (debug_ ==4) cout<<"innerwall....."<<endl;
    double ri=(r1<r2)?r1:r2;
    double ro=(r1<r2)?r2:r1;
    double Rmin,Rmax;
    int step;
    vector<KalFitCylinder>::iterator it;
    vector<KalFitCylinder>::iterator itStart;
    vector<KalFitCylinder>::iterator itStop;
    if(way<0){
        step=-1;
        itStart=_BesKalmanFitWalls.end()-index-1;
        itStop =_BesKalmanFitWalls.begin()-1;
    }
    else{
        step=1;
        itStart=_BesKalmanFitWalls.begin()+index;
        itStop =_BesKalmanFitWalls.end();
    }
    for(it=itStart; it != itStop; it=it+step) {
        if(ri < it->rmin() && it->radius() < ro) {
            it->updateTrack(track,way);
            Rmin=it->rmin();
            Rmax=it->radius();
            continue;
        }
        else if(it->rmin() <= ri && ri <= it->radius() && it->radius() < ro){
            it->updateTrack(track,way,ri,it->radius());
            Rmin=ri;
            Rmax=it->radius();
            if(way>0){
                //index = it - _BesKalmanFitWalls.begin();
                break;
            }
            else continue;
        }
        else if(ri < it->rmin() && it->rmin() <= ro && ro <= it->radius()){
            it->updateTrack(track,way,it->rmin(),ro);
            Rmin=it->rmin();
            Rmax=ro;
            if(way<0){
                //index = _BesKalmanFitWalls.end() - it;
                break;
            }
            else continue;
        }
        else if(it->radius()<ri || ro < it->rmin()){
            continue;
        }
        else {
            it->updateTrack(track,way,ri,ro);
            Rmin=ri;
            Rmax=ro;
            //index=it-_BesKalmanFitWalls.begin();
            break;
        }
    }
    if(way<0){
        //double phi=track.intersect_cylinder(Rmax);
        //HepPoint3D pivot=track.x(phi);
        //track.pivot_numf(pivot);
        track.pivot_numf(track.x(track.intersect_cylinder(Rmax)));
        index = _BesKalmanFitWalls.end() - it-1;
    }
    else{
        //double phi=track.intersect_cylinder(Rmin);
        //HepPoint3D pivot=track.x(phi);
        //track.pivot_numf(pivot);
        track.pivot_numf(track.x(track.intersect_cylinder(Rmin)));
        index = it - _BesKalmanFitWalls.begin();
    }
 
}

innerwall() [2/6]

void KalFitAlg::innerwall	(	KalFitTrack &	track,
		int	l_mass,
		int	way,
		double	r1,
		double	r2,
		int &	index
	)

innerwall() [3/6]

void KalFitAlg::innerwall	(	KalFitTrack &	trk,
		int	l_mass,
		int	way
	)

Take the inner walls (eloss and mult scat) into account.

Definition at line 3242 of file KalFitAlg.cxx.

                                                                {
 
    if (debug_ ==4) cout<<"innerwall....."<<endl;
    for(int i = 0; i < _BesKalmanFitWalls.size(); i++) {
        _BesKalmanFitWalls[i].updateTrack(track, way);
        if (debug_ == 4) cout<<"Wall "<<i<<" update the track!(filter)"<<endl;
    }
}

Referenced by Cgem_filter_anal(), complete_track(), and fitGemHits().

innerwall() [4/6]

void KalFitAlg::innerwall	(	KalFitTrack &	trk,
		int	l_mass,
		int	way
	)

Take the inner walls (eloss and mult scat) into account.

innerwall() [5/6]

void KalFitAlg::innerwall	(	KalFitTrack &	trk,
		int	l_mass,
		int	way,
		int	begin,
		int	end
	)

Definition at line 3251 of file KalFitAlg.cxx.

                                                                                  {
    if (debug_ ==4) cout<<"innerwall....."<<endl;
    for(int i = begin; i <= end; i++) {
        _BesKalmanFitWalls[i].updateTrack(track, way);
        if(debug_ == 4){cout << "wall" << i << endl;
            cout <<"track" << "pivot=" << track.pivot() << "a=" << track.a() << "ea=" <<track.Ea() << endl;}
            if (debug_ == 4) cout<<"Wall "<<i<<" update the track!(filter)"<<endl;
    }
}

innerwall() [6/6]

void KalFitAlg::innerwall	(	KalFitTrack &	trk,
		int	l_mass,
		int	way,
		int	begin,
		int	end
	)

kalman_fitting_anal() [1/2]

void KalFitAlg::kalman_fitting_anal

(

void

)

very low momentum and very big costheta angle, use special initial error matrix

chose different initial error matrix

Definition at line 3340 of file KalFitAlg.cxx.

{
 
    //cout<<"kalman_fitting_anal deal with a new event"<<endl;//wangll
 
    MsgStream log(msgSvc(), name());
    double Pt_threshold(0.3);
    Hep3Vector IP(0,0,0);
    vector<MdcRec_trk>* mdcMgr = MdcRecTrkCol::getMdcRecTrkCol();
    vector<MdcRec_trk_add>* mdc_addMgr = MdcRecTrkAddCol::getMdcRecTrkAddCol();
    vector<MdcRec_wirhit>* whMgr = MdcRecWirhitCol::getMdcRecWirhitCol();    
 
    // Table Manager
    if ( !&whMgr ) return;
 
    // Get reduced chi**2 of Mdc track :
    int ntrk = mdcMgr->size();
    double* rPt = new double[ntrk];
    int* rOM = new int[ntrk];
    unsigned int* order = new unsigned int[ntrk];
    unsigned int* rCont = new unsigned int[ntrk];
    unsigned int* rGen = new unsigned int[ntrk];
 
    if(testOutput) cout<<"nMdcTrk = "<<ntrk<<endl;
 
    int index = 0;
    for(vector<MdcRec_trk>::iterator it  = mdcMgr->begin(),
            end = mdcMgr->end(); it != end; it++) {
        // Pt
        rPt[index] = 0;
        if (it->helix[2])
            rPt[index] = 1 / fabs(it->helix[2]);
        if(debug_ == 4) cout<<"rPt...[ "<<index<<" ]...."<< rPt[index] <<endl;
        if(rPt[index] < 0) rPt[index] = DBL_MAX;
        // Outermost layer 
        std::vector<MdcRec_wirhit*> pt = it->hitcol ;
        if(debug_ == 4) cout<<"ppt size:  "<< pt.size()<<endl;
        int outermost(-1);
        for (vector<MdcRec_wirhit*>::iterator ii = pt.end()-1;
                ii !=pt.begin()-1; ii--) {
            int lyr((*ii)->geo->Lyr()->Id());
            if (outermost < lyr) outermost = lyr;
            if(debug_ == 4) cout<<"outmost:  "<<outermost<<"   lyr:  "<<lyr<<endl;
        }
        rOM[index] = outermost;
        order[index] = index;
        ++index;
    }
 
    // Sort Mdc tracks by Pt
    for (int j, k = ntrk - 1; k >= 0; k = j){
        j = -1;
        for(int i = 1; i <= k; i++)
            if(rPt[i - 1] < rPt[i]){
                j = i - 1;
                std::swap(order[i], order[j]);
                std::swap(rPt[i], rPt[j]);
                std::swap(rOM[i], rOM[j]);
                std::swap(rCont[i], rCont[j]);
                std::swap(rGen[i], rGen[j]);
            }
    }
    delete [] rPt;
 
    //
    int newcount(0);
    //check whether  Recon  already registered
    DataObject *aReconEvent;
    eventSvc()->findObject("/Event/Recon",aReconEvent);
    if(!aReconEvent) {
        // register ReconEvent Data Object to TDS;
        ReconEvent* recevt = new ReconEvent;
        StatusCode sc = eventSvc()->registerObject("/Event/Recon",recevt );
        if(sc!=StatusCode::SUCCESS) {
            log << MSG::FATAL << "Could not register ReconEvent" <<endreq;
            return;
        }
    }
 
    RecMdcKalTrackCol* kalcol = new RecMdcKalTrackCol;   
    RecMdcKalHelixSegCol *segcol =new RecMdcKalHelixSegCol;
    //make RecMdcKalTrackCol
    log << MSG::INFO << "beginning to make RecMdcKalTrackCol" <<endreq;     
    // Loop over tracks given by trasan :
    for(int l = 0; l < ntrk; l++) {
 
        //cout<<"----------------"<<endl;//wangll
        //cout<<"track "<<l<<" : "<<endl;//wangll
        nTotalTrks++;
 
        for(int i=0; i<5; i++) iqual_front_[i] = 1; // wangll 2010-11-01
 
        //    m_timer[3]->start();
        MdcRec_trk& TrasanTRK = *(mdcMgr->begin() + order[l]);     
        MdcRec_trk_add& TrasanTRK_add = *(mdc_addMgr->begin()+order[l]);
 
        // Reject the ones with quality != 0 
        int trasqual = TrasanTRK_add.quality;
        if(debug_ == 4) cout<<"kalman_fitting>trasqual... "<<trasqual<<endl; 
        if (trasqual) continue;
 
        newcount++;
        if (debug_ == 4)
            cout << "******* KalFit NUMBER : " << newcount << std::endl;      
 
        // What kind of KalFit ? 
        int type(0);
        if ((TrasanTRK_add.decision & 32) == 32 ||
                (TrasanTRK_add.decision & 64) == 64)      type = 1;
 
        // Initialisation : (x, a, ea)
        HepPoint3D x(TrasanTRK.pivot[0],
                TrasanTRK.pivot[1],
                TrasanTRK.pivot[2]);
 
        HepVector a(5);
        for(int i = 0; i < 5; i++)
            a[i] = TrasanTRK.helix[i];
 
        HepSymMatrix ea(5);
        for(int i = 0, k = 0; i < 5; i++) {
            for(int j = 0; j <= i; j++) {
                ea[i][j] = matrixg_*TrasanTRK.error[k++];
                ea[j][i] = ea[i][j];
            }
        }
        double fiTerm = TrasanTRK.fiTerm;
        int way(1);
        // Prepare the track found :
        KalFitTrack track_lead = KalFitTrack(x, a, ea, lead_, 0, 0);
 
        track_lead.bFieldZ(KalFitTrack::Bznom_);
 
        // Mdc Hits 
        int inlyr(999), outlyr(-1);
        int* rStat = new int[43];
        for(int irStat=0;irStat<43;++irStat)rStat[irStat]=0;
        std::vector<MdcRec_wirhit*> pt=TrasanTRK.hitcol;
        int hit_in(0);
        if(debug_ == 4) cout<<"*********Pt size****"<< pt.size()<<endl;
        // Number of hits/layer 
        int Num[43] = {0};
        for (vector<MdcRec_wirhit*>::iterator ii = pt.end()-1;
                ii != pt.begin()-1; ii--) {
            Num[(*ii)->geo->Lyr()->Id()]++;
        }
        int hit_asso(0);
        for (vector<MdcRec_wirhit*>::iterator ii = pt.end()-1;
                ii != pt.begin()-1; ii--) { 
            hit_asso++;
            if (Num[(*ii)->geo->Lyr()->Id()]>3) {
                if (debug_ >0)
                    cout << "WARNING:  I found " << Num[(*ii)->geo->Lyr()->Id()] 
                        << " hits in the layer "
                        << (*ii)->geo->Lyr()->Id() << std::endl;
                continue;
            }
            //   if(ii!=pt.end()-1){
            //       int layer_before=(*(ii+1))->geo->Lyr()->Id();
            //       if(layer_before == (*ii)->geo->Lyr()->Id()){
            //           MdcRec_wirhit * rechit_before = *(ii+1);
            //           if((*rechit_before).rechitptr->getDriftT()>450 || (**ii).rechitptr->getDriftT()>450.){
            //               if((*rechit_before).tdc < (**ii).tdc) continue;
            //               else if(track_lead.HitsMdc().size()>0 && rStat[layer_before]){
            //                   track_lead.HitsMdc().pop_back();
            //               }
            //           }
            //       }
            //   }
 
            hit_in++;
            MdcRec_wirhit & rechit = **ii;
            double dist[2] = {rechit.ddl, rechit.ddr};
            double erdist[2] = {rechit.erddl, rechit.erddr};
            const MdcGeoWire* geo = rechit.geo;
 
            int lr_decision(0);
            if (KalFitTrack::LR_ == 1){
                if (rechit.lr==2 || rechit.lr==0) lr_decision=-1;
                //  if (rechit.lr==0) lr_decision=-1;
                else if (rechit.lr==1) lr_decision=1;
            } 
 
            int ind(geo->Lyr()->Id());
 
            //  ATTENTION HERE!!!
            track_lead.appendHitsMdc( KalFitHitMdc(rechit.id,
                        lr_decision, rechit.tdc,
                        dist, erdist, 
                        _wire+(geo->Id()), rechit.rechitptr));
            // inner/outer layer :
            rStat[ind]++;
            if (inlyr>ind) inlyr = ind;
            if (outlyr<ind) outlyr = ind;
        }
        if (debug_ == 4) 
            cout << "**** NUMBER OF Mdc HITS (TRASAN) = " << hit_asso << std::endl;
 
        // Empty layers :
        int empty_between(0), empty(0);
        for (int i= inlyr; i <= outlyr; i++)
            if (!rStat[i]) empty_between++;
        empty = empty_between+inlyr+(42-outlyr);
        delete [] rStat;
 
        // RMK high momentum track under study, probably not neeeded...
        track_lead.order_wirhit(1);
        //track_lead.order_hits();
 
        for(std::vector<KalFitHitMdc>::iterator it_hit = track_lead.HitsMdc().begin(); it_hit!=track_lead.HitsMdc().end(); it_hit++){
            //std::cout<<" the id of this hits after sorting in PatRec is "<<it_hit->id()<<std::endl;    
            //std::cout<<" the layerid of the hit is "<<it_hit->wire().layer().layerId()<<std::endl; 
            //std::cout<<" the cellid of this wire is "<<it_hit->wire().localId()<<std::endl;
        }
 
        track_lead.type(type);
        track_lead.trasan_id(TrasanTRK.id);
        unsigned int nhit = track_lead.HitsMdc().size();
        if (!nhit && debug_ == 4) {
            cout << " ATTENTION TRACK WITH ONLY HITS " << nhit << std::endl;
            continue;
        }
 
        // Initialisation :
        double  KalFitst(0), KalFitax(0), KalFitschi2(0);
        // Move to the outer hit : 
 
        Hep3Vector outer_pivot(track_lead.x(fiTerm));
 
        track_lead.pivot(outer_pivot);
 
        track_lead.bFieldZ(KalFitTrack::Bznom_);
        // attention best_chi2 reinitialize !!! 
        if (nhit>=3 && !KalFitTrack::LR_) 
            start_seed(track_lead, lead_, way, TrasanTRK);
        HepSymMatrix Eakal(5,0);
 
        /// very low momentum and very big costheta angle, use special initial error matrix
        double costheta = track_lead.a()[4] / sqrt(1.0 + track_lead.a()[4]*track_lead.a()[4]); 
        if( (1.0/fabs(track_lead.a()[2]) < pt_cut_ ) && (fabs(costheta)> theta_cut_) ) {
            choice_ = 6;
        }
 
        /// chose different initial error matrix
        init_matrix(choice_,TrasanTRK, Eakal);
 
 
        if (debug_ == 4){
            cout << "from Mdc Pattern Recognition: " << std::endl;
            HepPoint3D IP(0,0,0);
            Helix work(track_lead.pivot(), 
                    track_lead.a(),
                    track_lead.Ea());
            work.pivot(IP);
            cout << " dr = " << work.a()[0] 
                << ", Er_dr = " << sqrt(work.Ea()[0][0]) << std::endl;
            cout << " phi0 = " << work.a()[1] 
                << ", Er_phi0 = " << sqrt(work.Ea()[1][1]) << std::endl;
            cout << " PT = " << 1/work.a()[2] 
                << ", Er_kappa = " << sqrt(work.Ea()[2][2]) << std::endl;
            cout << " dz = " << work.a()[3] 
                << ", Er_dz = " << sqrt(work.Ea()[3][3]) << std::endl;
            cout << " tanl = " << work.a()[4] 
                << ", Er_tanl = " << sqrt(work.Ea()[4][4]) << std::endl;
        }
 
        if(testOutput) {
            cout<<"----------------------"<<endl;//660a
            cout<<"track "<<l<<", pid = "<<lead_<<": "<<endl;
            //int n_hits=(*itRecMdcTrack)->getNhits();
            //int n_hit_Axis=n_hits-(*itRecMdcTrack)->nster();
            //cout<<"nMdcHits,nMdcHitsAxis = "<<n_hits<<", "<<n_hit_Axis<<endl;//660a
            //cout<<"----------------------"<<endl;
            //cout<<"# old  track par #"<<endl<<" pivot: "<<track.pivot()<<endl<<" helix: "<<track.a()<<endl<<" error: "<<track.Ea()<<endl;
            //cout<<"# true track par #"<<endl<<" helix: "<<mc_a<<endl;
        }
 
 
        filter_fwd_anal(track_lead, lead_, way, Eakal);
 
        // std::cout<<" step3, track_lead.Ea: "<<track_lead.Ea()<<std::endl;
        track_lead.update_forMdc();
 
        HepPoint3D IP(0,0,0);    
        if (debug_ == 4) {
            cout << " Mdc FIRST KALMAN FIT " << std::endl;
            Helix work(track_lead.pivot(), 
                    track_lead.a(),
                    track_lead.Ea());
            work.pivot(IP);
            cout << " dr = " << work.a()[0] 
                << ", Er_dr = " << sqrt(work.Ea()[0][0]) << std::endl;
            cout << " phi0 = " << work.a()[1] 
                << ", Er_phi0 = " << sqrt(work.Ea()[1][1]) << std::endl;
            cout << " PT = " << 1/work.a()[2] 
                << ", Er_kappa = " << sqrt(work.Ea()[2][2]) << std::endl;
            cout << " dz = " << work.a()[3] 
                << ", Er_dz = " << sqrt(work.Ea()[3][3]) << std::endl;
            cout << " tanl = " << work.a()[4] 
                << ", Er_tanl = " << sqrt(work.Ea()[4][4]) << std::endl;
        }
 
        // fill TDS
        RecMdcKalTrack* kaltrk = new RecMdcKalTrack;
        // Complete the track (other mass assumption, backward) and 
        complete_track(TrasanTRK, TrasanTRK_add, track_lead, kaltrk,kalcol,segcol,1);
    }
 
 
    IDataProviderSvc* eventSvc = NULL;
    Gaudi::svcLocator()->service("EventDataSvc", eventSvc);
    if (eventSvc) {
        log << MSG::INFO << "makeTds:event Svc has been found" << endreq;
    } else {
        log << MSG::FATAL << "makeTds:Could not find eventSvc" << endreq;
        return ;
    }
    StatusCode kalsc;
    IDataManagerSvc *dataManSvc;
    dataManSvc= dynamic_cast<IDataManagerSvc*>(eventSvc);
    DataObject *aKalTrackCol;
    eventSvc->findObject("/Event/Recon/RecMdcKalTrackCol",aKalTrackCol);
    if(aKalTrackCol != NULL) {
        dataManSvc->clearSubTree("/Event/Recon/RecMdcKalTrackCol");
        eventSvc->unregisterObject("/Event/Recon/RecMdcKalTrackCol");
    }
    kalsc = eventSvc->registerObject("/Event/Recon/RecMdcKalTrackCol", kalcol);
    if( kalsc.isFailure() ) {
        log << MSG::FATAL << "Could not register RecMdcKalTrack" << endreq;
        return ; 
    }
    log << MSG::INFO << "RecMdcKalTrackCol registered successfully!" <<endreq;
    StatusCode segsc;
    //check whether the RecMdcKalHelixSegCol has been already registered
    DataObject *aRecKalSegEvent;
    eventSvc->findObject("/Event/Recon/RecMdcKalHelixSegCol", aRecKalSegEvent);
    if(aRecKalSegEvent!=NULL) {
        //then unregister RecMdcKalHelixSegCol
        segsc = eventSvc->unregisterObject("/Event/Recon/RecMdcKalHelixSegCol");
        if(segsc != StatusCode::SUCCESS) {
            log << MSG::FATAL << "Could not unregister RecMdcKalHelixSegCol collection" << endreq;
            return;
        }
    }
    segsc = eventSvc->registerObject("/Event/Recon/RecMdcKalHelixSegCol", segcol);
    if( segsc.isFailure() ) {
        log << MSG::FATAL << "Could not register RecMdcKalHelixSeg" << endreq;
        return;
    }
    log << MSG::INFO << "RecMdcKalHelixSegCol registered successfully!" <<endreq;
 
    double x1(0.),x2(0.),y1(0.),y2(0.),z1(0.),z2(0.),the1(0.),the2(0.),phi1(0.),phi2(0.),p1(0.),p2(0.);
    double r1(0.),r2(0.),kap1(999.),kap2(999.),tanl1(0),tanl2(0.); 
    double px1(0.),px2(0.),py1(0.),py2(0.),pz1(0.),pz2(0.),charge1(0.),charge2(0.);
 
    //check the result:RecMdcKalTrackCol   
    SmartDataPtr<RecMdcKalTrackCol> kaltrkCol(eventSvc,"/Event/Recon/RecMdcKalTrackCol");
    if (!kaltrkCol) { 
        log << MSG::FATAL << "Could not find RecMdcKalTrackCol" << endreq;
        return;
    }
    log << MSG::INFO << "Begin to check RecMdcKalTrackCol"<<endreq;
    RecMdcKalTrackCol::iterator iter_trk = kaltrkCol->begin();
    for( int jj=1; iter_trk != kaltrkCol->end(); iter_trk++,jj++) {
        log << MSG::DEBUG << "retrieved MDC Kalmantrack:"
            << "Track Id: " << (*iter_trk)->getTrackId()
            << " Mass of the fit: "<< (*iter_trk)->getMass(2)<< endreq
            << " Length of the track: "<< (*iter_trk)->getLength(2)
            << "  Tof of the track: "<< (*iter_trk)->getTof(2) << endreq
            << " Chisq of the fit: "<< (*iter_trk)->getChisq(0,2)
            <<"  "<< (*iter_trk)->getChisq(1,2) << endreq
            << "Ndf of the fit: "<< (*iter_trk)->getNdf(0,2)
            <<"  "<< (*iter_trk)->getNdf(1,2) << endreq
            << "Kappa " << (*iter_trk)->getZHelix()[2]
            << endreq;
        for( int i = 0; i<43; i++) {
            log << MSG::DEBUG << "retrieved pathl["<<i<<"]= "
                << (*iter_trk)->getPathl(i) <<endreq;
        }
        if(ntuple_&1) {
            m_trackid = (*iter_trk)->getTrackId();
 
            for( int jj =0, iii=0; jj<5; jj++) {
 
                m_length[jj] = (*iter_trk)->getLength(jj);
                m_tof[jj] = (*iter_trk)->getTof(jj);
                m_nhits[jj] = (*iter_trk)->getNhits(jj);
                m_zhelix[jj] = (*iter_trk)->getZHelix()[jj];
                m_zhelixe[jj] = (*iter_trk)->getZHelixE()[jj];
                m_zhelixmu[jj] = (*iter_trk)->getZHelixMu()[jj];
                m_zhelixk[jj] = (*iter_trk)->getZHelixK()[jj];
                m_zhelixp[jj] = (*iter_trk)->getZHelixP()[jj];
                m_fhelix[jj] = (*iter_trk)->getFHelix()[jj];
                m_fhelixe[jj] = (*iter_trk)->getFHelixE()[jj];
                m_fhelixmu[jj] = (*iter_trk)->getFHelixMu()[jj];
                m_fhelixk[jj] = (*iter_trk)->getFHelixK()[jj];
                m_fhelixp[jj] = (*iter_trk)->getFHelixP()[jj];
                m_lhelix[jj] = (*iter_trk)->getLHelix()[jj];
                m_lhelixe[jj] = (*iter_trk)->getLHelixE()[jj];
                m_lhelixmu[jj] = (*iter_trk)->getLHelixMu()[jj];
                m_lhelixk[jj] = (*iter_trk)->getLHelixK()[jj];
                m_lhelixp[jj] = (*iter_trk)->getLHelixP()[jj];
 
                if(ntuple_&32) {
                    for(int kk=0; kk<=jj; kk++,iii++) {
                        m_zerror[iii] = (*iter_trk)->getZError()[jj][kk];
                        m_zerrore[iii] = (*iter_trk)->getZErrorE()[jj][kk];
                        m_zerrormu[iii] = (*iter_trk)->getZErrorMu()[jj][kk];
                        m_zerrork[iii] = (*iter_trk)->getZErrorK()[jj][kk];
                        m_zerrorp[iii] = (*iter_trk)->getZErrorP()[jj][kk];
                        m_ferror[iii] = (*iter_trk)->getFError()[jj][kk];
                        m_ferrore[iii] = (*iter_trk)->getFErrorE()[jj][kk];
                        m_ferrormu[iii] = (*iter_trk)->getFErrorMu()[jj][kk];
                        m_ferrork[iii] = (*iter_trk)->getFErrorK()[jj][kk];
                        m_ferrorp[iii] = (*iter_trk)->getFErrorP()[jj][kk];
                        m_lerror[iii] = (*iter_trk)->getLError()[jj][kk];
                        m_lerrore[iii] = (*iter_trk)->getLErrorE()[jj][kk];
                        m_lerrormu[iii] = (*iter_trk)->getLErrorMu()[jj][kk];
                        m_lerrork[iii] = (*iter_trk)->getLErrorK()[jj][kk];
                        m_lerrorp[iii] = (*iter_trk)->getLErrorP()[jj][kk];
                    }
                }
            }
 
            //       // the following logic may seem peculiar, but it IS the case(for BOSS5.0 and BOSS5.1)
            //       m_chisq[0][0] = (*iter_trk)->getChisq(0,0);
            //       m_chisq[0][1] = (*iter_trk)->getChisq(0,1);
            //       m_chisq[1][0] = (*iter_trk)->getChisq(0,2);
            //       m_chisq[1][1] = (*iter_trk)->getChisq(0,3);
            //       m_chisq[2][0] = (*iter_trk)->getChisq(0,4);
            //       m_chisq[2][1] = (*iter_trk)->getChisq(1,0);
            //       m_chisq[3][0] = (*iter_trk)->getChisq(1,1);
            //       m_chisq[3][1] = (*iter_trk)->getChisq(1,2);
            //       m_chisq[4][0] = (*iter_trk)->getChisq(1,3);
            //       m_chisq[4][1] = (*iter_trk)->getChisq(1,4);
 
            //       m_ndf[0][0] = (*iter_trk)->getNdf(0,0);
            //       m_ndf[0][1] = (*iter_trk)->getNdf(0,1);
            //       m_ndf[1][0] = (*iter_trk)->getNdf(0,2);
            //       m_ndf[1][1] = (*iter_trk)->getNdf(0,3);
            //       m_ndf[2][0] = (*iter_trk)->getNdf(0,4);
            //       m_ndf[2][1] = (*iter_trk)->getNdf(1,0);
            //       m_ndf[3][0] = (*iter_trk)->getNdf(1,1);
            //       m_ndf[3][1] = (*iter_trk)->getNdf(1,2);
            //       m_ndf[4][0] = (*iter_trk)->getNdf(1,3);
            //       m_ndf[4][1] = (*iter_trk)->getNdf(1,4);
 
            //       m_stat[0][0] = (*iter_trk)->getStat(0,0);
            //       m_stat[0][1] = (*iter_trk)->getStat(0,1);
            //       m_stat[1][0] = (*iter_trk)->getStat(0,2);
            //       m_stat[1][1] = (*iter_trk)->getStat(0,3);
            //       m_stat[2][0] = (*iter_trk)->getStat(0,4);
            //       m_stat[2][1] = (*iter_trk)->getStat(1,0);
            //       m_stat[3][0] = (*iter_trk)->getStat(1,1);
            //       m_stat[3][1] = (*iter_trk)->getStat(1,2);
            //       m_stat[4][0] = (*iter_trk)->getStat(1,3);
            //       m_stat[4][1] = (*iter_trk)->getStat(1,4);
 
            // RootConversion changed in BOSS6.0, so use thefollowing:
            m_chisq[0][0] = (*iter_trk)->getChisq(0,0);
            m_chisq[1][0] = (*iter_trk)->getChisq(0,1);
            m_chisq[2][0] = (*iter_trk)->getChisq(0,2);
            m_chisq[3][0] = (*iter_trk)->getChisq(0,3);
            m_chisq[4][0] = (*iter_trk)->getChisq(0,4);
            m_chisq[0][1] = (*iter_trk)->getChisq(1,0);
            m_chisq[1][1] = (*iter_trk)->getChisq(1,1);
            m_chisq[2][1] = (*iter_trk)->getChisq(1,2);
            m_chisq[3][1] = (*iter_trk)->getChisq(1,3);
            m_chisq[4][1] = (*iter_trk)->getChisq(1,4);
 
            m_ndf[0][0] = (*iter_trk)->getNdf(0,0);
            m_ndf[1][0] = (*iter_trk)->getNdf(0,1);
            m_ndf[2][0] = (*iter_trk)->getNdf(0,2);
            m_ndf[3][0] = (*iter_trk)->getNdf(0,3);
            m_ndf[4][0] = (*iter_trk)->getNdf(0,4);
            m_ndf[0][1] = (*iter_trk)->getNdf(1,0);
            m_ndf[1][1] = (*iter_trk)->getNdf(1,1);
            m_ndf[2][1] = (*iter_trk)->getNdf(1,2);
            m_ndf[3][1] = (*iter_trk)->getNdf(1,3);
            m_ndf[4][1] = (*iter_trk)->getNdf(1,4);
 
            m_stat[0][0] = (*iter_trk)->getStat(0,0);
            m_stat[1][0] = (*iter_trk)->getStat(0,1);
            m_stat[2][0] = (*iter_trk)->getStat(0,2);
            m_stat[3][0] = (*iter_trk)->getStat(0,3);
            m_stat[4][0] = (*iter_trk)->getStat(0,4);
            m_stat[0][1] = (*iter_trk)->getStat(1,0);
            m_stat[1][1] = (*iter_trk)->getStat(1,1);
            m_stat[2][1] = (*iter_trk)->getStat(1,2);
            m_stat[3][1] = (*iter_trk)->getStat(1,3);
            m_stat[4][1] = (*iter_trk)->getStat(1,4);
 
            m_fptot = sqrt(1+pow(m_fhelix[4],2))/m_fhelix[2];
            m_fptote = sqrt(1+pow(m_fhelixe[4],2))/m_fhelixe[2];
            m_fptotmu = sqrt(1+pow(m_fhelixmu[4],2))/m_fhelixmu[2];
            m_fptotk = sqrt(1+pow(m_fhelixk[4],2))/m_fhelixk[2];
            m_fptotp = sqrt(1+pow(m_fhelixp[4],2))/m_fhelixp[2];
 
            m_lptot = sqrt(1+pow(m_lhelix[4],2))/m_lhelix[2];
            m_lptote = sqrt(1+pow(m_lhelixe[4],2))/m_lhelixe[2];
            m_lptotmu = sqrt(1+pow(m_lhelixmu[4],2))/m_lhelixmu[2];
            m_lptotk = sqrt(1+pow(m_lhelixk[4],2))/m_lhelixk[2];
            m_lptotp = sqrt(1+pow(m_lhelixp[4],2))/m_lhelixp[2];
 
            m_lpt = 1/m_lhelix[2];
            m_lpte = 1/m_lhelixe[2];
            m_lptmu = 1/m_lhelixmu[2];
            m_lptk = 1/m_lhelixk[2];
            m_lptp = 1/m_lhelixp[2];
 
            m_fpt = 1/m_fhelix[2];
            m_fpte = 1/m_fhelixe[2];
            m_fptmu = 1/m_fhelixmu[2];
            m_fptk = 1/m_fhelixk[2];
            m_fptp = 1/m_fhelixp[2];
 
            if(debug_ >= 3){   
                std::cout<<"                                           "<<std::endl;
                std::cout<<"in file Kalman_fitting_anal ,the  m_fpt is .."<<m_fpt<<std::endl;
                std::cout<<"in file Kalman_fitting_anal ,the  m_fpte is .."<<m_fpte<<std::endl;
                std::cout<<"in file Kalman_fitting_anal ,the  m_fptmu is .."<<m_fptmu<<std::endl;
                std::cout<<"in file Kalman_fitting_anal ,the  m_fptk is .."<<m_fptk<<std::endl;
                std::cout<<"in file Kalman_fitting_anal ,the  m_fptp is .."<<m_fptp<<std::endl;
            }
 
            m_zpt = 1/m_zhelix[2];
            m_zpte = 1/m_zhelixe[2];
            m_zptmu = 1/m_zhelixmu[2];
            m_zptk = 1/m_zhelixk[2];
            m_zptp = 1/m_zhelixp[2];
 
            if(debug_ >= 3) {
                std::cout<<"in file Kalman_fitting_anal ,the  m_zpt is .."<<m_zpt<<std::endl;
                std::cout<<"in file Kalman_fitting_anal ,the  m_zpte is .."<<m_zpte<<std::endl; 
                std::cout<<"in file Kalman_fitting_anal ,the  m_zptmu is .."<<m_zptmu<<std::endl;
                std::cout<<"in file Kalman_fitting_anal ,the  m_zptk is .."<<m_zptk<<std::endl;   
                std::cout<<"in file Kalman_fitting_anal ,the  m_zptp is .."<<m_zptp<<std::endl;                                           
            }
            m_zptot = sqrt(1+pow(m_zhelix[4],2))/m_zhelix[2];
            m_zptote = sqrt(1+pow(m_zhelixe[4],2))/m_zhelixe[2];
            m_zptotmu = sqrt(1+pow(m_zhelixmu[4],2))/m_zhelixmu[2];
            m_zptotk = sqrt(1+pow(m_zhelixk[4],2))/m_zhelixk[2];
            m_zptotp = sqrt(1+pow(m_zhelixp[4],2))/m_zhelixp[2];
 
            if(debug_ >= 3) {
                std::cout<<"in file Kalman_fitting_anal ,the  m_zptot is .."<<m_zptot<<std::endl;
                std::cout<<"in file Kalman_fitting_anal ,the  m_zptote is .."<<m_zptote<<std::endl;   
                std::cout<<"in file Kalman_fitting_anal ,the  m_zptotmu is .."<<m_zptotmu<<std::endl;
                std::cout<<"in file Kalman_fitting_anal ,the  m_zptotk is .."<<m_zptotk<<std::endl;   
                std::cout<<"in file Kalman_fitting_anal ,the  m_zptotp is .."<<m_zptotp<<std::endl;
            }
 
            if(ntuple_&32) {
                m_zsigp = sqrt(pow((m_zptot/m_zhelix[2]),2)*m_zerror[5]+
                        pow((m_zhelix[4]/m_zptot),2)*pow((1/m_zhelix[2]),4)*m_zerror[14]-
                        2*m_zhelix[4]*m_zerror[12]*pow((1/m_zhelix[2]),3));
                m_zsigpe = sqrt(pow((m_zptote/m_zhelixe[2]),2)*m_zerrore[5]+
                        pow((m_zhelixe[4]/m_zptote),2)*pow((1/m_zhelixe[2]),4)*m_zerrore[14]-
                        2*m_zhelixe[4]*m_zerrore[12]*pow((1/m_zhelixe[2]),3));
                m_zsigpmu = sqrt(pow((m_zptotmu/m_zhelixmu[2]),2)*m_zerrormu[5]+
                        pow((m_zhelixmu[4]/m_zptotmu),2)*pow((1/m_zhelixmu[2]),4)*m_zerrormu[14]-
                        2*m_zhelixmu[4]*m_zerrormu[12]*pow((1/m_zhelixmu[2]),3));
                m_zsigpk = sqrt(pow((m_zptotk/m_zhelixk[2]),2)*m_zerrork[5]+
                        pow((m_zhelixk[4]/m_zptotk),2)*pow((1/m_zhelixk[2]),4)*m_zerrork[14]-
                        2*m_zhelixk[4]*m_zerrork[12]*pow((1/m_zhelixk[2]),3));
                m_zsigpp = sqrt(pow((m_zptotp/m_zhelixp[2]),2)*m_zerrorp[5]+
                        pow((m_zhelixp[4]/m_zptotp),2)*pow((1/m_zhelixp[2]),4)*m_zerrorp[14]-
                        2*m_zhelixp[4]*m_zerrorp[12]*pow((1/m_zhelixp[2]),3));
            }
 
            StatusCode sc1 = m_nt1->write();
            if( sc1.isFailure() ) cout<<"Ntuple1 filling failed!"<<endl;     
        }
 
        if(ntuple_&4) {
            if(jj == 1) {
                phi1 = (*iter_trk)->getFFi0();
                r1 = (*iter_trk)->getFDr();
                z1 = (*iter_trk)->getFDz(); 
                kap1 = (*iter_trk)->getFCpa();  
                tanl1 = (*iter_trk)->getFTanl();    
                charge1 = kap1/fabs(kap1);
                x1 = r1*cos(phi1);
                y1 = r1*sin(phi1);
                p1 = sqrt(1+tanl1*tanl1)/kap1;
                the1 = M_PI/2-atan(tanl1);
                px1 = -sin(phi1)/fabs(kap1);
                py1 = cos(phi1)/fabs(kap1);
                pz1= tanl1/fabs(kap1);
 
            } else if(jj == 2) {
                phi2 = (*iter_trk)->getFFi0();
                r2 = (*iter_trk)->getFDr();
                z2 = (*iter_trk)->getFDz(); 
                kap2 = (*iter_trk)->getFCpa();  
                tanl2 = (*iter_trk)->getFTanl();    
                charge2 = kap2/fabs(kap2);
                x2 = r1*cos(phi2);
                y2 = r1*sin(phi2);
                p2 = sqrt(1+tanl2*tanl2)/kap1;
                the2 = M_PI/2-atan(tanl2);
                px2 = -sin(phi2)/fabs(kap2);
                py2 = cos(phi2)/fabs(kap2);
                pz2= tanl2/fabs(kap2);
            }
        }
    }
    if(ntuple_&4) {
        m_delx = x1 - x2;
        m_dely = y1 - y2;
        m_delz = z1 - z2;
        m_delthe = the1 + the2;
        m_delphi = phi1- phi2;
        m_delp = p1 - p2;
        m_delpx = charge1*fabs(px1) + charge2*fabs(px2);
        m_delpy = charge1*fabs(py1) + charge2*fabs(py2);
        m_delpz = charge1*fabs(pz1) + charge2*fabs(pz2);
 
        StatusCode sc2 = m_nt2->write();
        if( sc2.isFailure() ) cout<<"Ntuple2 filling failed!"<<endl;      
    } 
 
    delete [] order;
    delete [] rCont;
    delete [] rGen;
    delete [] rOM;
 
    if (debug_ == 4)
        cout << "Kalfitting finished " << std::endl;
    //cout << "kalman fitting end" << endl;
}

Referenced by execute().

kalman_fitting_anal() [2/2]

void KalFitAlg::kalman_fitting_anal

(

void

)

kalman_fitting_calib() [1/2]

void KalFitAlg::kalman_fitting_calib

(

void

)

Definition at line 3972 of file KalFitAlg.cxx.

{
 
    MsgStream log(msgSvc(), name());
    double Pt_threshold(0.3);
    Hep3Vector IP(0,0,0);
 
    vector<MdcRec_trk>* mdcMgr = MdcRecTrkCol::getMdcRecTrkCol();
    vector<MdcRec_trk_add>* mdc_addMgr = MdcRecTrkAddCol::getMdcRecTrkAddCol();
    vector<MdcRec_wirhit>* whMgr = MdcRecWirhitCol::getMdcRecWirhitCol();    
 
    // Table Manager
    if ( !&whMgr ) return;
 
    // Get reduced chi**2 of Mdc track :
    int ntrk = mdcMgr->size();
    double* rPt = new double[ntrk];
    int* rOM = new int[ntrk];
    unsigned int* order = new unsigned int[ntrk];
    unsigned int* rCont = new unsigned int[ntrk];
    unsigned int* rGen = new unsigned int[ntrk];
 
    int index = 0;
    for(vector<MdcRec_trk>::iterator it  = mdcMgr->begin(),
            end = mdcMgr->end(); it != end; it++) {
        // Pt
        rPt[index] = 0;
        if (it->helix[2])
            rPt[index] = 1 / fabs(it->helix[2]);
        if(debug_ == 4) cout<<"rPt...[ "<<index<<" ]...."<< rPt[index] <<endl;
        if(rPt[index] < 0) rPt[index] = DBL_MAX;
        // Outermost layer 
        std::vector<MdcRec_wirhit*> pt = it->hitcol ;
        if(debug_ == 4) cout<<"ppt size:  "<< pt.size()<<endl;
        int outermost(-1);
        for (vector<MdcRec_wirhit*>::iterator ii = pt.end()-1;
                ii !=pt.begin()-1; ii--) {
            int lyr((*ii)->geo->Lyr()->Id());
            if (outermost < lyr) outermost = lyr;
            if(debug_ == 4) cout<<"outmost:  "<<outermost<<"   lyr:  "<<lyr<<endl;
        }
        rOM[index] = outermost;
        order[index] = index;
        ++index;
    }
 
    // Sort Mdc tracks by Pt
    for (int j, k = ntrk - 1; k >= 0; k = j){
        j = -1;
        for(int i = 1; i <= k; i++)
            if(rPt[i - 1] < rPt[i]){
                j = i - 1;
                std::swap(order[i], order[j]);
                std::swap(rPt[i], rPt[j]);
                std::swap(rOM[i], rOM[j]);
                std::swap(rCont[i], rCont[j]);
                std::swap(rGen[i], rGen[j]);
            }
    }
    delete [] rPt;
    //
    int newcount(0);
    //check whether  Recon  already registered
    DataObject *aReconEvent;
    eventSvc()->findObject("/Event/Recon",aReconEvent);
    if(!aReconEvent) {
        // register ReconEvent Data Object to TDS;
        ReconEvent* recevt = new ReconEvent;
        StatusCode sc = eventSvc()->registerObject("/Event/Recon",recevt );
        if(sc!=StatusCode::SUCCESS) {
            log << MSG::FATAL << "Could not register ReconEvent" <<endreq;
            return;
        }
    }
 
    RecMdcKalTrackCol* kalcol = new RecMdcKalTrackCol;   
    RecMdcKalHelixSegCol *segcol =new RecMdcKalHelixSegCol;
    //make RecMdcKalTrackCol
    log << MSG::INFO << "beginning to make RecMdcKalTrackCol" <<endreq;     
 
    // Loop over tracks given by PatRecon :
    for(int l = 0; l < ntrk; l++) {
        //    m_timer[3]->start();
        MdcRec_trk& TrasanTRK = *(mdcMgr->begin() + order[l]);     
        MdcRec_trk_add& TrasanTRK_add = *(mdc_addMgr->begin()+order[l]);
 
        // Reject the ones with quality != 0 
        int trasqual = TrasanTRK_add.quality;
        if(debug_ == 4) cout<<"kalman_fitting>trasqual... "<<trasqual<<endl; 
        if (trasqual) continue;
 
        newcount++;
        if (debug_ == 4)
            cout << "******* KalFit NUMBER : " << newcount << std::endl;      
 
        // What kind of KalFit ? 
        int type(0);
        if ((TrasanTRK_add.decision & 32) == 32 ||
                (TrasanTRK_add.decision & 64) == 64)      type = 1;
 
        // Initialisation : (x, a, ea)
        HepPoint3D x(TrasanTRK.pivot[0],
                TrasanTRK.pivot[1],
                TrasanTRK.pivot[2]);
 
        HepVector a(5);
        for(int i = 0; i < 5; i++)
            a[i] = TrasanTRK.helix[i];
 
        HepSymMatrix ea(5);
        for(int i = 0, k = 0; i < 5; i++) {
            for(int j = 0; j <= i; j++) {
                ea[i][j] = matrixg_*TrasanTRK.error[k++];
                ea[j][i] = ea[i][j];
            }
        }
 
        KalFitTrack::setInitMatrix(ea);
 
        double fiTerm = TrasanTRK.fiTerm;
        int way(1);
        // Prepare the track found :
        KalFitTrack track_lead = KalFitTrack(x, a, ea, lead_, 0, 0);
        track_lead.bFieldZ(KalFitTrack::Bznom_);
        // Mdc Hits 
        int inlyr(999), outlyr(-1);
        int* rStat = new int[43];
        for(int irStat=0;irStat<43;++irStat)rStat[irStat]=0;
        std::vector<MdcRec_wirhit*> pt=TrasanTRK.hitcol;
        int hit_in(0);
        if(debug_ == 4) cout<<"*********Pt size****"<< pt.size()<<endl;
        // Number of hits/layer 
        int Num[43] = {0};
        for (vector<MdcRec_wirhit*>::iterator ii = pt.end()-1;
                ii != pt.begin()-1; ii--) {
            Num[(*ii)->geo->Lyr()->Id()]++;
        }
 
        int hit_asso(0);
        for (vector<MdcRec_wirhit*>::iterator ii = pt.end()-1;
                ii != pt.begin()-1; ii--) { 
 
            hit_asso++;
            if (Num[(*ii)->geo->Lyr()->Id()]>3) {
                if (debug_ >0)
                    cout << "WARNING:  I found " << Num[(*ii)->geo->Lyr()->Id()] 
                        << " hits in the layer "
                        << (*ii)->geo->Lyr()->Id() << std::endl;
                continue;
            }
            //    if(ii!=pt.end()-1){
            //            if(42 == (*ii)->geo->Lyr()->Id() && 42 == (*(ii+1))->geo->Lyr()->Id()){
            //                MdcRec_wirhit * rechit_before = *(ii+1);
            //                if((*rechit_before).tdc < (**ii).tdc) continue;
            //                else if(track_lead.HitsMdc().size()>0 && rStat[42]){
            //                    track_lead.HitsMdc().pop_back();
            //                }
            //            }
            //            else{
            //                int layer_before=(*(ii+1))->geo->Lyr()->Id();
            //                if(layer_before == (*ii)->geo->Lyr()->Id()){
            //                    MdcRec_wirhit * rechit_before = *(ii+1);
            //                    if((*rechit_before).rechitptr->getDriftT()>450 || (**ii).rechitptr->getDriftT()>450.){
            //                        if((*rechit_before).tdc < (**ii).tdc) continue;
            //                        else if(track_lead.HitsMdc().size()>0 && rStat[layer_before]){
            //                            track_lead.HitsMdc().pop_back();
            //                        }
            //                    }
            //                }
            //            }
            //    }
 
            hit_in++;
            MdcRec_wirhit & rechit = **ii;
            double dist[2] = {rechit.ddl, rechit.ddr};
            double erdist[2] = {rechit.erddl, rechit.erddr};
            const MdcGeoWire* geo = rechit.geo;
 
            int lr_decision(0);
            if (KalFitTrack::LR_ == 1){
                if (rechit.lr==2 || rechit.lr==0) lr_decision=-1;
                //  if (rechit.lr==0) lr_decision=-1;
                else if (rechit.lr==1) lr_decision=1;
            } 
 
            int ind(geo->Lyr()->Id());
            track_lead.appendHitsMdc( KalFitHitMdc(rechit.id,
                        lr_decision, rechit.tdc,
                        dist, erdist, 
                        _wire+(geo->Id()), rechit.rechitptr));
            // inner/outer layer :
            rStat[ind]++;
            if (inlyr>ind) inlyr = ind;
            if (outlyr<ind) outlyr = ind;
        }
        if (debug_ == 4) 
            cout << "**** NUMBER OF Mdc HITS (TRASAN) = " << hit_asso << std::endl;
 
        // Empty layers :
        int empty_between(0), empty(0);
        for (int i= inlyr; i <= outlyr; i++)
            if (!rStat[i]) empty_between++;
        empty = empty_between+inlyr+(42-outlyr);
        delete [] rStat;
 
        // RMK high momentum track under study, probably not neeeded...
        track_lead.order_wirhit(1);
        track_lead.type(type);
        unsigned int nhit = track_lead.HitsMdc().size();
        if (!nhit && debug_ == 4) {
            cout << " ATTENTION TRACK WITH ONLY HITS " << nhit << std::endl;
            continue;
        }
 
        // Initialisation :
        double  KalFitst(0), KalFitax(0), KalFitschi2(0);
        // Move to the outer most hit :      
        Hep3Vector outer_pivot(track_lead.x(fiTerm));
 
        if(debug_ == 4) {
            std::cout<<"before track_lead.pivot(outer_pivot) ,the error matrix of track_lead is .."<<track_lead.Ea()<<std::endl;
        }
        track_lead.pivot(outer_pivot); // hi gay, the error matrix is changed in this function!! 
        track_lead.bFieldZ(KalFitTrack::Bznom_);
        // attention best_chi2 reinitialize !!! 
        if (nhit>=3 && !KalFitTrack::LR_) 
            start_seed(track_lead, lead_, way, TrasanTRK);
        HepSymMatrix Eakal(5,0);
 
        //init_matrix(TrasanTRK, Eakal);
 
        double costheta = track_lead.a()[4] / sqrt(1.0 + track_lead.a()[4]*track_lead.a()[4]);
        if( (1.0/fabs(track_lead.a()[2]) < pt_cut_ ) && (fabs(costheta)> theta_cut_) ) {
            choice_ = 6;
        }
 
        init_matrix(choice_,TrasanTRK, Eakal);
 
        //std::cout<<" Eakal be here: "<<Eakal<<std::endl;
 
        if (debug_ == 4){
            std::cout << "from Mdc Pattern Recognition: " << std::endl;
            HepPoint3D IP(0,0,0);
            Helix work(track_lead.pivot(), 
                    track_lead.a(),
                    track_lead.Ea());
            work.pivot(IP);
            std::cout << " dr = " << work.a()[0] 
                << ", Er_dr = " << sqrt(work.Ea()[0][0]) << std::endl;
            std::cout << " phi0 = " << work.a()[1] 
                << ", Er_phi0 = " << sqrt(work.Ea()[1][1]) << std::endl;
            std::cout << " PT = " << 1/work.a()[2] 
                << ", Er_kappa = " << sqrt(work.Ea()[2][2]) << std::endl;
            std::cout << " dz = " << work.a()[3] 
                << ", Er_dz = " << sqrt(work.Ea()[3][3]) << std::endl;
            std::cout << " tanl = " << work.a()[4] 
                << ", Er_tanl = " << sqrt(work.Ea()[4][4]) << std::endl;
        }
 
        filter_fwd_calib(track_lead, lead_, way, Eakal);
        track_lead.update_forMdc();
 
        HepPoint3D IP(0,0,0);    
        if (debug_ == 4) {
            cout << " Mdc FIRST KALMAN FIT " << std::endl;
            Helix work(track_lead.pivot(), 
                    track_lead.a(),
                    track_lead.Ea());
            work.pivot(IP);
            cout << " dr = " << work.a()[0] 
                << ", Er_dr = " << sqrt(work.Ea()[0][0]) << std::endl;
            cout << " phi0 = " << work.a()[1] 
                << ", Er_phi0 = " << sqrt(work.Ea()[1][1]) << std::endl;
            cout << " PT = " << 1/work.a()[2] 
                << ", Er_kappa = " << sqrt(work.Ea()[2][2]) << std::endl;
            cout << " dz = " << work.a()[3] 
                << ", Er_dz = " << sqrt(work.Ea()[3][3]) << std::endl;
            cout << " tanl = " << work.a()[4] 
                << ", Er_tanl = " << sqrt(work.Ea()[4][4]) << std::endl;
        }
 
        // fill TDS
        RecMdcKalTrack* kaltrk = new RecMdcKalTrack;
 
        // Complete the track (other mass assumption, backward) and 
        complete_track(TrasanTRK, TrasanTRK_add, track_lead, kaltrk,kalcol,segcol);
    }
 
 
    StatusCode kalsc;
    //check whether the RecMdcKalTrackCol has been already registered
    DataObject *aRecKalEvent;
    eventSvc()->findObject("/Event/Recon/RecMdcKalTrackCol", aRecKalEvent);
    if(aRecKalEvent!=NULL) {
        //then unregister RecMdcKalCol
        kalsc = eventSvc()->unregisterObject("/Event/Recon/RecMdcKalTrackCol");
        if(kalsc != StatusCode::SUCCESS) {
            log << MSG::FATAL << "Could not unregister RecMdcKalTrack collection" << endreq;
            return;
        }
    }
 
    kalsc = eventSvc()->registerObject("/Event/Recon/RecMdcKalTrackCol", kalcol);
    if( kalsc.isFailure()) {
        log << MSG::FATAL << "Could not register RecMdcKalTrack" << endreq;
        return; 
    }
    log << MSG::INFO << "RecMdcKalTrackCol registered successfully!" <<endreq;
 
 
 
    StatusCode segsc;
    //check whether the RecMdcKalHelixSegCol has been already registered
    DataObject *aRecKalSegEvent;
    eventSvc()->findObject("/Event/Recon/RecMdcKalHelixSegCol", aRecKalSegEvent);
    if(aRecKalSegEvent!=NULL) {
        //then unregister RecMdcKalHelixSegCol
        segsc = eventSvc()->unregisterObject("/Event/Recon/RecMdcKalHelixSegCol");
        if(segsc != StatusCode::SUCCESS) {
            log << MSG::FATAL << "Could not unregister RecMdcKalHelixSegCol collection" << endreq;
            return;
        }
    }
 
    segsc = eventSvc()->registerObject("/Event/Recon/RecMdcKalHelixSegCol", segcol);
    if( segsc.isFailure() ) {
        log << MSG::FATAL << "Could not register RecMdcKalHelixSeg" << endreq;
        return; 
    }
    log << MSG::INFO << "RecMdcKalHelixSegCol registered successfully!" <<endreq;
 
 
    double x1(0.),x2(0.),y1(0.),y2(0.),z1(0.),z2(0.),the1(0.),the2(0.),phi1(0.),phi2(0.),p1(0.),p2(0.);
    double r1(0.),r2(0.),kap1(999.),kap2(999.),tanl1(0.),tanl2(0.); 
    //check the result:RecMdcKalTrackCol   
 
    SmartDataPtr<RecMdcKalTrackCol> kaltrkCol(eventSvc(),"/Event/Recon/RecMdcKalTrackCol");
    if (!kaltrkCol) { 
        log << MSG::FATAL << "Could not find RecMdcKalTrackCol" << endreq;
        return;
    }
    log << MSG::INFO << "Begin to check RecMdcKalTrackCol"<<endreq; 
    RecMdcKalTrackCol::iterator iter_trk = kaltrkCol->begin();
    for( int jj=1; iter_trk != kaltrkCol->end(); iter_trk++,jj++) {
        log << MSG::DEBUG << "retrieved MDC Kalmantrack:"
            << "Track Id: " << (*iter_trk)->getTrackId()
            << " Mass of the fit: "<< (*iter_trk)->getMass(2)<< endreq
            << " Length of the track: "<< (*iter_trk)->getLength(2)
            << "  Tof of the track: "<< (*iter_trk)->getTof(2) << endreq
            << " Chisq of the fit: "<< (*iter_trk)->getChisq(0,2)
            <<"  "<< (*iter_trk)->getChisq(1,2) << endreq
            << "Ndf of the fit: "<< (*iter_trk)->getNdf(0,1)
            <<"  "<< (*iter_trk)->getNdf(1,2) << endreq
            << "Kappa " << (*iter_trk)->getZHelix()[2]
            << endreq;
 
        HelixSegRefVec gothelixsegs = (*iter_trk)->getVecHelixSegs();
        if(debug_ == 4) { 
            std::cout<<"the size of gothelixsegs ..."<<gothelixsegs.size()<<std::endl;      
        }
 
        HelixSegRefVec::iterator it_gothelixseg = gothelixsegs.begin();
        for( ; it_gothelixseg != gothelixsegs.end(); it_gothelixseg++) {
            if(debug_ == 4) { 
                std::cout<<"the layerId of this helixseg is ..."<<(*it_gothelixseg)->getLayerId()<<std::endl;
                std::cout<<"the residual of this helixseg exclude the meas hit"<<(*it_gothelixseg)->getResExcl()<<std::endl;
                std::cout<<"the residual of this helixseg include the meas hit"<<(*it_gothelixseg)->getResIncl()<<std::endl;
                std::cout<<"the track id of the helixseg is ..."<<(*it_gothelixseg)->getTrackId() <<std::endl;
                std::cout<<"the tof of the helixseg is ..."<<(*it_gothelixseg)->getTof()<<std::endl;
                std::cout<<"the Zhit of the helixseg is ..."<<(*it_gothelixseg)->getZhit()<<std::endl;
            }
        }
        for( int i = 0; i<43; i++) {
            log << MSG::DEBUG << "retrieved pathl["<<i<<"]= "
                << (*iter_trk)->getPathl(i) <<endreq;
        }
 
        if(ntuple_&1) {
            m_trackid = (*iter_trk)->getTrackId();
            for( int jj =0, iii=0; jj<5; jj++) {
                m_length[jj] = (*iter_trk)->getLength(jj);
                m_tof[jj] = (*iter_trk)->getTof(jj);
                m_nhits[jj] = (*iter_trk)->getNhits(jj);
                m_zhelix[jj] = (*iter_trk)->getZHelix()[jj];
                m_zhelixe[jj] = (*iter_trk)->getZHelixE()[jj];
                m_zhelixmu[jj] = (*iter_trk)->getZHelixMu()[jj];
                m_zhelixk[jj] = (*iter_trk)->getZHelixK()[jj];
                m_zhelixp[jj] = (*iter_trk)->getZHelixP()[jj];
                m_fhelix[jj] = (*iter_trk)->getFHelix()[jj];
                m_fhelixe[jj] = (*iter_trk)->getFHelixE()[jj];
                m_fhelixmu[jj] = (*iter_trk)->getFHelixMu()[jj];
                m_fhelixk[jj] = (*iter_trk)->getFHelixK()[jj];
                m_fhelixp[jj] = (*iter_trk)->getFHelixP()[jj];
                m_lhelix[jj] = (*iter_trk)->getLHelix()[jj];
                m_lhelixe[jj] = (*iter_trk)->getLHelixE()[jj];
                m_lhelixmu[jj] = (*iter_trk)->getLHelixMu()[jj];
                m_lhelixk[jj] = (*iter_trk)->getLHelixK()[jj];
                m_lhelixp[jj] = (*iter_trk)->getLHelixP()[jj];
                if(ntuple_&32) {
                    for(int kk=0; kk<=jj; kk++,iii++) {
                        m_zerror[iii] = (*iter_trk)->getZError()[jj][kk];
                        m_zerrore[iii] = (*iter_trk)->getZErrorE()[jj][kk];
                        m_zerrormu[iii] = (*iter_trk)->getZErrorMu()[jj][kk];
                        m_zerrork[iii] = (*iter_trk)->getZErrorK()[jj][kk];
                        m_zerrorp[iii] = (*iter_trk)->getZErrorP()[jj][kk];
                        m_ferror[iii] = (*iter_trk)->getFError()[jj][kk];
                        m_ferrore[iii] = (*iter_trk)->getFErrorE()[jj][kk];
                        m_ferrormu[iii] = (*iter_trk)->getFErrorMu()[jj][kk];
                        m_ferrork[iii] = (*iter_trk)->getFErrorK()[jj][kk];
                        m_ferrorp[iii] = (*iter_trk)->getFErrorP()[jj][kk];
                        m_lerror[iii] = (*iter_trk)->getLError()[jj][kk];
                        m_lerrore[iii] = (*iter_trk)->getLErrorE()[jj][kk];
                        m_lerrormu[iii] = (*iter_trk)->getLErrorMu()[jj][kk];
                        m_lerrork[iii] = (*iter_trk)->getLErrorK()[jj][kk];
                        m_lerrorp[iii] = (*iter_trk)->getLErrorP()[jj][kk];
                    }
 
                }
            }
 
            //       // the following logic may seem peculiar, but it IS the case(for BOSS5.0 and BOSS5.1)
            //       m_chisq[0][0] = (*iter_trk)->getChisq(0,0);
            //       m_chisq[0][1] = (*iter_trk)->getChisq(0,1);
            //       m_chisq[1][0] = (*iter_trk)->getChisq(0,2);
            //       m_chisq[1][1] = (*iter_trk)->getChisq(0,3);
            //       m_chisq[2][0] = (*iter_trk)->getChisq(0,4);
            //       m_chisq[2][1] = (*iter_trk)->getChisq(1,0);
            //       m_chisq[3][0] = (*iter_trk)->getChisq(1,1);
            //       m_chisq[3][1] = (*iter_trk)->getChisq(1,2);
            //       m_chisq[4][0] = (*iter_trk)->getChisq(1,3);
            //       m_chisq[4][1] = (*iter_trk)->getChisq(1,4);
 
            //       m_ndf[0][0] = (*iter_trk)->getNdf(0,0);
            //       m_ndf[0][1] = (*iter_trk)->getNdf(0,1);
            //       m_ndf[1][0] = (*iter_trk)->getNdf(0,2);
            //       m_ndf[1][1] = (*iter_trk)->getNdf(0,3);
            //       m_ndf[2][0] = (*iter_trk)->getNdf(0,4);
            //       m_ndf[2][1] = (*iter_trk)->getNdf(1,0);
            //       m_ndf[3][0] = (*iter_trk)->getNdf(1,1);
            //       m_ndf[3][1] = (*iter_trk)->getNdf(1,2);
            //       m_ndf[4][0] = (*iter_trk)->getNdf(1,3);
            //       m_ndf[4][1] = (*iter_trk)->getNdf(1,4);
 
            //       m_stat[0][0] = (*iter_trk)->getStat(0,0);
            //       m_stat[0][1] = (*iter_trk)->getStat(0,1);
            //       m_stat[1][0] = (*iter_trk)->getStat(0,2);
            //       m_stat[1][1] = (*iter_trk)->getStat(0,3);
            //       m_stat[2][0] = (*iter_trk)->getStat(0,4);
            //       m_stat[2][1] = (*iter_trk)->getStat(1,0);
            //       m_stat[3][0] = (*iter_trk)->getStat(1,1);
            //       m_stat[3][1] = (*iter_trk)->getStat(1,2);
            //       m_stat[4][0] = (*iter_trk)->getStat(1,3);
            //       m_stat[4][1] = (*iter_trk)->getStat(1,4);
 
            // RootConversion changed in BOSS6.0, so use thefollowing:
            m_chisq[0][0] = (*iter_trk)->getChisq(0,0);
            m_chisq[1][0] = (*iter_trk)->getChisq(0,1);
            m_chisq[2][0] = (*iter_trk)->getChisq(0,2);
            m_chisq[3][0] = (*iter_trk)->getChisq(0,3);
            m_chisq[4][0] = (*iter_trk)->getChisq(0,4);
            m_chisq[0][1] = (*iter_trk)->getChisq(1,0);
            m_chisq[1][1] = (*iter_trk)->getChisq(1,1);
            m_chisq[2][1] = (*iter_trk)->getChisq(1,2);
            m_chisq[3][1] = (*iter_trk)->getChisq(1,3);
            m_chisq[4][1] = (*iter_trk)->getChisq(1,4);
 
            m_ndf[0][0] = (*iter_trk)->getNdf(0,0);
            m_ndf[1][0] = (*iter_trk)->getNdf(0,1);
            m_ndf[2][0] = (*iter_trk)->getNdf(0,2);
            m_ndf[3][0] = (*iter_trk)->getNdf(0,3);
            m_ndf[4][0] = (*iter_trk)->getNdf(0,4);
            m_ndf[0][1] = (*iter_trk)->getNdf(1,0);
            m_ndf[1][1] = (*iter_trk)->getNdf(1,1);
            m_ndf[2][1] = (*iter_trk)->getNdf(1,2);
            m_ndf[3][1] = (*iter_trk)->getNdf(1,3);
            m_ndf[4][1] = (*iter_trk)->getNdf(1,4);
 
            m_stat[0][0] = (*iter_trk)->getStat(0,0);
            m_stat[1][0] = (*iter_trk)->getStat(0,1);
            m_stat[2][0] = (*iter_trk)->getStat(0,2);
            m_stat[3][0] = (*iter_trk)->getStat(0,3);
            m_stat[4][0] = (*iter_trk)->getStat(0,4);
            m_stat[0][1] = (*iter_trk)->getStat(1,0);
            m_stat[1][1] = (*iter_trk)->getStat(1,1);
            m_stat[2][1] = (*iter_trk)->getStat(1,2);
            m_stat[3][1] = (*iter_trk)->getStat(1,3);
            m_stat[4][1] = (*iter_trk)->getStat(1,4);
 
            m_fptot = sqrt(1+pow(m_fhelix[4],2))/m_fhelix[2];
            m_fptote = sqrt(1+pow(m_fhelixe[4],2))/m_fhelixe[2];
            m_fptotmu = sqrt(1+pow(m_fhelixmu[4],2))/m_fhelixmu[2];
            m_fptotk = sqrt(1+pow(m_fhelixk[4],2))/m_fhelixk[2];
            m_fptotp = sqrt(1+pow(m_fhelixp[4],2))/m_fhelixp[2];
 
            m_zpt = 1/m_zhelix[2];
            m_zpte = 1/m_zhelixe[2];
            m_zptmu = 1/m_zhelixmu[2];
            m_zptk = 1/m_zhelixk[2];
            m_zptp = 1/m_zhelixp[2];
 
            m_fpt = 1/m_fhelix[2];
            m_fpte = 1/m_fhelixe[2];
            m_fptmu = 1/m_fhelixmu[2];
            m_fptk = 1/m_fhelixk[2];
            m_fptp = 1/m_fhelixp[2];
 
            m_lpt = 1/m_lhelix[2];
            m_lpte = 1/m_lhelixe[2];
            m_lptmu = 1/m_lhelixmu[2];
            m_lptk = 1/m_lhelixk[2];
            m_lptp = 1/m_lhelixp[2];
 
            m_lptot = sqrt(1+pow(m_lhelix[4],2))/m_lhelix[2];
            m_lptote = sqrt(1+pow(m_lhelixe[4],2))/m_lhelixe[2];
            m_lptotmu = sqrt(1+pow(m_lhelixmu[4],2))/m_lhelixmu[2];
            m_lptotk = sqrt(1+pow(m_lhelixk[4],2))/m_lhelixk[2];
            m_lptotp = sqrt(1+pow(m_lhelixp[4],2))/m_lhelixp[2];
 
            m_zptot = sqrt(1+pow(m_zhelix[4],2))/m_zhelix[2];
            m_zptote = sqrt(1+pow(m_zhelixe[4],2))/m_zhelixe[2];
            m_zptotmu = sqrt(1+pow(m_zhelixmu[4],2))/m_zhelixmu[2];
            m_zptotk = sqrt(1+pow(m_zhelixk[4],2))/m_zhelixk[2];
            m_zptotp = sqrt(1+pow(m_zhelixp[4],2))/m_zhelixp[2];
            if(ntuple_&32) {
                m_zsigp = sqrt(pow((m_zptot/m_zhelix[2]),2)*m_zerror[5]+
                        pow((m_zhelix[4]/m_zptot),2)*pow((1/m_zhelix[2]),4)*m_zerror[14]-
                        2*m_zhelix[4]*m_zerror[12]*pow((1/m_zhelix[2]),3));
                m_zsigpe = sqrt(pow((m_zptote/m_zhelixe[2]),2)*m_zerrore[5]+
                        pow((m_zhelixe[4]/m_zptote),2)*pow((1/m_zhelixe[2]),4)*m_zerrore[14]-
                        2*m_zhelixe[4]*m_zerrore[12]*pow((1/m_zhelixe[2]),3));
                m_zsigpmu = sqrt(pow((m_zptotmu/m_zhelixmu[2]),2)*m_zerrormu[5]+
                        pow((m_zhelixmu[4]/m_zptotmu),2)*pow((1/m_zhelixmu[2]),4)*m_zerrormu[14]-
                        2*m_zhelixmu[4]*m_zerrormu[12]*pow((1/m_zhelixmu[2]),3));
                m_zsigpk = sqrt(pow((m_zptotk/m_zhelixk[2]),2)*m_zerrork[5]+
                        pow((m_zhelixk[4]/m_zptotk),2)*pow((1/m_zhelixk[2]),4)*m_zerrork[14]-
                        2*m_zhelixk[4]*m_zerrork[12]*pow((1/m_zhelixk[2]),3));
                m_zsigpp = sqrt(pow((m_zptotp/m_zhelixp[2]),2)*m_zerrorp[5]+
                        pow((m_zhelixp[4]/m_zptotp),2)*pow((1/m_zhelixp[2]),4)*m_zerrorp[14]-
                        2*m_zhelixp[4]*m_zerrorp[12]*pow((1/m_zhelixp[2]),3));
            }
 
            StatusCode sc1 = m_nt1->write();
            if( sc1.isFailure() ) cout<<"Ntuple1 filling failed!"<<endl;     
        }
 
        if(ntuple_&4) {
            if(jj == 1) { 
                phi1 = (*iter_trk)->getFFi0();
                r1 = (*iter_trk)->getFDr();
                z1 = (*iter_trk)->getFDz(); 
                kap1 = (*iter_trk)->getFCpa();  
                tanl1 = (*iter_trk)->getFTanl();    
                x1 = r1*cos(phi1);
                y1 = r1*sin(phi1);
                p1 = sqrt(1+tanl1*tanl1)/kap1;
                the1 = M_PI/2-atan(tanl1);
            } else if(jj == 2) {
                phi2 = (*iter_trk)->getFFi0();
                r2 = (*iter_trk)->getFDr();
                z2 = (*iter_trk)->getFDz(); 
                kap2 = (*iter_trk)->getFCpa();  
                tanl2 = (*iter_trk)->getFTanl();    
                x2 = r1*cos(phi2);
                y2 = r1*sin(phi2);
                p2 = sqrt(1+tanl2*tanl2)/kap1;
                the2 = M_PI/2-atan(tanl2);
            }
        }
    }
    if(ntuple_&4) {
        m_delx = x1 - x2;
        m_dely = y1 - y2;
        m_delz = z1 - z2;
        m_delthe = the1 + the2;
        m_delphi = phi1- phi2;
        m_delp = p1 - p2;
        StatusCode sc2 = m_nt2->write();
        if( sc2.isFailure() ) cout<<"Ntuple2 filling failed!"<<endl;      
    } 
    delete [] order;
    delete [] rCont;
    delete [] rGen;
    delete [] rOM;
 
    if (debug_ == 4)
        cout << "Kalfitting finished " << std::endl;
}

Referenced by execute().

kalman_fitting_calib() [2/2]

void KalFitAlg::kalman_fitting_calib

(

void

)

kalman_fitting_csmalign() [1/2]

void KalFitAlg::kalman_fitting_csmalign

(

void

)

Definition at line 5050 of file KalFitAlg.cxx.

{
 
    MsgStream log(msgSvc(), name());
    double Pt_threshold(0.3);
    Hep3Vector IP(0,0,0);
 
    vector<MdcRec_trk>* mdcMgr = MdcRecTrkCol::getMdcRecTrkCol();
    vector<MdcRec_trk_add>* mdc_addMgr = MdcRecTrkAddCol::getMdcRecTrkAddCol();
    vector<MdcRec_wirhit>* whMgr = MdcRecWirhitCol::getMdcRecWirhitCol();    
 
    // Table Manager
    if ( !&whMgr ) return;
 
    // Get reduced chi**2 of Mdc track :
    int ntrk = mdcMgr->size();
    //cout<<"ntrk: "<<ntrk<<endl;
 
    int nhits = whMgr->size();
    //cout<<"nhits: "<<nhits<<endl;
 
 
    double* rY = new double[ntrk];
    double* rfiTerm = new double[ntrk];
    double* rPt = new double[ntrk];
    int* rOM = new int[ntrk];
    unsigned int* order = new unsigned int[ntrk];
    unsigned int* rCont = new unsigned int[ntrk];
    unsigned int* rGen = new unsigned int[ntrk];
 
    int index = 0;
    Hep3Vector csmp3[2];
    for(vector<MdcRec_trk>::iterator it  = mdcMgr->begin(),
            end = mdcMgr->end(); it != end; it++) {
        //order by phi term
        rfiTerm[index]=it->fiTerm;
        //cout<<"fiTerm: "<<rfiTerm[index]<<endl;
        // Pt
        rPt[index] = 0;
        if (it->helix[2])
            rPt[index] = 1 / fabs(it->helix[2]);
        if(debug_ == 4) cout<<"rPt...[ "<<index<<" ]...."<< rPt[index] <<endl;
        if(rPt[index] < 0) rPt[index] = DBL_MAX;
        // Outermost layer 
        std::vector<MdcRec_wirhit*> pt = it->hitcol ;
        if(debug_ == 4) cout<<"ppt size:  "<< pt.size()<<endl;
        int outermost(-1);
        for (vector<MdcRec_wirhit*>::iterator ii = pt.end()-1;
                ii !=pt.begin()-1; ii--) {
            int lyr((*ii)->geo->Lyr()->Id());
            if (outermost < lyr) {
                outermost = lyr;
                rY[index] = (*ii)->geo->Forward().y();  
            }
            if(debug_ == 4) cout<<"outmost:  "<<outermost<<"   lyr:  "<<lyr<<endl;
        }
        rOM[index] = outermost;
        order[index] = index;
        ++index;
    }
 
    // Sort Mdc tracks by fiTerm
    for (int j, k = ntrk - 1; k >= 0; k = j){
        j = -1; 
        for(int i = 1; i <= k; i++)
            if(rY[i - 1] < rY[i]){
                j = i - 1;
                std::swap(order[i], order[j]);
                std::swap(rY[i], rY[j]);
                std::swap(rOM[i], rOM[j]);
                std::swap(rCont[i], rCont[j]);
                std::swap(rGen[i], rGen[j]);
            }
    }
    delete [] rPt;
    delete [] rY;
    delete [] rfiTerm;
    //
    int newcount(0);
    //check whether  Recon  already registered
    DataObject *aReconEvent;
    eventSvc()->findObject("/Event/Recon",aReconEvent);
    if(!aReconEvent) {
        // register ReconEvent Data Object to TDS;
        ReconEvent* recevt = new ReconEvent;
        StatusCode sc = eventSvc()->registerObject("/Event/Recon",recevt );
        if(sc!=StatusCode::SUCCESS) {
            log << MSG::FATAL << "Could not register ReconEvent" <<endreq;
            return;
        }
    }
 
    RecMdcKalTrackCol* kalcol = new RecMdcKalTrackCol;   
    RecMdcKalHelixSegCol *segcol =new RecMdcKalHelixSegCol;
    //make RecMdcKalTrackCol
    log << MSG::INFO << "beginning to make RecMdcKalTrackCol" <<endreq;     
 
    //    m_timer[3]->start();
    //  MdcRec_trk& TrasanTRK;     
    //  MdcRec_trk_add& TrasanTRK_add;
 
    //  for(int l = 0; l < ntrk; l++) {
    MdcRec_trk& TrasanTRK = *(mdcMgr->begin() + order[1]);     
    MdcRec_trk_add& TrasanTRK_add = *(mdc_addMgr->begin()+order[1]);
    // Reject the ones with quality != 0 
    // int trasqual = TrasanTRK_add.quality;
    // if(debug_ == 4) cout<<"kalman_fitting>trasqual... "<<trasqual<<endl; 
    // if (trasqual) continue;
 
    newcount++;
    if (debug_ == 4)
        cout << "******* KalFit NUMBER : " << newcount << std::endl;      
 
    // What kind of KalFit ? 
    int type(0);
    if ((TrasanTRK_add.decision & 32) == 32 ||
            (TrasanTRK_add.decision & 64) == 64)      type = 1;
 
    // Initialisation : (x, a, ea)
    HepPoint3D x(TrasanTRK.pivot[0],
            TrasanTRK.pivot[1],
            TrasanTRK.pivot[2]);
 
    HepVector a(5);
    for(int i = 0; i < 5; i++)
        a[i] = TrasanTRK.helix[i];
 
    HepSymMatrix ea(5);
    for(int i = 0, k = 0; i < 5; i++) {
        for(int j = 0; j <= i; j++) {
            ea[i][j] = matrixg_*TrasanTRK.error[k++];
            ea[j][i] = ea[i][j];
        }
    }
 
    KalFitTrack::setInitMatrix(ea);
 
    double fiTerm = TrasanTRK.fiTerm;
    int way(1);
    // Prepare the track found :
    KalFitTrack track_lead = KalFitTrack(x, a, ea, lead_, 0, 0);
    track_lead.bFieldZ(KalFitTrack::Bznom_);
 
    int hit_asso(0);
    for(int l = 0; l < ntrk; l++) {
        MdcRec_trk& TrasanTRK1 = *(mdcMgr->begin() + order[l]);     
        MdcRec_trk_add& TrasanTRK_add1 = *(mdc_addMgr->begin()+order[l]);
        // Reject the ones with quality != 0 
        int trasqual = TrasanTRK_add1.quality;
        if(debug_ == 4) cout<<"kalman_fitting>trasqual... "<<trasqual<<endl; 
        if (trasqual) continue;
        // Mdc Hits 
        int inlyr(999), outlyr(-1);
        int* rStat = new int[43];
        for(int irStat=0;irStat<43;++irStat)rStat[irStat]=0;
        std::vector<MdcRec_wirhit*> pt=TrasanTRK1.hitcol;
        int hit_in(0);
        if(debug_ == 4) cout<<"*********Pt size****"<< pt.size()<<endl;
        // Number of hits/layer 
        int Num[43] = {0};
        for (vector<MdcRec_wirhit*>::iterator ii = pt.end()-1;
                ii != pt.begin()-1; ii--) {
            Num[(*ii)->geo->Lyr()->Id()]++;
        }
 
        for (vector<MdcRec_wirhit*>::iterator ii = pt.end()-1;
                ii != pt.begin()-1; ii--) { 
 
            hit_asso++;
            if (Num[(*ii)->geo->Lyr()->Id()]>3) {
                if (debug_ >0)
                    cout << "WARNING:  I found " << Num[(*ii)->geo->Lyr()->Id()] 
                        << " hits in the layer "
                        << (*ii)->geo->Lyr()->Id() << std::endl;
                continue;
            }
 
            hit_in++;
            MdcRec_wirhit & rechit = **ii;
            double dist[2] = {rechit.ddl, rechit.ddr};
            double erdist[2] = {rechit.erddl, rechit.erddr};
            const MdcGeoWire* geo = rechit.geo;
 
            int lr_decision(0);
            if (KalFitTrack::LR_ == 1){
                if (rechit.lr==2 || rechit.lr==0) lr_decision=-1;
                //  if (rechit.lr==0) lr_decision=-1;
                else if (rechit.lr==1) lr_decision=1;
            } 
 
            int ind(geo->Lyr()->Id());
            track_lead.appendHitsMdc( KalFitHitMdc(rechit.id,
                        lr_decision, rechit.tdc,
                        dist, erdist, 
                        _wire+(geo->Id()), rechit.rechitptr));
            // inner/outer layer :
            rStat[ind]++;
            if (inlyr>ind) inlyr = ind;
            if (outlyr<ind) outlyr = ind;
        }
        // Empty layers :
        int empty_between(0), empty(0);
        for (int i= inlyr; i <= outlyr; i++)
            if (!rStat[i]) empty_between++;
        empty = empty_between+inlyr+(42-outlyr);
        delete [] rStat;
    }
    if (debug_ == 4) 
        cout << "**** NUMBER OF Mdc HITS (TRASAN) = " << hit_asso << std::endl;
 
 
    // RMK high momentum track under study, probably not neeeded...
    track_lead.order_wirhit(0);
    track_lead.type(type);
    unsigned int nhit = track_lead.HitsMdc().size();
    if (nhit<70) {
        cout << " ATTENTION TRACK WITH ONLY HITS " << nhit << std::endl;
        return;
    }
 
    // Initialisation :
    double  KalFitst(0), KalFitax(0), KalFitschi2(0);
    // Move to the outer most hit :      
    Hep3Vector outer_pivot(track_lead.x(fiTerm));
 
    if(debug_ == 4) {
        std::cout<<"before track_lead.pivot(outer_pivot) ,the error matrix of track_lead is .."<<track_lead.Ea()<<std::endl;
    }
    track_lead.pivot(outer_pivot); // hi gay, the error matrix is changed in this function!! 
    track_lead.bFieldZ(KalFitTrack::Bznom_);
    // attention best_chi2 reinitialize !!! 
    if (nhit>=3 && !KalFitTrack::LR_) 
        start_seed(track_lead, lead_, way, TrasanTRK);
    HepSymMatrix Eakal(5,0);
 
    //init_matrix(TrasanTRK, Eakal);
 
    double costheta = track_lead.a()[4] / sqrt(1.0 + track_lead.a()[4]*track_lead.a()[4]);
    if( (1.0/fabs(track_lead.a()[2]) < pt_cut_ ) && (fabs(costheta)> theta_cut_) ) {
        choice_ = 6;
    }
 
    init_matrix(choice_,TrasanTRK, Eakal);
 
    //std::cout<<" Eakal be here: "<<Eakal<<std::endl;
 
    if (debug_ == 4){
        std::cout << "from Mdc Pattern Recognition: " << std::endl;
        //HepPoint3D IP(0,0,0);
        Helix work(track_lead.pivot(), 
                track_lead.a(),
                track_lead.Ea());
        work.pivot(IP);
        std::cout << " dr = " << work.a()[0] 
            << ", Er_dr = " << sqrt(work.Ea()[0][0]) << std::endl;
        std::cout << " phi0 = " << work.a()[1] 
            << ", Er_phi0 = " << sqrt(work.Ea()[1][1]) << std::endl;
        std::cout << " PT = " << 1/work.a()[2] 
            << ", Er_kappa = " << sqrt(work.Ea()[2][2]) << std::endl;
        std::cout << " dz = " << work.a()[3] 
            << ", Er_dz = " << sqrt(work.Ea()[3][3]) << std::endl;
        std::cout << " tanl = " << work.a()[4] 
            << ", Er_tanl = " << sqrt(work.Ea()[4][4]) << std::endl;
    }
    filter_fwd_calib(track_lead, lead_, way, Eakal);
    track_lead.update_forMdc();
 
    //HepPoint3D IP(0,0,0);    
    if (debug_ == 4) {
        cout << " Mdc FIRST KALMAN FIT " << std::endl;
        Helix work1(track_lead.pivot(), 
                track_lead.a(),
                track_lead.Ea());
        work1.pivot(IP);
        cout << " dr = " << work1.a()[0] 
            << ", Er_dr = " << sqrt(work1.Ea()[0][0]) << std::endl;
        cout << " phi0 = " << work1.a()[1] 
            << ", Er_phi0 = " << sqrt(work1.Ea()[1][1]) << std::endl;
        cout << " PT = " << 1/work1.a()[2] 
            << ", Er_kappa = " << sqrt(work1.Ea()[2][2]) << std::endl;
        cout << " dz = " << work1.a()[3] 
            << ", Er_dz = " << sqrt(work1.Ea()[3][3]) << std::endl;
        cout << " tanl = " << work1.a()[4] 
            << ", Er_tanl = " << sqrt(work1.Ea()[4][4]) << std::endl;
    }
 
    // fill TDS
    RecMdcKalTrack* kaltrk = new RecMdcKalTrack;
 
    // Complete the track (other mass assumption, backward) and 
    complete_track(TrasanTRK, TrasanTRK_add, track_lead, kaltrk,kalcol,segcol);
    // }
 
 
    StatusCode kalsc;
    //check whether the RecMdcKalTrackCol has been already registered
    DataObject *aRecKalEvent;
    eventSvc()->findObject("/Event/Recon/RecMdcKalTrackCol", aRecKalEvent);
    if(aRecKalEvent!=NULL) {
        //then unregister RecMdcKalCol
        kalsc = eventSvc()->unregisterObject("/Event/Recon/RecMdcKalTrackCol");
        if(kalsc != StatusCode::SUCCESS) {
            log << MSG::FATAL << "Could not unregister RecMdcKalTrack collection" << endreq;
            return;
        }
    }
 
    kalsc = eventSvc()->registerObject("/Event/Recon/RecMdcKalTrackCol", kalcol);
    if( kalsc.isFailure()) {
        log << MSG::FATAL << "Could not register RecMdcKalTrack" << endreq;
        return; 
    }
    log << MSG::INFO << "RecMdcKalTrackCol registered successfully!" <<endreq;
 
 
 
    StatusCode segsc;
    //check whether the RecMdcKalHelixSegCol has been already registered
    DataObject *aRecKalSegEvent;
    eventSvc()->findObject("/Event/Recon/RecMdcKalHelixSegCol", aRecKalSegEvent);
    if(aRecKalSegEvent!=NULL) {
        //then unregister RecMdcKalHelixSegCol
        segsc = eventSvc()->unregisterObject("/Event/Recon/RecMdcKalHelixSegCol");
        if(segsc != StatusCode::SUCCESS) {
            log << MSG::FATAL << "Could not unregister RecMdcKalHelixSegCol collection" << endreq;
            return;
        }
    }
 
    segsc = eventSvc()->registerObject("/Event/Recon/RecMdcKalHelixSegCol", segcol);
    if( segsc.isFailure() ) {
        log << MSG::FATAL << "Could not register RecMdcKalHelixSeg" << endreq;
        return; 
    }
    log << MSG::INFO << "RecMdcKalHelixSegCol registered successfully!" <<endreq;
 
 
    double x1(0.),x2(0.),y1(0.),y2(0.),z1(0.),z2(0.),the1(0.),the2(0.),phi1(0.),phi2(0.),p1(0.),p2(0.);
    double r1(0.),r2(0.),kap1(999.),kap2(999.),tanl1(0.),tanl2(0.); 
    //check the result:RecMdcKalTrackCol   
 
    SmartDataPtr<RecMdcKalTrackCol> kaltrkCol(eventSvc(),"/Event/Recon/RecMdcKalTrackCol");
    if (!kaltrkCol) { 
        log << MSG::FATAL << "Could not find RecMdcKalTrackCol" << endreq;
        return;
    }
    log << MSG::INFO << "Begin to check RecMdcKalTrackCol"<<endreq; 
    RecMdcKalTrackCol::iterator iter_trk = kaltrkCol->begin();
    for( int jj=1; iter_trk != kaltrkCol->end(); iter_trk++,jj++) {
        log << MSG::DEBUG << "retrieved MDC Kalmantrack:"
            << "Track Id: " << (*iter_trk)->getTrackId()
            << " Mass of the fit: "<< (*iter_trk)->getMass(2)<< endreq
            << " Length of the track: "<< (*iter_trk)->getLength(2)
            << "  Tof of the track: "<< (*iter_trk)->getTof(2) << endreq
            << " Chisq of the fit: "<< (*iter_trk)->getChisq(0,2)
            <<"  "<< (*iter_trk)->getChisq(1,2) << endreq
            << "Ndf of the fit: "<< (*iter_trk)->getNdf(0,1)
            <<"  "<< (*iter_trk)->getNdf(1,2) << endreq
            << "Kappa " << (*iter_trk)->getZHelix()[2]
            << "zhelixmu "<<(*iter_trk)->getZHelixMu()
            << endreq;
 
        HelixSegRefVec gothelixsegs = (*iter_trk)->getVecHelixSegs();
        if(debug_ == 4) { 
            std::cout<<"the size of gothelixsegs ..."<<gothelixsegs.size()<<std::endl;      
        }
 
        HelixSegRefVec::iterator it_gothelixseg = gothelixsegs.begin();
        for( ; it_gothelixseg != gothelixsegs.end(); it_gothelixseg++) {
            if(debug_ == 4) { 
                std::cout<<"the layerId of this helixseg is ..."<<(*it_gothelixseg)->getLayerId()<<std::endl;
                std::cout<<"the residual of this helixseg exclude the meas hit"<<(*it_gothelixseg)->getResExcl()<<std::endl;
                std::cout<<"the residual of this helixseg include the meas hit"<<(*it_gothelixseg)->getResIncl()<<std::endl;
                std::cout<<"the track id of the helixseg is ..."<<(*it_gothelixseg)->getTrackId() <<std::endl;
                std::cout<<"the tof of the helixseg is ..."<<(*it_gothelixseg)->getTof()<<std::endl;
                std::cout<<"the Zhit of the helixseg is ..."<<(*it_gothelixseg)->getZhit()<<std::endl;
            }
        }
        for( int i = 0; i<43; i++) {
            log << MSG::DEBUG << "retrieved pathl["<<i<<"]= "
                << (*iter_trk)->getPathl(i) <<endreq;
        }
 
        if(ntuple_&1) {
            m_trackid = (*iter_trk)->getTrackId();
            for( int jj =0, iii=0; jj<5; jj++) {
                m_length[jj] = (*iter_trk)->getLength(jj);
                m_tof[jj] = (*iter_trk)->getTof(jj);
                m_nhits[jj] = (*iter_trk)->getNhits(jj);
                m_zhelix[jj] = (*iter_trk)->getZHelix()[jj];
                m_zhelixe[jj] = (*iter_trk)->getZHelixE()[jj];
                m_zhelixmu[jj] = (*iter_trk)->getZHelixMu()[jj];
                m_zhelixk[jj] = (*iter_trk)->getZHelixK()[jj];
                m_zhelixp[jj] = (*iter_trk)->getZHelixP()[jj];
                m_fhelix[jj] = (*iter_trk)->getFHelix()[jj];
                m_fhelixe[jj] = (*iter_trk)->getFHelixE()[jj];
                m_fhelixmu[jj] = (*iter_trk)->getFHelixMu()[jj];
                m_fhelixk[jj] = (*iter_trk)->getFHelixK()[jj];
                m_fhelixp[jj] = (*iter_trk)->getFHelixP()[jj];
                m_lhelix[jj] = (*iter_trk)->getLHelix()[jj];
                m_lhelixe[jj] = (*iter_trk)->getLHelixE()[jj];
                m_lhelixmu[jj] = (*iter_trk)->getLHelixMu()[jj];
                m_lhelixk[jj] = (*iter_trk)->getLHelixK()[jj];
                m_lhelixp[jj] = (*iter_trk)->getLHelixP()[jj];
                if(ntuple_&32) {
                    for(int kk=0; kk<=jj; kk++,iii++) {
                        m_zerror[iii] = (*iter_trk)->getZError()[jj][kk];
                        m_zerrore[iii] = (*iter_trk)->getZErrorE()[jj][kk];
                        m_zerrormu[iii] = (*iter_trk)->getZErrorMu()[jj][kk];
                        m_zerrork[iii] = (*iter_trk)->getZErrorK()[jj][kk];
                        m_zerrorp[iii] = (*iter_trk)->getZErrorP()[jj][kk];
                        m_ferror[iii] = (*iter_trk)->getFError()[jj][kk];
                        m_ferrore[iii] = (*iter_trk)->getFErrorE()[jj][kk];
                        m_ferrormu[iii] = (*iter_trk)->getFErrorMu()[jj][kk];
                        m_ferrork[iii] = (*iter_trk)->getFErrorK()[jj][kk];
                        m_ferrorp[iii] = (*iter_trk)->getFErrorP()[jj][kk];
                        m_lerror[iii] = (*iter_trk)->getLError()[jj][kk];
                        m_lerrore[iii] = (*iter_trk)->getLErrorE()[jj][kk];
                        m_lerrormu[iii] = (*iter_trk)->getLErrorMu()[jj][kk];
                        m_lerrork[iii] = (*iter_trk)->getLErrorK()[jj][kk];
                        m_lerrorp[iii] = (*iter_trk)->getLErrorP()[jj][kk];
                    }
 
                }
            }
 
            // RootConversion changed in BOSS6.0, so use thefollowing:
            m_chisq[0][0] = (*iter_trk)->getChisq(0,0);
            m_chisq[1][0] = (*iter_trk)->getChisq(0,1);
            m_chisq[2][0] = (*iter_trk)->getChisq(0,2);
            m_chisq[3][0] = (*iter_trk)->getChisq(0,3);
            m_chisq[4][0] = (*iter_trk)->getChisq(0,4);
            m_chisq[0][1] = (*iter_trk)->getChisq(1,0);
            m_chisq[1][1] = (*iter_trk)->getChisq(1,1);
            m_chisq[2][1] = (*iter_trk)->getChisq(1,2);
            m_chisq[3][1] = (*iter_trk)->getChisq(1,3);
            m_chisq[4][1] = (*iter_trk)->getChisq(1,4);
 
            m_ndf[0][0] = (*iter_trk)->getNdf(0,0);
            m_ndf[1][0] = (*iter_trk)->getNdf(0,1);
            m_ndf[2][0] = (*iter_trk)->getNdf(0,2);
            m_ndf[3][0] = (*iter_trk)->getNdf(0,3);
            m_ndf[4][0] = (*iter_trk)->getNdf(0,4);
            m_ndf[0][1] = (*iter_trk)->getNdf(1,0);
            m_ndf[1][1] = (*iter_trk)->getNdf(1,1);
            m_ndf[2][1] = (*iter_trk)->getNdf(1,2);
            m_ndf[3][1] = (*iter_trk)->getNdf(1,3);
            m_ndf[4][1] = (*iter_trk)->getNdf(1,4);
 
            m_stat[0][0] = (*iter_trk)->getStat(0,0);
            m_stat[1][0] = (*iter_trk)->getStat(0,1);
            m_stat[2][0] = (*iter_trk)->getStat(0,2);
            m_stat[3][0] = (*iter_trk)->getStat(0,3);
            m_stat[4][0] = (*iter_trk)->getStat(0,4);
            m_stat[0][1] = (*iter_trk)->getStat(1,0);
            m_stat[1][1] = (*iter_trk)->getStat(1,1);
            m_stat[2][1] = (*iter_trk)->getStat(1,2);
            m_stat[3][1] = (*iter_trk)->getStat(1,3);
            m_stat[4][1] = (*iter_trk)->getStat(1,4);
 
            m_fptot = sqrt(1+pow(m_fhelix[4],2))/m_fhelix[2];
            m_fptote = sqrt(1+pow(m_fhelixe[4],2))/m_fhelixe[2];
            m_fptotmu = sqrt(1+pow(m_fhelixmu[4],2))/m_fhelixmu[2];
            m_fptotk = sqrt(1+pow(m_fhelixk[4],2))/m_fhelixk[2];
            m_fptotp = sqrt(1+pow(m_fhelixp[4],2))/m_fhelixp[2];
 
            m_zpt = 1/m_zhelix[2];
            m_zpte = 1/m_zhelixe[2];
            m_zptmu = 1/m_zhelixmu[2];
            m_zptk = 1/m_zhelixk[2];
            m_zptp = 1/m_zhelixp[2];
 
            m_fpt = 1/m_fhelix[2];
            m_fpte = 1/m_fhelixe[2];
            m_fptmu = 1/m_fhelixmu[2];
            m_fptk = 1/m_fhelixk[2];
            m_fptp = 1/m_fhelixp[2];
 
            m_lpt = 1/m_lhelix[2];
            m_lpte = 1/m_lhelixe[2];
            m_lptmu = 1/m_lhelixmu[2];
            m_lptk = 1/m_lhelixk[2];
            m_lptp = 1/m_lhelixp[2];
 
            m_lptot = sqrt(1+pow(m_lhelix[4],2))/m_lhelix[2];
            m_lptote = sqrt(1+pow(m_lhelixe[4],2))/m_lhelixe[2];
            m_lptotmu = sqrt(1+pow(m_lhelixmu[4],2))/m_lhelixmu[2];
            m_lptotk = sqrt(1+pow(m_lhelixk[4],2))/m_lhelixk[2];
            m_lptotp = sqrt(1+pow(m_lhelixp[4],2))/m_lhelixp[2];
 
            m_zptot = sqrt(1+pow(m_zhelix[4],2))/m_zhelix[2];
            m_zptote = sqrt(1+pow(m_zhelixe[4],2))/m_zhelixe[2];
            m_zptotmu = sqrt(1+pow(m_zhelixmu[4],2))/m_zhelixmu[2];
            m_zptotk = sqrt(1+pow(m_zhelixk[4],2))/m_zhelixk[2];
            m_zptotp = sqrt(1+pow(m_zhelixp[4],2))/m_zhelixp[2];
            if(ntuple_&32) {
                m_zsigp = sqrt(pow((m_zptot/m_zhelix[2]),2)*m_zerror[5]+
                        pow((m_zhelix[4]/m_zptot),2)*pow((1/m_zhelix[2]),4)*m_zerror[14]-
                        2*m_zhelix[4]*m_zerror[12]*pow((1/m_zhelix[2]),3));
                m_zsigpe = sqrt(pow((m_zptote/m_zhelixe[2]),2)*m_zerrore[5]+
                        pow((m_zhelixe[4]/m_zptote),2)*pow((1/m_zhelixe[2]),4)*m_zerrore[14]-
                        2*m_zhelixe[4]*m_zerrore[12]*pow((1/m_zhelixe[2]),3));
                m_zsigpmu = sqrt(pow((m_zptotmu/m_zhelixmu[2]),2)*m_zerrormu[5]+
                        pow((m_zhelixmu[4]/m_zptotmu),2)*pow((1/m_zhelixmu[2]),4)*m_zerrormu[14]-
                        2*m_zhelixmu[4]*m_zerrormu[12]*pow((1/m_zhelixmu[2]),3));
                m_zsigpk = sqrt(pow((m_zptotk/m_zhelixk[2]),2)*m_zerrork[5]+
                        pow((m_zhelixk[4]/m_zptotk),2)*pow((1/m_zhelixk[2]),4)*m_zerrork[14]-
                        2*m_zhelixk[4]*m_zerrork[12]*pow((1/m_zhelixk[2]),3));
                m_zsigpp = sqrt(pow((m_zptotp/m_zhelixp[2]),2)*m_zerrorp[5]+
                        pow((m_zhelixp[4]/m_zptotp),2)*pow((1/m_zhelixp[2]),4)*m_zerrorp[14]-
                        2*m_zhelixp[4]*m_zerrorp[12]*pow((1/m_zhelixp[2]),3));
            }
 
            StatusCode sc1 = m_nt1->write();
            if( sc1.isFailure() ) cout<<"Ntuple1 filling failed!"<<endl;     
        }
 
        if(ntuple_&4) {
            if(jj == 1) { 
                phi1 = (*iter_trk)->getFFi0();
                r1 = (*iter_trk)->getFDr();
                z1 = (*iter_trk)->getFDz(); 
                kap1 = (*iter_trk)->getFCpa();  
                tanl1 = (*iter_trk)->getFTanl();    
                x1 = r1*cos(phi1);
                y1 = r1*sin(phi1);
                p1 = sqrt(1+tanl1*tanl1)/kap1;
                the1 = M_PI/2-atan(tanl1);
            } else if(jj == 2) {
                phi2 = (*iter_trk)->getFFi0();
                r2 = (*iter_trk)->getFDr();
                z2 = (*iter_trk)->getFDz(); 
                kap2 = (*iter_trk)->getFCpa();  
                tanl2 = (*iter_trk)->getFTanl();    
                x2 = r1*cos(phi2);
                y2 = r1*sin(phi2);
                p2 = sqrt(1+tanl2*tanl2)/kap1;
                the2 = M_PI/2-atan(tanl2);
            }
        }
    }
    if(ntuple_&4) {
        m_delx = x1 - x2;
        m_dely = y1 - y2;
        m_delz = z1 - z2;
        m_delthe = the1 + the2;
        m_delphi = phi1- phi2;
        m_delp = p1 - p2;
        StatusCode sc2 = m_nt2->write();
        if( sc2.isFailure() ) cout<<"Ntuple2 filling failed!"<<endl;      
    } 
    delete [] order;
    delete [] rCont;
    delete [] rGen;
    delete [] rOM;
 
    if (debug_ == 4)
        cout << "Kalfitting finished " << std::endl;
}

Referenced by execute().

kalman_fitting_csmalign() [2/2]

void KalFitAlg::kalman_fitting_csmalign

(

void

)

kalman_fitting_MdcxReco_Csmc_Sew() [1/2]

void KalFitAlg::kalman_fitting_MdcxReco_Csmc_Sew

(

void

)

Definition at line 4561 of file KalFitAlg.cxx.

{
 
    MsgStream log(msgSvc(), name());
    double Pt_threshold(0.3);
    Hep3Vector IP(0,0,0);
 
    vector<MdcRec_trk>* mdcMgr = MdcRecTrkCol::getMdcRecTrkCol();
    vector<MdcRec_trk_add>* mdc_addMgr = MdcRecTrkAddCol::getMdcRecTrkAddCol();
    vector<MdcRec_wirhit>* whMgr = MdcRecWirhitCol::getMdcRecWirhitCol();    
 
    // Table Manager
    if ( !&whMgr ) return;
 
    // Get reduced chi**2 of Mdc track :
    int ntrk = mdcMgr->size();
    // cout<<"ntrk: "<<ntrk<<endl;
 
    int nhits = whMgr->size();
    //cout<<"nhits: "<<nhits<<endl;
 
 
    //check whether  Recon  already registered
    DataObject *aReconEvent;
    eventSvc()->findObject("/Event/Recon",aReconEvent);
    if(!aReconEvent) {
        // register ReconEvent Data Object to TDS;
        ReconEvent* recevt = new ReconEvent;
        StatusCode sc = eventSvc()->registerObject("/Event/Recon",recevt );
        if(sc!=StatusCode::SUCCESS) {
            log << MSG::FATAL << "Could not register ReconEvent" <<endreq;
            return;
        }
    }
 
    RecMdcKalTrackCol* kalcol = new RecMdcKalTrackCol;   
    RecMdcKalHelixSegCol *segcol =new RecMdcKalHelixSegCol;
    //make RecMdcKalTrackCol
    log << MSG::INFO << "beginning to make RecMdcKalTrackCol" <<endreq;     
 
 
    MdcRec_trk& TrasanTRK = *(mdcMgr->begin());     
    MdcRec_trk_add& TrasanTRK_add = *(mdc_addMgr->begin());
    // Reject the ones with quality != 0 
    // int trasqual = TrasanTRK_add.quality;
    // if(debug_ == 4) cout<<"kalman_fitting>trasqual... "<<trasqual<<endl; 
    // if (trasqual) continue;
 
    // What kind of KalFit ? 
    int type(0);
    if ((TrasanTRK_add.decision & 32) == 32 ||
            (TrasanTRK_add.decision & 64) == 64)      type = 1;
 
    // Initialisation : (x, a, ea)
    HepPoint3D x(TrasanTRK.pivot[0],
            TrasanTRK.pivot[1],
            TrasanTRK.pivot[2]);
 
    HepVector a(5);
    for(int i = 0; i < 5; i++)
        a[i] = TrasanTRK.helix[i];
 
    HepSymMatrix ea(5);
    for(int i = 0, k = 0; i < 5; i++) {
        for(int j = 0; j <= i; j++) {
            ea[i][j] = matrixg_*TrasanTRK.error[k++];
            ea[j][i] = ea[i][j];
        }
    }
 
    KalFitTrack::setInitMatrix(ea);
 
    double fiTerm = TrasanTRK.fiTerm;
    int way(1);
    // Prepare the track found :
    KalFitTrack track_lead = KalFitTrack(x, a, ea, lead_, 0, 0);
    track_lead.bFieldZ(KalFitTrack::Bznom_);
 
    int hit_asso(0);
    // Reject the ones with quality != 0 
    int trasqual = TrasanTRK_add.quality;
    if(debug_ == 4) cout<<"kalman_fitting>trasqual... "<<trasqual<<endl; 
    if (trasqual) return;
    // Mdc Hits 
    int inlyr(999), outlyr(-1);
    int* rStat = new int[43];
    for(int irStat=0;irStat<43;++irStat)rStat[irStat]=0;
    std::vector<MdcRec_wirhit*> pt=TrasanTRK.hitcol;
    int hit_in(0);
    if(debug_ == 4)    cout<<"*********Pt size****"<< pt.size()<<endl;
    // Number of hits/layer 
    int Num[43] = {0};
    for (vector<MdcRec_wirhit*>::iterator ii = pt.end()-1;
            ii != pt.begin()-1; ii--) {
        Num[(*ii)->geo->Lyr()->Id()]++;
    }
 
    for (vector<MdcRec_wirhit*>::iterator ii = pt.end()-1;
            ii != pt.begin()-1; ii--) { 
 
        hit_asso++;
        if (Num[(*ii)->geo->Lyr()->Id()]>3) {
            if (debug_ >0)
                cout << "WARNING:  I found " << Num[(*ii)->geo->Lyr()->Id()] 
                    << " hits in the layer "
                    << (*ii)->geo->Lyr()->Id() << std::endl;
            continue;
        }
 
        hit_in++;
        MdcRec_wirhit & rechit = **ii;
        double dist[2] = {rechit.ddl, rechit.ddr};
        double erdist[2] = {rechit.erddl, rechit.erddr};
        const MdcGeoWire* geo = rechit.geo;
 
        int lr_decision(0);
        if (KalFitTrack::LR_ == 1){
            if (rechit.lr==2 || rechit.lr==0) lr_decision=-1;
            //  if (rechit.lr==0) lr_decision=-1;
            else if (rechit.lr==1) lr_decision=1;
        } 
 
        int ind(geo->Lyr()->Id());
        track_lead.appendHitsMdc( KalFitHitMdc(rechit.id,
                    lr_decision, rechit.tdc,
                    dist, erdist, 
                    _wire+(geo->Id()), rechit.rechitptr));
        // inner/outer layer :
        rStat[ind]++;
        if (inlyr>ind) inlyr = ind;
        if (outlyr<ind) outlyr = ind;
    }
    // Empty layers :
    int empty_between(0), empty(0);
    for (int i= inlyr; i <= outlyr; i++)
        if (!rStat[i]) empty_between++;
    empty = empty_between+inlyr+(42-outlyr);
    delete [] rStat;
 
    if (debug_ == 4) 
        cout << "**** NUMBER OF Mdc HITS (TRASAN) = " << hit_asso << std::endl;
 
 
    // RMK high momentum track under study, probably not neeeded...
    track_lead.order_wirhit(0);
    track_lead.type(type);
    unsigned int nhit = track_lead.HitsMdc().size();
    if (nhit<70) {
        cout << " ATTENTION TRACK WITH ONLY HITS " << nhit << std::endl;
        return;
    }
 
    // Initialisation :
    double  KalFitst(0), KalFitax(0), KalFitschi2(0);
    // Move to the outer most hit :      
    Hep3Vector outer_pivot(track_lead.x(fiTerm));
 
    if(debug_ == 4) {
        std::cout<<"before track_lead.pivot(outer_pivot) ,the error matrix of track_lead is .."<<track_lead.Ea()<<std::endl;
    }
    track_lead.pivot(outer_pivot); // hi gay, the error matrix is changed in this function!! 
    track_lead.bFieldZ(KalFitTrack::Bznom_);
    // attention best_chi2 reinitialize !!! 
    if (nhit>=3 && !KalFitTrack::LR_) 
        start_seed(track_lead, lead_, way, TrasanTRK);
    HepSymMatrix Eakal(5,0);
 
    //init_matrix(TrasanTRK, Eakal);
 
    double costheta = track_lead.a()[4] / sqrt(1.0 + track_lead.a()[4]*track_lead.a()[4]);
    if( (1.0/fabs(track_lead.a()[2]) < pt_cut_ ) && (fabs(costheta)> theta_cut_) ) {
        choice_ = 6;
    }
 
    init_matrix(choice_,TrasanTRK, Eakal);
 
    //std::cout<<" Eakal be here: "<<Eakal<<std::endl;
 
    if (debug_ == 4){
        std::cout << "from Mdc Pattern Recognition: " << std::endl;
        //HepPoint3D IP(0,0,0);
        Helix work(track_lead.pivot(), 
                track_lead.a(),
                track_lead.Ea());
        work.pivot(IP);
        std::cout << " dr = " << work.a()[0] 
            << ", Er_dr = " << sqrt(work.Ea()[0][0]) << std::endl;
        std::cout << " phi0 = " << work.a()[1] 
            << ", Er_phi0 = " << sqrt(work.Ea()[1][1]) << std::endl;
        std::cout << " PT = " << 1/work.a()[2] 
            << ", Er_kappa = " << sqrt(work.Ea()[2][2]) << std::endl;
        std::cout << " dz = " << work.a()[3] 
            << ", Er_dz = " << sqrt(work.Ea()[3][3]) << std::endl;
        std::cout << " tanl = " << work.a()[4] 
            << ", Er_tanl = " << sqrt(work.Ea()[4][4]) << std::endl;
    }
    filter_fwd_calib(track_lead, lead_, way, Eakal);
    track_lead.update_forMdc();
 
    //HepPoint3D IP(0,0,0);    
    if (debug_ == 4) {
        cout << " Mdc FIRST KALMAN FIT " << std::endl;
        Helix work1(track_lead.pivot(), 
                track_lead.a(),
                track_lead.Ea());
        work1.pivot(IP);
        cout << " dr = " << work1.a()[0] 
            << ", Er_dr = " << sqrt(work1.Ea()[0][0]) << std::endl;
        cout << " phi0 = " << work1.a()[1] 
            << ", Er_phi0 = " << sqrt(work1.Ea()[1][1]) << std::endl;
        cout << " PT = " << 1/work1.a()[2] 
            << ", Er_kappa = " << sqrt(work1.Ea()[2][2]) << std::endl;
        cout << " dz = " << work1.a()[3] 
            << ", Er_dz = " << sqrt(work1.Ea()[3][3]) << std::endl;
        cout << " tanl = " << work1.a()[4] 
            << ", Er_tanl = " << sqrt(work1.Ea()[4][4]) << std::endl;
    }
 
    // fill TDS
    RecMdcKalTrack* kaltrk = new RecMdcKalTrack;
 
    // Complete the track (other mass assumption, backward) and 
    complete_track(TrasanTRK, TrasanTRK_add, track_lead, kaltrk,kalcol,segcol);
 
 
    StatusCode kalsc;
    //check whether the RecMdcKalTrackCol has been already registered
    DataObject *aRecKalEvent;
    eventSvc()->findObject("/Event/Recon/RecMdcKalTrackCol", aRecKalEvent);
    if(aRecKalEvent!=NULL) {
        //then unregister RecMdcKalCol
        kalsc = eventSvc()->unregisterObject("/Event/Recon/RecMdcKalTrackCol");
        if(kalsc != StatusCode::SUCCESS) {
            log << MSG::FATAL << "Could not unregister RecMdcKalTrack collection" << endreq;
            return;
        }
    }
 
    kalsc = eventSvc()->registerObject("/Event/Recon/RecMdcKalTrackCol", kalcol);
    if( kalsc.isFailure()) {
        log << MSG::FATAL << "Could not register RecMdcKalTrack" << endreq;
        return; 
    }
    log << MSG::INFO << "RecMdcKalTrackCol registered successfully!" <<endreq;
 
 
 
    StatusCode segsc;
    //check whether the RecMdcKalHelixSegCol has been already registered
    DataObject *aRecKalSegEvent;
    eventSvc()->findObject("/Event/Recon/RecMdcKalHelixSegCol", aRecKalSegEvent);
    if(aRecKalSegEvent!=NULL) {
        //then unregister RecMdcKalHelixSegCol
        segsc = eventSvc()->unregisterObject("/Event/Recon/RecMdcKalHelixSegCol");
        if(segsc != StatusCode::SUCCESS) {
            log << MSG::FATAL << "Could not unregister RecMdcKalHelixSegCol collection" << endreq;
            return;
        }
    }
 
    segsc = eventSvc()->registerObject("/Event/Recon/RecMdcKalHelixSegCol", segcol);
    if( segsc.isFailure() ) {
        log << MSG::FATAL << "Could not register RecMdcKalHelixSeg" << endreq;
        return; 
    }
    log << MSG::INFO << "RecMdcKalHelixSegCol registered successfully!" <<endreq;
 
 
    double x1(0.),x2(0.),y1(0.),y2(0.),z1(0.),z2(0.),the1(0.),the2(0.),phi1(0.),phi2(0.),p1(0.),p2(0.);
    double r1(0.),r2(0.),kap1(999.),kap2(999.),tanl1(0.),tanl2(0.); 
    //check the result:RecMdcKalTrackCol   
 
    SmartDataPtr<RecMdcKalTrackCol> kaltrkCol(eventSvc(),"/Event/Recon/RecMdcKalTrackCol");
    if (!kaltrkCol) { 
        log << MSG::FATAL << "Could not find RecMdcKalTrackCol" << endreq;
        return;
    }
    log << MSG::INFO << "Begin to check RecMdcKalTrackCol"<<endreq; 
    RecMdcKalTrackCol::iterator iter_trk = kaltrkCol->begin();
    for( int jj=1; iter_trk != kaltrkCol->end(); iter_trk++,jj++) {
        log << MSG::DEBUG << "retrieved MDC Kalmantrack:"
            << "Track Id: " << (*iter_trk)->getTrackId()
            << " Mass of the fit: "<< (*iter_trk)->getMass(2)<< endreq
            << " Length of the track: "<< (*iter_trk)->getLength(2)
            << "  Tof of the track: "<< (*iter_trk)->getTof(2) << endreq
            << " Chisq of the fit: "<< (*iter_trk)->getChisq(0,2)
            <<"  "<< (*iter_trk)->getChisq(1,2) << endreq
            << "Ndf of the fit: "<< (*iter_trk)->getNdf(0,1)
            <<"  "<< (*iter_trk)->getNdf(1,2) << endreq
            << "Kappa " << (*iter_trk)->getZHelix()[2]
            << "zhelixmu "<<(*iter_trk)->getZHelixMu()
            << endreq;
 
        HelixSegRefVec gothelixsegs = (*iter_trk)->getVecHelixSegs();
        if(debug_ == 4) { 
            std::cout<<"the size of gothelixsegs ..."<<gothelixsegs.size()<<std::endl;      
        }
 
        HelixSegRefVec::iterator it_gothelixseg = gothelixsegs.begin();
        for( ; it_gothelixseg != gothelixsegs.end(); it_gothelixseg++) {
            if(debug_ == 4) { 
                std::cout<<"the layerId of this helixseg is ..."<<(*it_gothelixseg)->getLayerId()<<std::endl;
                std::cout<<"the residual of this helixseg exclude the meas hit"<<(*it_gothelixseg)->getResExcl()<<std::endl;
                std::cout<<"the residual of this helixseg include the meas hit"<<(*it_gothelixseg)->getResIncl()<<std::endl;
                std::cout<<"the track id of the helixseg is ..."<<(*it_gothelixseg)->getTrackId() <<std::endl;
                std::cout<<"the tof of the helixseg is ..."<<(*it_gothelixseg)->getTof()<<std::endl;
                std::cout<<"the Zhit of the helixseg is ..."<<(*it_gothelixseg)->getZhit()<<std::endl;
            }
        }
        for( int i = 0; i<43; i++) {
            log << MSG::DEBUG << "retrieved pathl["<<i<<"]= "
                << (*iter_trk)->getPathl(i) <<endreq;
        }
 
        if(ntuple_&1) {
            m_trackid = (*iter_trk)->getTrackId();
            for( int jj =0, iii=0; jj<5; jj++) {
                m_length[jj] = (*iter_trk)->getLength(jj);
                m_tof[jj] = (*iter_trk)->getTof(jj);
                m_nhits[jj] = (*iter_trk)->getNhits(jj);
                m_zhelix[jj] = (*iter_trk)->getZHelix()[jj];
                m_zhelixe[jj] = (*iter_trk)->getZHelixE()[jj];
                m_zhelixmu[jj] = (*iter_trk)->getZHelixMu()[jj];
                m_zhelixk[jj] = (*iter_trk)->getZHelixK()[jj];
                m_zhelixp[jj] = (*iter_trk)->getZHelixP()[jj];
                m_fhelix[jj] = (*iter_trk)->getFHelix()[jj];
                m_fhelixe[jj] = (*iter_trk)->getFHelixE()[jj];
                m_fhelixmu[jj] = (*iter_trk)->getFHelixMu()[jj];
                m_fhelixk[jj] = (*iter_trk)->getFHelixK()[jj];
                m_fhelixp[jj] = (*iter_trk)->getFHelixP()[jj];
                m_lhelix[jj] = (*iter_trk)->getLHelix()[jj];
                m_lhelixe[jj] = (*iter_trk)->getLHelixE()[jj];
                m_lhelixmu[jj] = (*iter_trk)->getLHelixMu()[jj];
                m_lhelixk[jj] = (*iter_trk)->getLHelixK()[jj];
                m_lhelixp[jj] = (*iter_trk)->getLHelixP()[jj];
                if(ntuple_&32) {
                    for(int kk=0; kk<=jj; kk++,iii++) {
                        m_zerror[iii] = (*iter_trk)->getZError()[jj][kk];
                        m_zerrore[iii] = (*iter_trk)->getZErrorE()[jj][kk];
                        m_zerrormu[iii] = (*iter_trk)->getZErrorMu()[jj][kk];
                        m_zerrork[iii] = (*iter_trk)->getZErrorK()[jj][kk];
                        m_zerrorp[iii] = (*iter_trk)->getZErrorP()[jj][kk];
                        m_ferror[iii] = (*iter_trk)->getFError()[jj][kk];
                        m_ferrore[iii] = (*iter_trk)->getFErrorE()[jj][kk];
                        m_ferrormu[iii] = (*iter_trk)->getFErrorMu()[jj][kk];
                        m_ferrork[iii] = (*iter_trk)->getFErrorK()[jj][kk];
                        m_ferrorp[iii] = (*iter_trk)->getFErrorP()[jj][kk];
                        m_lerror[iii] = (*iter_trk)->getLError()[jj][kk];
                        m_lerrore[iii] = (*iter_trk)->getLErrorE()[jj][kk];
                        m_lerrormu[iii] = (*iter_trk)->getLErrorMu()[jj][kk];
                        m_lerrork[iii] = (*iter_trk)->getLErrorK()[jj][kk];
                        m_lerrorp[iii] = (*iter_trk)->getLErrorP()[jj][kk];
                    }
 
                }
            }
 
            // RootConversion changed in BOSS6.0, so use thefollowing:
            m_chisq[0][0] = (*iter_trk)->getChisq(0,0);
            m_chisq[1][0] = (*iter_trk)->getChisq(0,1);
            m_chisq[2][0] = (*iter_trk)->getChisq(0,2);
            m_chisq[3][0] = (*iter_trk)->getChisq(0,3);
            m_chisq[4][0] = (*iter_trk)->getChisq(0,4);
            m_chisq[0][1] = (*iter_trk)->getChisq(1,0);
            m_chisq[1][1] = (*iter_trk)->getChisq(1,1);
            m_chisq[2][1] = (*iter_trk)->getChisq(1,2);
            m_chisq[3][1] = (*iter_trk)->getChisq(1,3);
            m_chisq[4][1] = (*iter_trk)->getChisq(1,4);
 
            m_ndf[0][0] = (*iter_trk)->getNdf(0,0);
            m_ndf[1][0] = (*iter_trk)->getNdf(0,1);
            m_ndf[2][0] = (*iter_trk)->getNdf(0,2);
            m_ndf[3][0] = (*iter_trk)->getNdf(0,3);
            m_ndf[4][0] = (*iter_trk)->getNdf(0,4);
            m_ndf[0][1] = (*iter_trk)->getNdf(1,0);
            m_ndf[1][1] = (*iter_trk)->getNdf(1,1);
            m_ndf[2][1] = (*iter_trk)->getNdf(1,2);
            m_ndf[3][1] = (*iter_trk)->getNdf(1,3);
            m_ndf[4][1] = (*iter_trk)->getNdf(1,4);
 
            m_stat[0][0] = (*iter_trk)->getStat(0,0);
            m_stat[1][0] = (*iter_trk)->getStat(0,1);
            m_stat[2][0] = (*iter_trk)->getStat(0,2);
            m_stat[3][0] = (*iter_trk)->getStat(0,3);
            m_stat[4][0] = (*iter_trk)->getStat(0,4);
            m_stat[0][1] = (*iter_trk)->getStat(1,0);
            m_stat[1][1] = (*iter_trk)->getStat(1,1);
            m_stat[2][1] = (*iter_trk)->getStat(1,2);
            m_stat[3][1] = (*iter_trk)->getStat(1,3);
            m_stat[4][1] = (*iter_trk)->getStat(1,4);
 
            m_fptot = sqrt(1+pow(m_fhelix[4],2))/m_fhelix[2];
            m_fptote = sqrt(1+pow(m_fhelixe[4],2))/m_fhelixe[2];
            m_fptotmu = sqrt(1+pow(m_fhelixmu[4],2))/m_fhelixmu[2];
            m_fptotk = sqrt(1+pow(m_fhelixk[4],2))/m_fhelixk[2];
            m_fptotp = sqrt(1+pow(m_fhelixp[4],2))/m_fhelixp[2];
 
            m_zpt = 1/m_zhelix[2];
            m_zpte = 1/m_zhelixe[2];
            m_zptmu = 1/m_zhelixmu[2];
            m_zptk = 1/m_zhelixk[2];
            m_zptp = 1/m_zhelixp[2];
 
            m_fpt = 1/m_fhelix[2];
            m_fpte = 1/m_fhelixe[2];
            m_fptmu = 1/m_fhelixmu[2];
            m_fptk = 1/m_fhelixk[2];
            m_fptp = 1/m_fhelixp[2];
 
            m_lpt = 1/m_lhelix[2];
            m_lpte = 1/m_lhelixe[2];
            m_lptmu = 1/m_lhelixmu[2];
            m_lptk = 1/m_lhelixk[2];
            m_lptp = 1/m_lhelixp[2];
 
            m_lptot = sqrt(1+pow(m_lhelix[4],2))/m_lhelix[2];
            m_lptote = sqrt(1+pow(m_lhelixe[4],2))/m_lhelixe[2];
            m_lptotmu = sqrt(1+pow(m_lhelixmu[4],2))/m_lhelixmu[2];
            m_lptotk = sqrt(1+pow(m_lhelixk[4],2))/m_lhelixk[2];
            m_lptotp = sqrt(1+pow(m_lhelixp[4],2))/m_lhelixp[2];
 
            m_zptot = sqrt(1+pow(m_zhelix[4],2))/m_zhelix[2];
            m_zptote = sqrt(1+pow(m_zhelixe[4],2))/m_zhelixe[2];
            m_zptotmu = sqrt(1+pow(m_zhelixmu[4],2))/m_zhelixmu[2];
            m_zptotk = sqrt(1+pow(m_zhelixk[4],2))/m_zhelixk[2];
            m_zptotp = sqrt(1+pow(m_zhelixp[4],2))/m_zhelixp[2];
            if(ntuple_&32) {
                m_zsigp = sqrt(pow((m_zptot/m_zhelix[2]),2)*m_zerror[5]+
                        pow((m_zhelix[4]/m_zptot),2)*pow((1/m_zhelix[2]),4)*m_zerror[14]-
                        2*m_zhelix[4]*m_zerror[12]*pow((1/m_zhelix[2]),3));
                m_zsigpe = sqrt(pow((m_zptote/m_zhelixe[2]),2)*m_zerrore[5]+
                        pow((m_zhelixe[4]/m_zptote),2)*pow((1/m_zhelixe[2]),4)*m_zerrore[14]-
                        2*m_zhelixe[4]*m_zerrore[12]*pow((1/m_zhelixe[2]),3));
                m_zsigpmu = sqrt(pow((m_zptotmu/m_zhelixmu[2]),2)*m_zerrormu[5]+
                        pow((m_zhelixmu[4]/m_zptotmu),2)*pow((1/m_zhelixmu[2]),4)*m_zerrormu[14]-
                        2*m_zhelixmu[4]*m_zerrormu[12]*pow((1/m_zhelixmu[2]),3));
                m_zsigpk = sqrt(pow((m_zptotk/m_zhelixk[2]),2)*m_zerrork[5]+
                        pow((m_zhelixk[4]/m_zptotk),2)*pow((1/m_zhelixk[2]),4)*m_zerrork[14]-
                        2*m_zhelixk[4]*m_zerrork[12]*pow((1/m_zhelixk[2]),3));
                m_zsigpp = sqrt(pow((m_zptotp/m_zhelixp[2]),2)*m_zerrorp[5]+
                        pow((m_zhelixp[4]/m_zptotp),2)*pow((1/m_zhelixp[2]),4)*m_zerrorp[14]-
                        2*m_zhelixp[4]*m_zerrorp[12]*pow((1/m_zhelixp[2]),3));
            }
 
            StatusCode sc1 = m_nt1->write();
            if( sc1.isFailure() ) cout<<"Ntuple1 filling failed!"<<endl;     
        }
 
        if(ntuple_&4) {
            if(jj == 1) { 
                phi1 = (*iter_trk)->getFFi0();
                r1 = (*iter_trk)->getFDr();
                z1 = (*iter_trk)->getFDz(); 
                kap1 = (*iter_trk)->getFCpa();  
                tanl1 = (*iter_trk)->getFTanl();    
                x1 = r1*cos(phi1);
                y1 = r1*sin(phi1);
                p1 = sqrt(1+tanl1*tanl1)/kap1;
                the1 = M_PI/2-atan(tanl1);
            } else if(jj == 2) {
                phi2 = (*iter_trk)->getFFi0();
                r2 = (*iter_trk)->getFDr();
                z2 = (*iter_trk)->getFDz(); 
                kap2 = (*iter_trk)->getFCpa();  
                tanl2 = (*iter_trk)->getFTanl();    
                x2 = r1*cos(phi2);
                y2 = r1*sin(phi2);
                p2 = sqrt(1+tanl2*tanl2)/kap1;
                the2 = M_PI/2-atan(tanl2);
            }
        }
    }
    if(ntuple_&4) {
        m_delx = x1 - x2;
        m_dely = y1 - y2;
        m_delz = z1 - z2;
        m_delthe = the1 + the2;
        m_delphi = phi1- phi2;
        m_delp = p1 - p2;
        StatusCode sc2 = m_nt2->write();
        if( sc2.isFailure() ) cout<<"Ntuple2 filling failed!"<<endl;      
    } 
 
    if (debug_ == 4)
        cout << "Kalfitting finished " << std::endl;
}

Referenced by execute().

kalman_fitting_MdcxReco_Csmc_Sew() [2/2]

void KalFitAlg::kalman_fitting_MdcxReco_Csmc_Sew

(

void

)

makeGemHitsCol() [1/2]

void KalFitAlg::makeGemHitsCol

(

)

Definition at line 6738 of file KalFitAlg.cxx.

{
    for(int i=0; i<3; i++) myGemHitCol[i].clear();
 
    /*SmartDataPtr<Event::MdcMcHitCol> mdcMcHitCol(eventSvc(), "/Event/MC/MdcMcHitCol");
      SmartDataPtr<MdcDigiCol> mdcDigiCol(eventSvc(),"/Event/Digi/MdcDigiCol");
 
      int nHits, nDigi;
      unsigned int stripIndx, isVStrip;
      int layer;
      double x, y, z, r, phi;
 
      nHits = mdcMcHitCol->size();
      nDigi = mdcDigiCol->size();
 
    //cout<<__FUNCTION__<<":: nHits = "<<nHits<<endl;
 
    Rndm::Numbers gaussRPhi(randSvc(), Rndm::Gauss(0.,0.023));
    Rndm::Numbers gaussZ(randSvc(), Rndm::Gauss(0.,0.05));
 
    MdcMcHitCol::const_iterator it = mdcMcHitCol->begin();
 
    cout<<endl<<endl<<" ------------- Mdc MC hits: ------------"<<endl<<endl;*/ 
 
    SmartDataPtr<RecCgemClusterCol> cgemClusterCol(eventSvc(),"/Event/Recon/RecCgemClusterCol");
    int layer,sheet;
    double phi,v;
    RecCgemClusterCol::const_iterator it = cgemClusterCol->begin();
    for(;it!=cgemClusterCol->end();it++){
        //cout<<"cluster:"<<(*it)->getclusterid()<<" phi:"<<(*it)->getrecphi()<<"  z:"<<(*it)->getRecZ()<<endl;
        if((*it)->getflag()==2){
            layer = (*it)->getlayerid();
            sheet = (*it)->getsheetid();
            phi   = (*it)->getrecphi();
            v     = (*it)->getrecv();
            KalFitGemHit aKalFitGemHit(phi,v,layer,sheet);
            myGemHitCol[layer].push_back(aKalFitGemHit);
        }
    }
    if(debug_==4){
        cout << "Gem information" << endl;
        cout << "first layer " << myGemHitCol[0].size() << endl;
        cout << "second layer" << myGemHitCol[1].size() << endl;
        cout << "third layer"  << myGemHitCol[2].size() << endl;
    }
    /*
       for(;it!=mdcMcHitCol->end(); it++)
       {
       Identifier id= (*it)->identify();
       layer = MdcID::layer(id);
       if(layer>7) continue;
       stripIndx = (*it)->getDriftDistance();
       isVStrip  = (*it)->getPositionFlag();
       x = ((*it)->getPositionX())*0.1; // mm->cm
       y = ((*it)->getPositionY())*0.1; // mm->cm
       z = ((*it)->getPositionZ())*0.1; // mm->cm
       r=sqrt(x*x+y*y);
       phi=atan2(y,x);
       cout<<"id, layer , stripIndx, isVSTrip = "<<id<<", "<<layer<<", "<<stripIndx<<", "<<isVStrip<<endl;
    //cout<<"    true   x, y, z, phi, r = "<<x<<", "<<y<<", "<<z<<", "<<phi<<", "<<r<<endl;
    if(myGemHitCol[layer].empty()) 
    {
    //cout<<"myGemHitCol["<<layer<<"] is empty"<<endl;
    phi+=gaussRPhi()/r;
    while(phi>M_PI)  phi-=M_PI2;
    while(phi<-M_PI) phi+=M_PI2;
    z+=gaussZ();
    KalFitGemHit aKalFitGemHit(phi,z,r);
    //cout<<"    resam  x, y, z, phi, r = "<<x<<", "<<y<<", "<<z<<", "<<phi<<", "<<r<<endl;
    myGemHitCol[layer].push_back(aKalFitGemHit);
    }
    }
 
    cout<<endl<<endl<<" ------------- Mdc digi: ------------"<<endl<<endl;
 
    MdcDigiCol::const_iterator it_digi = mdcDigiCol->begin();
    for(;it_digi!=mdcDigiCol->end(); it_digi++)
    {
    Identifier id = (*it_digi)->identify();
    layer = MdcID::layer(id);
    if(layer>7) continue;
    double stripId = RawDataUtil::MdcTime((*it_digi)->getTimeChannel());
    double isV     = RawDataUtil::MdcCharge((*it_digi)->getChargeChannel());
    cout<<"id, layer , stripIndx, isVSTrip = "<<id<<", "<<layer<<", "<<stripId<<", "<<isV<<endl;
    stripIndx=stripId+0.5;
    cout<<"            stripIndx           = "<<id<<", "<<layer<<", "<<stripIndx<<", "<<isV<<endl;
    }
    */ 
 
    // --- print out GEM hits
    bool prtGemHits=false;
    //bool prtGemHits=true;
    if(prtGemHits) cout<<endl<<"------- GEM hits: --------"<<endl;
    for(int i=0; i<3; i++)
    {
        if(prtGemHits) cout<<"###  layer "<<i<<endl;
        //int nhits = myGemHitCol[i].size();
        KalFitGemHitCol::const_iterator it_GemHit = (myGemHitCol[i]).begin();
        for(int j=0; it_GemHit!=(myGemHitCol[i]).end(); it_GemHit++, j++)
        {
            if(prtGemHits) cout<<"     hit "<<(j+1)<<":  phi, z, r = "<<it_GemHit->getPhi()<<", "<<it_GemHit->getZ()<<", "<<it_GemHit->getR()<<endl;
        }
    }
 
}

Referenced by execute().

makeGemHitsCol() [2/2]

void KalFitAlg::makeGemHitsCol

(

)

residual() [1/2]

void KalFitAlg::residual

(

KalFitTrack &

track

)

• 
  

Definition at line 7462 of file KalFitAlg.cxx.

{
 
    //cout<<"R:"<<track.pivot().perp()<<endl;
    SmartDataPtr<Event::EventHeader> eventHeader(eventSvc(),"/Event/EventHeader");
    if (!eventHeader) {
        cout << "Could not find Event Header" << endl;
    }
    int eventNo = eventHeader->eventNumber();
    int runNo = eventHeader->runNumber();
    m_evt=eventNo;
    //cout<<"Event::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::"<<eventNo<<endl;
 
    SmartDataPtr<McParticleCol> mcPartCol(eventSvc(),"/Event/MC/McParticleCol");
    if (!mcPartCol) {
        cout << "Could not find McParticle" << endl;
    }
 
    HepVector mc_a(5,0);
    McParticleCol::iterator i_mcTrk = mcPartCol->begin();
    for (;i_mcTrk != mcPartCol->end(); i_mcTrk++) {
        if(!(*i_mcTrk)->primaryParticle()) continue;
        const HepLorentzVector& mom((*i_mcTrk)->initialFourMomentum());
        const HepLorentzVector& pos = (*i_mcTrk)->initialPosition();
        //cout<<"MCposition:"<<pos.x()<<"  "<<pos.y()<<"  "<<pos.z()<<"  "<<endl;
        double charge = 0.0;
        int pid = (*i_mcTrk)->particleProperty();
        if( pid >0 ) { 
            charge = m_particleTable->particle( pid )->charge();
        } else if ( pid <0 ) {
            charge = m_particleTable->particle( -pid )->charge();
            charge *= -1;
        } else {
        }
        HepPoint3D pos2(pos.x(),pos.y(),pos.z());
        Hep3Vector mom2(mom.px(),mom.py(),mom.pz());
 
        Helix mchelix(pos2, mom2, charge);
        //if( debug_ == 0) cout<< "helix: "<<mchelix.a()<<endl;
        mchelix.pivot( HepPoint3D(0,0,0) );
        for( int j =0; j<5; j++) {
            //m_mchelix[j] = mchelix.a()[j];
            mc_a[j] = mchelix.a()[j];
        }
        //m_mcpid = pid;
        //m_mcptot = sqrt(1+pow(m_mchelix[4],2))/m_mchelix[2];
    }   
    HepPoint3D IP(0,0,0);
    Helix MChelix(IP,mc_a);
    MChelix.pivot(track.pivot());
    m_diff_dr    = track.a()[0]-MChelix.a()[0];
    m_diff_phi0  = track.a()[1]-MChelix.a()[1];
    m_diff_kappa = track.a()[2]-MChelix.a()[2];
    m_diff_dz    = track.a()[3]-MChelix.a()[3];
    m_diff_tanl  = track.a()[4]-MChelix.a()[4];
    if(track.a()[2] != 0 && MChelix.a()[2] != 0)
        m_diff_p = sqrt(1+track.a()[4]*track.a()[4])/track.a()[2] - sqrt(1+MChelix.a()[4]*MChelix.a()[4])/MChelix.a()[2];
    else
        m_diff_p =9999;
    StatusCode sc12 = m_nt12->write();
    if( sc12.isFailure() ) cout<<"Ntuple12 filling failed!"<<endl;
    //cout<<"kalfit a:"<<track.a()<<endl<<"MCtruth a:"<<MChelix.a()<<endl<<endl;
///*    
    // --- calculate the material quantity
    bool printwalls = false;
    if(printwalls){
        double material_quantity(0);
        int size = _BesKalmanFitWalls.size();
        for(int i=0;i<size;i++)
        {
            double ro = _BesKalmanFitWalls[i].radius();
            double ri = _BesKalmanFitWalls[i].rmin();
            double thick = ro-ri;
            KalFitMaterial material = _BesKalmanFitWalls[i].material();
            double X0 = material.X0();
            double rho = material.get_density();
            double Z = material.Z();
            //double X = X0/rho;
            material_quantity += 100*thick/X0;
            cout<<"----------------------------------------------------------------------------------------------------"<<endl;
            cout<<"wall"<<i+1<<"    Z:"<<setw(12)<<Z<<endl;
            cout<<"Ri(cm):"<<setw(12)<<ri<<"Ro(cm):"<<setw(12)<<ro<<"T(cm):"<<setw(12)<<thick<<"X0(cm):"<<setw(12)<<X0<<"T/X0(%)="<<setw(12)<<100*thick/X0<<"accumulation(%):"<<setw(12)<<material_quantity<<endl;
            cout<<"----------------------------------------------------------------------------------------------------"<<endl;
            cout<<endl;
            //cout<<"wall"<<i+1<<"  Z:"<<Z<<"  Thick:"<<thick<<"  Density:"<<rho <<"  X0:"<<X0<<endl;
            //cout<<"radiation length="<<x<<"  material quantity="<<thick/x<<endl;
 
        }
        cout<<"============================================================"<<endl;
        cout<<"total material quantity="<<material_quantity<<endl;
        cout<<"============================================================"<<endl;
    }
//*/
}

Referenced by complete_track().

residual() [2/2]

void KalFitAlg::residual

(

KalFitTrack &

track

)

sameas() [1/2]

void KalFitAlg::sameas	(	RecMdcKalTrack *	trk,
		int	l_mass,
		int	imain
	)

complete the RecMdcKalTrackCol

Definition at line 2431 of file KalFitAlg.cxx.

{
    // note: for this function,only imain==lead(2) considered
    //std::cout<<"BEGINNING THE sameas() function ..."<<std::endl;
    trk->setMass(trk->getMass(imain), l_mass);
    trk->setLength(trk->getLength(imain), l_mass);
    trk->setTof(trk->getTof(imain), l_mass);
    trk->setNhits(trk->getNhits(imain), l_mass);
 
    for(int jj = 0; jj<2; jj++) {
        trk->setStat(trk->getStat(jj,imain), jj, l_mass);
        trk->setChisq(trk->getChisq(jj, l_mass), jj, l_mass);
        trk->setNdf(trk->getChisq(jj, l_mass), jj, l_mass);
    }
    trk->setLHelix(trk->getFHelix(),l_mass);
    trk->setLError(trk->getFError(),l_mass);
}

Referenced by complete_track().

sameas() [2/2]

void KalFitAlg::sameas	(	RecMdcKalTrack *	trk,
		int	l_mass,
		int	imain
	)

complete the RecMdcKalTrackCol

set_Mdc() [1/2]

void KalFitAlg::set_Mdc

(

void

)

Set up the wires, layers and superlayers...

Definition at line 114 of file KalFitAlg2.cxx.

{
   MdcGeomSvc * mdcGeomSvc = dynamic_cast<MdcGeomSvc* >(imdcGeomSvc_);
  if(! mdcGeomSvc) {
       std::cout<<"ERROR OCCUR when dynamic_cast in KalFitAlg2.cxx ..!!"<<std::endl;
   }
 
  if(debug_ == 4)  {
     cout << "KalFitAlg:: MDC initialisation " << std::endl;
   }
  _wire = NULL;
  _layer = NULL; 
  _superLayer = NULL;
 
  const int Nwire = mdcGeomSvc->getWireSize();
  const int Nlyr =  mdcGeomSvc->getLayerSize();
  const int Nsup =  mdcGeomSvc->getSuperLayerSize();
 
  if (!Nwire || !Nlyr || !Nsup){
    cout << ".....MdcGeom Objects are missing !! " << std::endl;
    exit(-1); 
  }
      
  if (!_wire) 
    _wire = (KalFitWire *) malloc((Nwire+1) * sizeof(KalFitWire));
  if (!_layer) 
    _layer = (KalFitLayer_Mdc *) malloc(Nlyr * sizeof(KalFitLayer_Mdc));
  if (!_superLayer) 
    _superLayer = (KalFitSuper_Mdc *) malloc(Nsup * sizeof(KalFitSuper_Mdc));
 
  if (!_wire || !_layer || !_superLayer){  
    std::cerr << "KalFitAlg::Cannot allocate geometries" << std::endl;
    std::cerr << "JOB will stop" << std::endl;
    exit(-1);
  }
   
  int superLayerID = 0;
  int layerID = 0;
  int localLayerID = 0;
  int localWireID = 0; 
  int localID = 0;
  int wireID;
 
  MdcGeoLayer * layer_back = NULL;
  MdcGeoSuper * superLayer_back = NULL;
  int k = 0;
  int Nlayer[12];
  int Nlocal[12];
  int NlocalWireID[43];
 
  for (wireID = 0;wireID <= Nwire; wireID++) {
    MdcGeoLayer * layer = (wireID==Nwire) ? NULL : mdcGeomSvc->Wire(wireID)->Lyr();
    if (layer != layer_back) {
      layer_back = layer;
      MdcGeoSuper * superLayer = (wireID==Nwire) ? NULL : mdcGeomSvc->Layer(layerID)->Sup();
      if (superLayer != superLayer_back) {
        superLayer_back = superLayer;
        Nlayer[k] = localLayerID;
        Nlocal[k] = localID;
        localLayerID = 0;
        k++;
      }
      NlocalWireID[layerID] = localWireID;
      localID = 0;
      localWireID = 0;
      layerID++;
      localLayerID++;
    }
    localID++;
    localWireID++;
  }
 
  superLayerID = -1;
  layerID = -1;
  localLayerID = 0;
  localID = 0;
  layer_back = NULL;
  superLayer_back = NULL;
  for (wireID = 0;wireID < Nwire; wireID++) {
    MdcGeoLayer * layer = (wireID==Nwire) ? 
                          NULL : mdcGeomSvc->Wire(wireID)->Lyr();
    if (layer != layer_back){
      layer_back = layer;
      MdcGeoSuper * superLayer = (wireID==Nwire) ? 
                                 NULL : mdcGeomSvc->Layer(layerID+1)->Sup();
      if (superLayer != superLayer_back){
        superLayer_back = superLayer;
        // initialize super-layer
        superLayerID++;
        new(_superLayer+superLayerID) KalFitSuper_Mdc(wireID,
                                                   Nlocal[superLayerID+1],
                                                   layerID+1,
                                                   Nlayer[superLayerID+1],
                                                   superLayerID);
        localLayerID=0;
      }
      // initialize layer
      layerID++;
      double slantWithSymbol = (mdcGeomSvc->Layer(layerID)->Slant())
                              *(mdcGeomSvc->Layer(layerID)->Sup()->Type());
      new(_layer+layerID) KalFitLayer_Mdc(_superLayer[superLayerID],
                                  0.1*layer->Radius(), (layer->Slant())*(layer->Sup()->Type()),
                                  0.1*(layer->Length()/2), 
                                  0.1*(-layer->Length()/2), layer->Offset(),
                  layerID, localLayerID++ );
      localID = 0;
    }
    // initialize wire
 
    const MdcGeoWire * wire = (wireID==Nwire) ? NULL : mdcGeomSvc->Wire(wireID); 
    HepPoint3D fwd(0.1*wire->Backward());
    HepPoint3D bck(0.1*wire->Forward());
 
    if (superLayerID == 2 || superLayerID == 3  ||
        superLayerID == 4 || superLayerID == 9 ||
        superLayerID == 10) {     // axial wire
      new(_wire+wireID) KalFitWire(localID++,_layer[layerID],
                   fwd,bck, _wire+Nwire,wire->Id(),0);
                  
    } else {                      // stereo wire
      new(_wire+wireID) KalFitWire(localID++,_layer[layerID],
                   fwd,bck, _wire+Nwire,wire->Id(),1);
    }
  }
 
  // make virtual wire object for the pointer of boundary's neighbor
  new(_wire+Nwire) KalFitWire();
 
  if (debug_ == 4) cout << "MDC geometry reading done" << std::endl;  
 
  return;
}

Referenced by beginRun().

set_Mdc() [2/2]

void KalFitAlg::set_Mdc

(

void

)

Set up the wires, layers and superlayers...

setBesFromGdml() [1/2]

void KalFitAlg::setBesFromGdml

(

void

)

— mdcgas

— CarbonFiber, Separator between ODC and Cgem

— Anode Kapton4

— Anode Cu3

— Anode Epoxy5

— Anode Rohacell2

— Anode Epoxy4

— Anode Kapton3

— Anode Epoxy3

— Anode Rohacell1

— Anode Epoxy2

— Anode Kapton2

—Anode Epoxy1

— Anode Cu2

— Anode Kapton1

— Anode Cu1

— Gap I

============================ Gem Foil2============================

— Foil Cu2

— Foil Kapton

— Foil Cu1

— Gap T2

— Foil Cu2

— Foil Kapton

— Foil Cu1

— Gap T1

— Foil Cu2

— Foil Kapton

— Foil Cu1

— Gap D

— Cathode

— Cathode Cu

— Cathode Kapton3

— Cathode Epoxy4

— Cathode Rohacell2

— Cathode Epoxy3

—Cathode Kapton2

— Cathode Epoxy2

— Cathode Rohacell1

— Cathode Epoxy1

— Cathode Kapton1

—air

air

outer beryllium pipe

cooling oil

inner beryllium pipe

gold

now construct the cylinders

Separator

shield kapton2

shield honeycomb

shield kapton1

Anode Kapton4

Anode Au2

Anode Cu3

Anode Epoxy5

Anode Rohacell2

Anode Epoxy4

Anode Kapton3

Anode Epoxy3

Anode Rohacell1

Anode Epoxy2

Anode Kapton2

Anode Epoxy1

Anode Cu2

Anode Cu1

Anode Au1

GAP I

Foil Gem2 Cu2

Kapton

Cu1

Gap T2

outer air, be attention the calculation of the radius and thick of the air cylinder is special

outer Beryllium layer

oil layer

inner Beryllium layer

gold layer

Definition at line 12 of file KalFitReadGdml.cxx.

                                  {
 
    int i(0);
    double Z(0.),A(0.),Ionization(0.),Density(0.),Radlen(0.);
 
    G4LogicalVolume *logicalMdc = 0;
    MdcG4Geo* aMdcG4Geo = new MdcG4Geo();
    logicalMdc = aMdcG4Geo->GetTopVolume();   
 
    ///--- mdcgas
    G4Material* mdcMaterial = logicalMdc->GetMaterial();  
    for(i=0; i<mdcMaterial->GetElementVector()->size(); i++){
        Z += (mdcMaterial->GetElement(i)->GetZ())*
            (mdcMaterial->GetFractionVector()[i]);
        A += (mdcMaterial->GetElement(i)->GetA())*
            (mdcMaterial->GetFractionVector()[i]);
    }
    Ionization = mdcMaterial->GetIonisation()->GetMeanExcitationEnergy();
    Density = mdcMaterial->GetDensity()/(g/cm3);
    Radlen = mdcMaterial->GetRadlen();
    cout<<"mdcgas: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
    KalFitMaterial FitMdcMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.); 
    _BesKalmanFitMaterials.push_back(FitMdcMaterial);
    KalFitTrack::mdcGasRadlen_ = Radlen/10.;
    cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 /* 
    ///--- inner wall shield fiml1 Al by wangll 2012-09-07
    G4LogicalVolume* innerWallFilm1Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume("LogicalMdcInnerFilm1"));
    G4Material* innerWallFilm1Material = innerWallFilm1Volume->GetMaterial();
    G4Tubs* innerwallFilm1Tub = dynamic_cast<G4Tubs*>(innerWallFilm1Volume->GetSolid());
 
    Z = 0.;
    A = 0.;
    for(i=0; i<innerWallFilm1Material->GetElementVector()->size(); i++){    
        Z += (innerWallFilm1Material->GetElement(i)->GetZ())*
            (innerWallFilm1Material->GetFractionVector()[i]); 
        A += (innerWallFilm1Material->GetElement(i)->GetA())*   
            (innerWallFilm1Material->GetFractionVector()[i]);
    }
 
    Ionization = innerWallFilm1Material->GetIonisation()->GetMeanExcitationEnergy();
    Density = innerWallFilm1Material->GetDensity()/(g/cm3);
    Radlen = innerWallFilm1Material->GetRadlen();
    std::cout<<"Mdc innerwall Film1, Al: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<std::endl;
    KalFitMaterial FitInnerwallFilm1Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
    _BesKalmanFitMaterials.push_back(FitInnerwallFilm1Material);
 
 
    ///--- inner wall CarbonFiber by wll 2012-09-06
    G4LogicalVolume* innerwallVolume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume("logicalMdcSegment2"));
    G4Material* innerwallMaterial = innerwallVolume->GetMaterial();
    G4Tubs* innerwallTub = dynamic_cast<G4Tubs*>(innerwallVolume->GetSolid());
 
    Z = 0.;
    A = 0.;
    for(i=0; i<innerwallMaterial->GetElementVector()->size(); i++){    
        Z += (innerwallMaterial->GetElement(i)->GetZ())*
            (innerwallMaterial->GetFractionVector()[i]); 
        A += (innerwallMaterial->GetElement(i)->GetA())*    
            (innerwallMaterial->GetFractionVector()[i]);
    }
 
    Ionization = innerwallMaterial->GetIonisation()->GetMeanExcitationEnergy();
    Density = innerwallMaterial->GetDensity()/(g/cm3);
    Radlen = innerwallMaterial->GetRadlen();
    cout<<"Mdc innerwall, Al: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
    KalFitMaterial FitInnerwallMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
    _BesKalmanFitMaterials.push_back(FitInnerwallMaterial);
 
    ///--- inner wall shield film0 Al by wangll 2012-09-07
    G4LogicalVolume* innerWallFilm0Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume("LogicalMdcInnerFilm0"));
    G4Material* innerWallFilm0Material = innerWallFilm0Volume->GetMaterial();
    G4Tubs* innerwallFilm0Tub = dynamic_cast<G4Tubs*>(innerWallFilm0Volume->GetSolid());
 
    Z = 0.;
    A = 0.;
    for(i=0; i<innerWallFilm0Material->GetElementVector()->size(); i++){    
        Z += (innerWallFilm0Material->GetElement(i)->GetZ())*
            (innerWallFilm0Material->GetFractionVector()[i]); 
        A += (innerWallFilm0Material->GetElement(i)->GetA())*   
            (innerWallFilm0Material->GetFractionVector()[i]);
    }
 
    Ionization = innerWallFilm0Material->GetIonisation()->GetMeanExcitationEnergy();
    Density = innerWallFilm0Material->GetDensity()/(g/cm3);
    Radlen = innerWallFilm0Material->GetRadlen();
    std::cout<<"Mdc innerwall Film0, Al: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<std::endl;
    KalFitMaterial FitInnerwallFilm0Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
    _BesKalmanFitMaterials.push_back(FitInnerwallFilm0Material);
    
*/
    //////////////////////////////////////////////////////////////////////////////////////////////////
    G4LogicalVolume *logicalCgem = 0;
    CgemG4Geo* aCgemG4Geo = new CgemG4Geo();
    logicalCgem = aCgemG4Geo->GetTopVolume();
 
    ///--- CarbonFiber, Separator between ODC and Cgem 
    G4LogicalVolume* SeparatorVolume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume("Separator_logic"));
    G4Material* SeparatorMaterial = SeparatorVolume->GetMaterial();
    G4Tubs* SeparatorTub = dynamic_cast<G4Tubs*>(SeparatorVolume->GetSolid());
 
    Z = 0.;
    A = 0.;
    for(i=0; i<SeparatorMaterial->GetElementVector()->size(); i++){    
        Z += (SeparatorMaterial->GetElement(i)->GetZ())*
            (SeparatorMaterial->GetFractionVector()[i]); 
        A += (SeparatorMaterial->GetElement(i)->GetA())*    
            (SeparatorMaterial->GetFractionVector()[i]);
    }
 
    Ionization = SeparatorMaterial->GetIonisation()->GetMeanExcitationEnergy();
    Density = SeparatorMaterial->GetDensity()/(g/cm3);
    Radlen = SeparatorMaterial->GetRadlen();
    cout<<"Separator: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
    KalFitMaterial FitSeparatorMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
    _BesKalmanFitMaterials.push_back(FitSeparatorMaterial);
    cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
    int nCgemLayer = 3;
    //G4Tubs* SK2Tub[3];
    //G4Tubs* HCTub[3];
    //G4Tubs* SK1Tub[3];
    //G4Tubs* AA2Tub[3];
    G4Tubs* AK4Tub[3];
    G4Tubs* AC3Tub[3];
    G4Tubs* AE5Tub[3];
    G4Tubs* AR2Tub[3];
    G4Tubs* AE4Tub[3];
    G4Tubs* AK3Tub[3];
    G4Tubs* AE3Tub[3];
    G4Tubs* AR1Tub[3];
    G4Tubs* AE2Tub[3];
    G4Tubs* AK2Tub[3];
    G4Tubs* AE1Tub[3];
    G4Tubs* AC2Tub[3];
    G4Tubs* AK1Tub[3];
    G4Tubs* AC1Tub[3];
    //G4Tubs* AA1Tub[3];
    
    G4Tubs* GAPITub[3];
 
    G4Tubs* FC22Tub[3];
    G4Tubs* FK2Tub[3];
    G4Tubs* FC12Tub[3];
 
    G4Tubs* GAPT2Tub[3];
    
    G4Tubs* FC21Tub[3];
    G4Tubs* FK1Tub[3];
    G4Tubs* FC11Tub[3];
    
    G4Tubs* GAPT1Tub[3];
 
    G4Tubs* FC20Tub[3];
    G4Tubs* FK0Tub[3];
    G4Tubs* FC10Tub[3];
    
    G4Tubs* GAPDTub[3];
    
    //G4Tubs* C2Tub[3];
    G4Tubs* CCuTub[3];
    G4Tubs* CK3Tub[3];
    G4Tubs* CE4Tub[3];
    G4Tubs* CR2Tub[3];
    G4Tubs* CE3Tub[3];
    G4Tubs* CK2Tub[3];
    G4Tubs* CE2Tub[3];
    G4Tubs* CR1Tub[3];
    G4Tubs* CE1Tub[3];
    //G4Tubs* CHTub[3];
    //G4Tubs* CC1Tub[3];
    G4Tubs* CK1Tub[3];
   
    stringstream ss;
    string s; 
    for(int j=2;j>=0;j--){
    /*
        ///--- shield kapton2
        ss.str("");
        ss << "Shield_Kapton2_logic" << j ;
        s = ss.str();
        G4LogicalVolume* logicalSK2Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
        G4Material* SK2Material = logicalSK2Volume->GetMaterial();
         SK2Tub[j] = dynamic_cast<G4Tubs*>(logicalSK2Volume->GetSolid());
         cout << logicalSK2Volume->GetSolid()->GetName() << endl; 
        Z = 0.;
        A = 0.;
        for(i=0; i<SK2Material->GetElementVector()->size(); i++){
            Z += (SK2Material->GetElement(i)->GetZ())*
                (SK2Material->GetFractionVector()[i]);
            A += (SK2Material->GetElement(i)->GetA())*
                (SK2Material->GetFractionVector()[i]);
        }
        Ionization = SK2Material->GetIonisation()->GetMeanExcitationEnergy();
        Density = SK2Material->GetDensity()/(g/cm3);
        Radlen = SK2Material->GetRadlen();
        cout<<"SK2: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
   
        KalFitMaterial FitSK2Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
 
        _BesKalmanFitMaterials.push_back(FitSK2Material);
        cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
    */
    /*
        ///--- shield honeycomb
        ss.str("");
        ss << "Shield_Honeycomb_logic" << j ;
        s = ss.str();
        cout << s << endl;
        G4LogicalVolume* logicalHCVolume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
        G4Material* HCMaterial = logicalHCVolume->GetMaterial();
         HCTub[j] = dynamic_cast<G4Tubs*>(logicalHCVolume->GetSolid());
         cout << logicalHCVolume->GetSolid()->GetName() << endl; 
        Z = 0.;
        A = 0.;
        for(i=0; i<HCMaterial->GetElementVector()->size(); i++){
            Z += (HCMaterial->GetElement(i)->GetZ())*
                (HCMaterial->GetFractionVector()[i]);
            A += (HCMaterial->GetElement(i)->GetA())*
                (HCMaterial->GetFractionVector()[i]);
        }
        Ionization = HCMaterial->GetIonisation()->GetMeanExcitationEnergy();
        Density = HCMaterial->GetDensity()/(g/cm3);
        Radlen = HCMaterial->GetRadlen();
        cout<<"HC: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
        KalFitMaterial FitHCMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
        _BesKalmanFitMaterials.push_back(FitHCMaterial);
        cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
    */
    /*
        ///--- shield kapton1
        ss.str("");
        ss << "Shield_Kapton1_logic" << j ;
        s = ss.str();
        G4LogicalVolume* logicalSK1Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
        G4Material* SK1Material = logicalSK1Volume->GetMaterial();
         SK1Tub[j] = dynamic_cast<G4Tubs*>(logicalSK1Volume->GetSolid());
         cout << logicalSK1Volume->GetSolid()->GetName() << endl; 
 
        Z = 0.;
        A = 0.;
        for(i=0; i<SK1Material->GetElementVector()->size(); i++){
            Z += (SK1Material->GetElement(i)->GetZ())*
                (SK1Material->GetFractionVector()[i]);
            A += (SK1Material->GetElement(i)->GetA())*
                (SK1Material->GetFractionVector()[i]);
         }
         Ionization = SK1Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = SK1Material->GetDensity()/(g/cm3);
         Radlen = SK1Material->GetRadlen();
         cout<<"SK1: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitSK1Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitSK1Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
    */
        ///--- Anode Kapton4
        ss.str("");
        ss << "Anode_Kapton4_logic" << j ;
        s = ss.str();
        G4LogicalVolume* logicalAK4Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
        G4Material* AK4Material = logicalAK4Volume->GetMaterial();
         AK4Tub[j] = dynamic_cast<G4Tubs*>(logicalAK4Volume->GetSolid());
         //cout << logicalAK4Volume->GetSolid()->GetName() << endl; 
 
        Z = 0.;
        A = 0.;
        for(i=0; i<AK4Material->GetElementVector()->size(); i++){
            Z += (AK4Material->GetElement(i)->GetZ())*
                (AK4Material->GetFractionVector()[i]);
            A += (AK4Material->GetElement(i)->GetA())*
                (AK4Material->GetFractionVector()[i]);
         }
         Ionization = AK4Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = AK4Material->GetDensity()/(g/cm3);
         Radlen = AK4Material->GetRadlen();
         cout<<"AK4: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitAK4Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitAK4Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
    /*
         ///--- Anode Au2
        ss.str("");
        ss << "Anode_Au2_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalAA2Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* AA2Material = logicalAA2Volume->GetMaterial();
          AA2Tub[j] = dynamic_cast<G4Tubs*>(logicalAA2Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<AA2Material->GetElementVector()->size(); i++){
             Z += (AA2Material->GetElement(i)->GetZ())*
                 (AA2Material->GetFractionVector()[i]);
             A += (AA2Material->GetElement(i)->GetA())*
                 (AA2Material->GetFractionVector()[i]);
         }
         Ionization = AA2Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = AA2Material->GetDensity()/(g/cm3);
         Radlen = AA2Material->GetRadlen();
         cout<<"AA2: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitAA2Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitAA2Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
    */
        ///--- Anode Cu3
        ss.str("");
        ss << "Anode_Cu3_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalAC3Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* AC3Material = logicalAC3Volume->GetMaterial();
          AC3Tub[j] = dynamic_cast<G4Tubs*>(logicalAC3Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<AC3Material->GetElementVector()->size(); i++){
             Z += (AC3Material->GetElement(i)->GetZ())*
                 (AC3Material->GetFractionVector()[i]);
             A += (AC3Material->GetElement(i)->GetA())*
                 (AC3Material->GetFractionVector()[i]);
         }
         Ionization = AC3Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = AC3Material->GetDensity()/(g/cm3);
         Radlen = AC3Material->GetRadlen();
         cout<<"AC3: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitAC3Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitAC3Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///--- Anode Epoxy5
        ss.str("");
        ss << "Anode_Epoxy5_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalAE5Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* AE5Material = logicalAE5Volume->GetMaterial();
          AE5Tub[j] = dynamic_cast<G4Tubs*>(logicalAE5Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<AE5Material->GetElementVector()->size(); i++){
             Z += (AE5Material->GetElement(i)->GetZ())*
                 (AE5Material->GetFractionVector()[i]);
             A += (AE5Material->GetElement(i)->GetA())*
                 (AE5Material->GetFractionVector()[i]);
         }
         Ionization = AE5Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = AE5Material->GetDensity()/(g/cm3);
         Radlen = AE5Material->GetRadlen();
         cout<<"AE5: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitAE5Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitAE5Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
   
        ///--- Anode Rohacell2 
        ss.str("");
        ss << "Anode_Rohacell2_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalAR2Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* AR2Material = logicalAR2Volume->GetMaterial();
          AR2Tub[j] = dynamic_cast<G4Tubs*>(logicalAR2Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<AR2Material->GetElementVector()->size(); i++){
             Z += (AR2Material->GetElement(i)->GetZ())*
                 (AR2Material->GetFractionVector()[i]);
             A += (AR2Material->GetElement(i)->GetA())*
                 (AR2Material->GetFractionVector()[i]);
         }
         Ionization = AR2Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = AR2Material->GetDensity()/(g/cm3);
         Radlen = AR2Material->GetRadlen();
         cout<<"AR2: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitAR2Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitAR2Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///--- Anode Epoxy4
        ss.str("");
        ss << "Anode_Epoxy4_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalAE4Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* AE4Material = logicalAE4Volume->GetMaterial();
          AE4Tub[j] = dynamic_cast<G4Tubs*>(logicalAE4Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<AE4Material->GetElementVector()->size(); i++){
             Z += (AE4Material->GetElement(i)->GetZ())*
                 (AE4Material->GetFractionVector()[i]);
             A += (AE4Material->GetElement(i)->GetA())*
                 (AE4Material->GetFractionVector()[i]);
         }
         Ionization = AE4Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = AE4Material->GetDensity()/(g/cm3);
         Radlen = AE4Material->GetRadlen();
         cout<<"AE4: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitAE4Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitAE4Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
   
        ///--- Anode Kapton3
        ss.str("");
        ss << "Anode_Kapton3_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalAK3Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* AK3Material = logicalAK3Volume->GetMaterial();
          AK3Tub[j] = dynamic_cast<G4Tubs*>(logicalAK3Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<AK3Material->GetElementVector()->size(); i++){
             Z += (AK3Material->GetElement(i)->GetZ())*
                 (AK3Material->GetFractionVector()[i]);
             A += (AK3Material->GetElement(i)->GetA())*
                 (AK3Material->GetFractionVector()[i]);
         }
         Ionization = AK3Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = AK3Material->GetDensity()/(g/cm3);
         Radlen = AK3Material->GetRadlen();
         cout<<"AK3: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitAK3Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitAK3Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///--- Anode Epoxy3
        ss.str("");
        ss << "Anode_Epoxy3_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalAE3Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* AE3Material = logicalAE3Volume->GetMaterial();
          AE3Tub[j] = dynamic_cast<G4Tubs*>(logicalAE3Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<AE3Material->GetElementVector()->size(); i++){
             Z += (AE3Material->GetElement(i)->GetZ())*
                 (AE3Material->GetFractionVector()[i]);
             A += (AE3Material->GetElement(i)->GetA())*
                 (AE3Material->GetFractionVector()[i]);
         }
         Ionization = AE3Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = AE3Material->GetDensity()/(g/cm3);
         Radlen = AE3Material->GetRadlen();
         cout<<"AE3: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitAE3Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitAE3Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
   
        ///--- Anode Rohacell1 
        ss.str("");
        ss << "Anode_Rohacell1_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalAR1Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* AR1Material = logicalAR1Volume->GetMaterial();
          AR1Tub[j] = dynamic_cast<G4Tubs*>(logicalAR1Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<AR1Material->GetElementVector()->size(); i++){
             Z += (AR1Material->GetElement(i)->GetZ())*
                 (AR1Material->GetFractionVector()[i]);
             A += (AR1Material->GetElement(i)->GetA())*
                 (AR1Material->GetFractionVector()[i]);
         }
         Ionization = AR1Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = AR1Material->GetDensity()/(g/cm3);
         Radlen = AR1Material->GetRadlen();
         cout<<"AR1: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitAR1Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitAR1Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///--- Anode Epoxy2
        ss.str("");
        ss << "Anode_Epoxy2_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalAE2Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* AE2Material = logicalAE2Volume->GetMaterial();
          AE2Tub[j] = dynamic_cast<G4Tubs*>(logicalAE2Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<AE2Material->GetElementVector()->size(); i++){
             Z += (AE2Material->GetElement(i)->GetZ())*
                 (AE2Material->GetFractionVector()[i]);
             A += (AE2Material->GetElement(i)->GetA())*
                 (AE2Material->GetFractionVector()[i]);
         }
         Ionization = AE2Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = AE2Material->GetDensity()/(g/cm3);
         Radlen = AE2Material->GetRadlen();
         cout<<"AE2: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitAE2Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitAE2Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///--- Anode Kapton2
        ss.str("");
        ss << "Anode_Kapton2_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalAK2Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* AK2Material = logicalAK2Volume->GetMaterial();
          AK2Tub[j] = dynamic_cast<G4Tubs*>(logicalAK2Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<AK2Material->GetElementVector()->size(); i++){
             Z += (AK2Material->GetElement(i)->GetZ())*
                 (AK2Material->GetFractionVector()[i]);
             A += (AK2Material->GetElement(i)->GetA())*
                 (AK2Material->GetFractionVector()[i]);
         }
         Ionization = AK2Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = AK2Material->GetDensity()/(g/cm3);
         Radlen = AK2Material->GetRadlen();
         cout<<"AK2: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitAK2Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitAK2Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///---Anode Epoxy1
        ss.str("");
        ss << "Anode_Epoxy1_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalAE1Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* AE1Material = logicalAE1Volume->GetMaterial();
          AE1Tub[j] = dynamic_cast<G4Tubs*>(logicalAE1Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<AE1Material->GetElementVector()->size(); i++){
             Z += (AE1Material->GetElement(i)->GetZ())*
                 (AE1Material->GetFractionVector()[i]);
             A += (AE1Material->GetElement(i)->GetA())*
                 (AE1Material->GetFractionVector()[i]);
         }
         Ionization = AE1Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = AE1Material->GetDensity()/(g/cm3);
         Radlen = AE1Material->GetRadlen();
         cout<<"AE1: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitAE1Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitAE1Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///--- Anode Cu2
        ss.str("");
        ss << "Anode_Cu2_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalAC2Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* AC2Material = logicalAC2Volume->GetMaterial();
          AC2Tub[j] = dynamic_cast<G4Tubs*>(logicalAC2Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<AC2Material->GetElementVector()->size(); i++){
             Z += (AC2Material->GetElement(i)->GetZ())*
                 (AC2Material->GetFractionVector()[i]);
             A += (AC2Material->GetElement(i)->GetA())*
                 (AC2Material->GetFractionVector()[i]);
         }
         Ionization = AC2Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = AC2Material->GetDensity()/(g/cm3);
         Radlen = AC2Material->GetRadlen();
         cout<<"AC2: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitAC2Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitAC2Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///--- Anode Kapton1
        ss.str("");
        ss << "Anode_Kapton1_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalAK1Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* AK1Material = logicalAK1Volume->GetMaterial();
          AK1Tub[j] = dynamic_cast<G4Tubs*>(logicalAK1Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<AK1Material->GetElementVector()->size(); i++){
             Z += (AK1Material->GetElement(i)->GetZ())*
                 (AK1Material->GetFractionVector()[i]);
             A += (AK1Material->GetElement(i)->GetA())*
                 (AK1Material->GetFractionVector()[i]);
         }
         Ionization = AK1Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = AK1Material->GetDensity()/(g/cm3);
         Radlen = AK1Material->GetRadlen();
         cout<<"AK1: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitAK1Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitAK1Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///--- Anode Cu1
        ss.str("");
        ss << "Anode_Cu1_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalAC1Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* AC1Material = logicalAC1Volume->GetMaterial();
          AC1Tub[j] = dynamic_cast<G4Tubs*>(logicalAC1Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<AC1Material->GetElementVector()->size(); i++){
             Z += (AC1Material->GetElement(i)->GetZ())*
                 (AC1Material->GetFractionVector()[i]);
             A += (AC1Material->GetElement(i)->GetA())*
                 (AC1Material->GetFractionVector()[i]);
         }
         Ionization = AC1Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = AC1Material->GetDensity()/(g/cm3);
         Radlen = AC1Material->GetRadlen();
         cout<<"AC1: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitAC1Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitAC1Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
    /*
         ///--- Anode Au1
        ss.str("");
        ss << "Anode_Au1_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalAA1Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* AA1Material = logicalAA1Volume->GetMaterial();
          AA1Tub[j] = dynamic_cast<G4Tubs*>(logicalAA1Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<AA1Material->GetElementVector()->size(); i++){
             Z += (AA1Material->GetElement(i)->GetZ())*
                 (AA1Material->GetFractionVector()[i]);
             A += (AA1Material->GetElement(i)->GetA())*
                 (AA1Material->GetFractionVector()[i]);
         }
         Ionization = AA1Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = AA1Material->GetDensity()/(g/cm3);
         Radlen = AA1Material->GetRadlen();
         cout<<"AA1: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitAA1Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitAA1Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
    */     
        ///--- Gap I
        ss.str("");
        ss << "Gap_I_logic" << j;
        s = ss.str();
         G4LogicalVolume* logicalGAPIVolume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* GAPIMaterial = logicalGAPIVolume->GetMaterial();
          GAPITub[j] = dynamic_cast<G4Tubs*>(logicalGAPIVolume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<GAPIMaterial->GetElementVector()->size(); i++){
             Z += (GAPIMaterial->GetElement(i)->GetZ())*
                 (GAPIMaterial->GetFractionVector()[i]);
             A += (GAPIMaterial->GetElement(i)->GetA())*
                 (GAPIMaterial->GetFractionVector()[i]);
         }
         Ionization = GAPIMaterial->GetIonisation()->GetMeanExcitationEnergy();
         Density = GAPIMaterial->GetDensity()/(g/cm3);
         Radlen = GAPIMaterial->GetRadlen();
         cout<<"GAPI: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitGAPIMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitGAPIMaterial);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
            
         ///============================ Gem Foil2============================
 
        ///--- Foil Cu2
        ss.str("");
        ss << "GemFoil_Cu2_logic" << j << "foil2" ;
        s = ss.str();
         G4LogicalVolume* logicalFC22Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* FC22Material = logicalFC22Volume->GetMaterial();
          FC22Tub[j] = dynamic_cast<G4Tubs*>(logicalFC22Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<FC22Material->GetElementVector()->size(); i++){
            Z += (FC22Material->GetElement(i)->GetZ())*
                (FC22Material->GetFractionVector()[i]);
            A += (FC22Material->GetElement(i)->GetA())*
                (FC22Material->GetFractionVector()[i]);
          }
          Ionization = FC22Material->GetIonisation()->GetMeanExcitationEnergy();
          Density = FC22Material->GetDensity()/(g/cm3);
          Radlen = FC22Material->GetRadlen();
          cout<<"FC22: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
          KalFitMaterial FitFC22Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
          _BesKalmanFitMaterials.push_back(FitFC22Material);
          cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///--- Foil Kapton
        ss.str("");
        ss << "GemFoil_Kapton_logic" << j << "foil2" ;
        s = ss.str();
          G4LogicalVolume* logicalFK2Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
          G4Material* FK2Material = logicalFK2Volume->GetMaterial();
           FK2Tub[j] = dynamic_cast<G4Tubs*>(logicalFK2Volume->GetSolid());
          Z = 0.;
          A = 0.;
          for(i=0; i<FK2Material->GetElementVector()->size(); i++){
             Z += (FK2Material->GetElement(i)->GetZ())*
                 (FK2Material->GetFractionVector()[i]);
             A += (FK2Material->GetElement(i)->GetA())*
                 (FK2Material->GetFractionVector()[i]);
          }
          Ionization = FK2Material->GetIonisation()->GetMeanExcitationEnergy();
          Density = FK2Material->GetDensity()/(g/cm3);
          Radlen = FK2Material->GetRadlen();
          cout<<"FK2: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
          KalFitMaterial FitFK2Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
          _BesKalmanFitMaterials.push_back(FitFK2Material);
          cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///--- Foil Cu1
        ss.str("");
        ss << "GemFoil_Cu1_logic" << j << "foil2" ;
        s = ss.str();
          G4LogicalVolume* logicalFC12Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
          G4Material* FC12Material = logicalFC12Volume->GetMaterial();
           FC12Tub[j] = dynamic_cast<G4Tubs*>(logicalFC12Volume->GetSolid());
          Z = 0.;
          A = 0.;
          for(i=0; i<FC12Material->GetElementVector()->size(); i++){
             Z += (FC12Material->GetElement(i)->GetZ())*
                 (FC12Material->GetFractionVector()[i]);
             A += (FC12Material->GetElement(i)->GetA())*
                 (FC12Material->GetFractionVector()[i]);
          }
          Ionization = FC12Material->GetIonisation()->GetMeanExcitationEnergy();
          Density = FC12Material->GetDensity()/(g/cm3);
          Radlen = FC12Material->GetRadlen();
          cout<<"FC12: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
          KalFitMaterial FitFC12Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
          _BesKalmanFitMaterials.push_back(FitFC12Material);
          cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///--- Gap T2
        ss.str("");
        ss << "Gap_T2_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalGAPT2Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* GAPT2Material = logicalGAPT2Volume->GetMaterial();
          GAPT2Tub[j] = dynamic_cast<G4Tubs*>(logicalGAPT2Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<GAPT2Material->GetElementVector()->size(); i++){
             Z += (GAPT2Material->GetElement(i)->GetZ())*
                 (GAPT2Material->GetFractionVector()[i]);
             A += (GAPT2Material->GetElement(i)->GetA())*
                 (GAPT2Material->GetFractionVector()[i]);
         }
         Ionization = GAPT2Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = GAPT2Material->GetDensity()/(g/cm3);
         Radlen = GAPT2Material->GetRadlen();
         cout<<"GAPT2: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitGAPT2Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitGAPT2Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
         //======================================== Gem Foil1=========================================
        ///--- Foil Cu2
        ss.str("");
        ss << "GemFoil_Cu2_logic" << j << "foil1" ;
        s = ss.str();
         G4LogicalVolume* logicalFC21Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* FC21Material = logicalFC21Volume->GetMaterial();
          FC21Tub[j] = dynamic_cast<G4Tubs*>(logicalFC21Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<FC21Material->GetElementVector()->size(); i++){
            Z += (FC21Material->GetElement(i)->GetZ())*
                (FC21Material->GetFractionVector()[i]);
            A += (FC21Material->GetElement(i)->GetA())*
                (FC21Material->GetFractionVector()[i]);
         }
         Ionization = FC21Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = FC21Material->GetDensity()/(g/cm3);
         Radlen = FC21Material->GetRadlen();
         cout<<"FC21: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitFC21Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitFC21Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///--- Foil Kapton
        ss.str("");
        ss << "GemFoil_Kapton_logic" << j << "foil1" ;
        s = ss.str();
         G4LogicalVolume* logicalFK1Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* FK1Material = logicalFK1Volume->GetMaterial();
          FK1Tub[j] = dynamic_cast<G4Tubs*>(logicalFK1Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<FK1Material->GetElementVector()->size(); i++){
            Z += (FK1Material->GetElement(i)->GetZ())*
                (FK1Material->GetFractionVector()[i]);
            A += (FK1Material->GetElement(i)->GetA())*
                (FK1Material->GetFractionVector()[i]);
         }
         Ionization = FK1Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = FK1Material->GetDensity()/(g/cm3);
         Radlen = FK1Material->GetRadlen();
         cout<<"FK1: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitFK1Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitFK1Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
         
        ///--- Foil Cu1
        ss.str("");
        ss << "GemFoil_Cu1_logic" << j << "foil1" ;
        s = ss.str();
         G4LogicalVolume* logicalFC11Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* FC11Material = logicalFC11Volume->GetMaterial();
          FC11Tub[j] = dynamic_cast<G4Tubs*>(logicalFC11Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<FC11Material->GetElementVector()->size(); i++){
            Z += (FC11Material->GetElement(i)->GetZ())*
                (FC11Material->GetFractionVector()[i]);
            A += (FC11Material->GetElement(i)->GetA())*
                (FC11Material->GetFractionVector()[i]);
         }
         Ionization = FC11Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = FC11Material->GetDensity()/(g/cm3);
         Radlen = FC11Material->GetRadlen();
         cout<<"FC11: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitFC11Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitFC11Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
         
        ///--- Gap T1
        ss.str("");
        ss << "Gap_T1_logic" << j  ;
        s = ss.str();
         G4LogicalVolume* logicalGAPT1Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* GAPT1Material = logicalGAPT1Volume->GetMaterial();
          GAPT1Tub[j] = dynamic_cast<G4Tubs*>(logicalGAPT1Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<GAPT1Material->GetElementVector()->size(); i++){
            Z += (GAPT1Material->GetElement(i)->GetZ())*
                (GAPT1Material->GetFractionVector()[i]);
            A += (GAPT1Material->GetElement(i)->GetA())*
                (GAPT1Material->GetFractionVector()[i]);
         }
         Ionization = GAPT1Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = GAPT1Material->GetDensity()/(g/cm3);
         Radlen = GAPT1Material->GetRadlen();
         cout<<"GAPT1: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitGAPT1Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitGAPT1Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
         //============================ Gem Foil0================================
        ///--- Foil Cu2
        ss.str("");
        ss << "GemFoil_Cu2_logic" << j << "foil0" ;
        s = ss.str();
         G4LogicalVolume* logicalFC20Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* FC20Material = logicalFC20Volume->GetMaterial();
          FC20Tub[j] = dynamic_cast<G4Tubs*>(logicalFC20Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<FC20Material->GetElementVector()->size(); i++){
            Z += (FC20Material->GetElement(i)->GetZ())*
                (FC20Material->GetFractionVector()[i]);
            A += (FC20Material->GetElement(i)->GetA())*
                (FC20Material->GetFractionVector()[i]);
         }
         Ionization = FC20Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = FC20Material->GetDensity()/(g/cm3);
         Radlen = FC20Material->GetRadlen();
         cout<<"FC20: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitFC20Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitFC20Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
         
        ///--- Foil Kapton
        ss.str("");
        ss << "GemFoil_Kapton_logic" << j << "foil0" ;
        s = ss.str();
         G4LogicalVolume* logicalFK0Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* FK0Material = logicalFK0Volume->GetMaterial();
          FK0Tub[j] = dynamic_cast<G4Tubs*>(logicalFK0Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<FK0Material->GetElementVector()->size(); i++){
            Z += (FK0Material->GetElement(i)->GetZ())*
                (FK0Material->GetFractionVector()[i]);
            A += (FK0Material->GetElement(i)->GetA())*
                (FK0Material->GetFractionVector()[i]);
         }
         Ionization = FK0Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = FK0Material->GetDensity()/(g/cm3);
         Radlen = FK0Material->GetRadlen();
         cout<<"FK0: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitFK0Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitFK0Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///--- Foil Cu1
        ss.str("");
        ss << "GemFoil_Cu1_logic" << j<< "foil0" ;
        s = ss.str();
         G4LogicalVolume* logicalFC10Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* FC10Material = logicalFC10Volume->GetMaterial();
          FC10Tub[j] = dynamic_cast<G4Tubs*>(logicalFC10Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<FC10Material->GetElementVector()->size(); i++){
            Z += (FC10Material->GetElement(i)->GetZ())*
                (FC10Material->GetFractionVector()[i]);
            A += (FC10Material->GetElement(i)->GetA())*
                (FC10Material->GetFractionVector()[i]);
         }
         Ionization = FC10Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = FC10Material->GetDensity()/(g/cm3);
         Radlen = FC10Material->GetRadlen();
         cout<<"FC10: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitFC10Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitFC10Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///--- Gap D
        ss.str("");
        ss << "Gap_D_logic" << j  ;
        s = ss.str();
         G4LogicalVolume* logicalGAPDVolume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* GAPDMaterial = logicalGAPDVolume->GetMaterial();
          GAPDTub[j] = dynamic_cast<G4Tubs*>(logicalGAPDVolume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<GAPDMaterial->GetElementVector()->size(); i++){
            Z += (GAPDMaterial->GetElement(i)->GetZ())*
                (GAPDMaterial->GetFractionVector()[i]);
            A += (GAPDMaterial->GetElement(i)->GetA())*
                (GAPDMaterial->GetFractionVector()[i]);
          }
          Ionization = GAPDMaterial->GetIonisation()->GetMeanExcitationEnergy();
          Density = GAPDMaterial->GetDensity()/(g/cm3);
          Radlen = GAPDMaterial->GetRadlen();
          cout<<"GAPD: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
          KalFitMaterial FitGAPDMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
          _BesKalmanFitMaterials.push_back(FitGAPDMaterial);
          cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
         ///--- Cathode
         /*ss.str("");
         ss << "Cathode_logic" << j;
         s = ss.str();
         G4LogicalVolume* logicalC2Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* C2Material = logicalC2Volume->GetMaterial();
         C2Tub[j] = dynamic_cast<G4Tubs*>(logicalC2Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<C2Material->GetElementVector()->size(); i++){
             Z += (C2Material->GetElement(i)->GetZ())*
                 (C2Material->GetFractionVector()[i]);
             A += (C2Material->GetElement(i)->GetA())*
                 (C2Material->GetFractionVector()[i]);
         }
         Ionization = C2Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = C2Material->GetDensity()/(g/cm3);
         Radlen = C2Material->GetRadlen();
         cout<<"C2: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitC2Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitC2Material);
         */
 
        ///--- Cathode Cu 
        ss.str("");
        ss << "Cathode_Cu_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalCCuVolume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* CCuMaterial = logicalCCuVolume->GetMaterial();
          CCuTub[j] = dynamic_cast<G4Tubs*>(logicalCCuVolume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<CCuMaterial->GetElementVector()->size(); i++){
             Z += (CCuMaterial->GetElement(i)->GetZ())*
                 (CCuMaterial->GetFractionVector()[i]);
             A += (CCuMaterial->GetElement(i)->GetA())*
                 (CCuMaterial->GetFractionVector()[i]);
         }
         Ionization = CCuMaterial->GetIonisation()->GetMeanExcitationEnergy();
         Density = CCuMaterial->GetDensity()/(g/cm3);
         Radlen = CCuMaterial->GetRadlen();
         cout<<"CCu: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitCCuMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitCCuMaterial);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///--- Cathode Kapton3
        ss.str("");
        ss << "Cathode_Kapton3_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalCK3Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* CK3Material = logicalCK3Volume->GetMaterial();
          CK3Tub[j] = dynamic_cast<G4Tubs*>(logicalCK3Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<CK3Material->GetElementVector()->size(); i++){
             Z += (CK3Material->GetElement(i)->GetZ())*
                 (CK3Material->GetFractionVector()[i]);
             A += (CK3Material->GetElement(i)->GetA())*
                 (CK3Material->GetFractionVector()[i]);
         }
         Ionization = CK3Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = CK3Material->GetDensity()/(g/cm3);
         Radlen = CK3Material->GetRadlen();
         cout<<"CK3: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitCK3Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitCK3Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///--- Cathode Epoxy4 
        ss.str("");
        ss << "Cathode_Epoxy4_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalCE4Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* CE4Material = logicalCE4Volume->GetMaterial();
          CE4Tub[j] = dynamic_cast<G4Tubs*>(logicalCE4Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<CE4Material->GetElementVector()->size(); i++){
             Z += (CE4Material->GetElement(i)->GetZ())*
                 (CE4Material->GetFractionVector()[i]);
             A += (CE4Material->GetElement(i)->GetA())*
                 (CE4Material->GetFractionVector()[i]);
         }
         Ionization = CE4Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = CE4Material->GetDensity()/(g/cm3);
         Radlen = CE4Material->GetRadlen();
         cout<<"CE4: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitCE4Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitCE4Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
 
        ///--- Cathode Rohacell2 
        ss.str("");
        ss << "Cathode_Rohacell2_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalCR2Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* CR2Material = logicalCR2Volume->GetMaterial();
          CR2Tub[j] = dynamic_cast<G4Tubs*>(logicalCR2Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<CR2Material->GetElementVector()->size(); i++){
             Z += (CR2Material->GetElement(i)->GetZ())*
                 (CR2Material->GetFractionVector()[i]);
             A += (CR2Material->GetElement(i)->GetA())*
                 (CR2Material->GetFractionVector()[i]);
         }
         Ionization = CR2Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = CR2Material->GetDensity()/(g/cm3);
         Radlen = CR2Material->GetRadlen();
         cout<<"CR2: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitCR2Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitCR2Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///--- Cathode Epoxy3 
        ss.str("");
        ss << "Cathode_Epoxy3_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalCE3Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* CE3Material = logicalCE3Volume->GetMaterial();
          CE3Tub[j] = dynamic_cast<G4Tubs*>(logicalCE3Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<CE3Material->GetElementVector()->size(); i++){
             Z += (CE3Material->GetElement(i)->GetZ())*
                 (CE3Material->GetFractionVector()[i]);
             A += (CE3Material->GetElement(i)->GetA())*
                 (CE3Material->GetFractionVector()[i]);
         }
         Ionization = CE3Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = CE3Material->GetDensity()/(g/cm3);
         Radlen = CE3Material->GetRadlen();
         cout<<"CE3: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitCE3Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitCE3Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///---Cathode Kapton2
        ss.str("");
        ss << "Cathode_Kapton2_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalCK2Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* CK2Material = logicalCK2Volume->GetMaterial();
          CK2Tub[j] = dynamic_cast<G4Tubs*>(logicalCK2Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<CK2Material->GetElementVector()->size(); i++){
             Z += (CK2Material->GetElement(i)->GetZ())*
                 (CK2Material->GetFractionVector()[i]);
             A += (CK2Material->GetElement(i)->GetA())*
                 (CK2Material->GetFractionVector()[i]);
         }
         Ionization = CK2Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = CK2Material->GetDensity()/(g/cm3);
         Radlen = CK2Material->GetRadlen();
         cout<<"CK2: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitCK2Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitCK2Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///--- Cathode Epoxy2 
        ss.str("");
        ss << "Cathode_Epoxy2_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalCE2Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* CE2Material = logicalCE2Volume->GetMaterial();
          CE2Tub[j] = dynamic_cast<G4Tubs*>(logicalCE2Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<CE2Material->GetElementVector()->size(); i++){
             Z += (CE2Material->GetElement(i)->GetZ())*
                 (CE2Material->GetFractionVector()[i]);
             A += (CE2Material->GetElement(i)->GetA())*
                 (CE2Material->GetFractionVector()[i]);
         }
         Ionization = CE2Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = CE2Material->GetDensity()/(g/cm3);
         Radlen = CE2Material->GetRadlen();
         cout<<"CE2: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitCE2Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitCE2Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///--- Cathode Rohacell1 
        ss.str("");
        ss << "Cathode_Rohacell1_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalCR1Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* CR1Material = logicalCR1Volume->GetMaterial();
          CR1Tub[j] = dynamic_cast<G4Tubs*>(logicalCR1Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<CR1Material->GetElementVector()->size(); i++){
             Z += (CR1Material->GetElement(i)->GetZ())*
                 (CR1Material->GetFractionVector()[i]);
             A += (CR1Material->GetElement(i)->GetA())*
                 (CR1Material->GetFractionVector()[i]);
         }
         Ionization = CR1Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = CR1Material->GetDensity()/(g/cm3);
         Radlen = CR1Material->GetRadlen();
         cout<<"CR1: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitCR1Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitCR1Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
        ///--- Cathode Epoxy1 
        ss.str("");
        ss << "Cathode_Epoxy1_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalCE1Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* CE1Material = logicalCE1Volume->GetMaterial();
          CE1Tub[j] = dynamic_cast<G4Tubs*>(logicalCE1Volume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<CE1Material->GetElementVector()->size(); i++){
             Z += (CE1Material->GetElement(i)->GetZ())*
                 (CE1Material->GetFractionVector()[i]);
             A += (CE1Material->GetElement(i)->GetA())*
                 (CE1Material->GetFractionVector()[i]);
         }
         Ionization = CE1Material->GetIonisation()->GetMeanExcitationEnergy();
         Density = CE1Material->GetDensity()/(g/cm3);
         Radlen = CE1Material->GetRadlen();
         cout<<"CE1: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitCE1Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitCE1Material);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
    /*
        ///--- Cathode Honeycomb
        ss.str("");
        ss << "Cathode_Honeycomb_logic" << j ;
        s = ss.str();
         G4LogicalVolume* logicalCHVolume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
         G4Material* CHMaterial = logicalCHVolume->GetMaterial();
          CHTub[j] = dynamic_cast<G4Tubs*>(logicalCHVolume->GetSolid());
         Z = 0.;
         A = 0.;
         for(i=0; i<CHMaterial->GetElementVector()->size(); i++){
             Z += (CHMaterial->GetElement(i)->GetZ())*
                 (CHMaterial->GetFractionVector()[i]);
             A += (CHMaterial->GetElement(i)->GetA())*
                 (CHMaterial->GetFractionVector()[i]);
         }
         Ionization = CHMaterial->GetIonisation()->GetMeanExcitationEnergy();
         Density = CHMaterial->GetDensity()/(g/cm3);
         Radlen = CHMaterial->GetRadlen();
         cout<<"CH: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
         KalFitMaterial FitCHMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
         _BesKalmanFitMaterials.push_back(FitCHMaterial);
         cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
    */
        ///--- Cathode Kapton1
        ss.str("");
        ss << "Cathode_Kapton1_logic" << j ;
        s = ss.str();
        G4LogicalVolume* logicalCK1Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
        G4Material* CK1Material = logicalCK1Volume->GetMaterial();
         CK1Tub[j] = dynamic_cast<G4Tubs*>(logicalCK1Volume->GetSolid());
        Z = 0.;
        A = 0.;
        for(i=0; i<CK1Material->GetElementVector()->size(); i++){
            Z += (CK1Material->GetElement(i)->GetZ())*
                (CK1Material->GetFractionVector()[i]);
            A += (CK1Material->GetElement(i)->GetA())*
                (CK1Material->GetFractionVector()[i]);
        }
        Ionization = CK1Material->GetIonisation()->GetMeanExcitationEnergy();
        Density = CK1Material->GetDensity()/(g/cm3);
        Radlen = CK1Material->GetRadlen();
        cout<<"CK1: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
        KalFitMaterial FitCK1Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
        _BesKalmanFitMaterials.push_back(FitCK1Material);
        cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
    /*
        ///--- Cathode Cu1
        ss.str("");
        ss << "Cathode_Cu1_logic" << j ;
        s = ss.str();
        G4LogicalVolume* logicalCC1Volume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
        G4Material* CC1Material = logicalCC1Volume->GetMaterial();
         CC1Tub[j] = dynamic_cast<G4Tubs*>(logicalCC1Volume->GetSolid());
        Z = 0.;
        A = 0.;
        for(i=0; i<CC1Material->GetElementVector()->size(); i++){
            Z += (CC1Material->GetElement(i)->GetZ())*
                (CC1Material->GetFractionVector()[i]);
            A += (CC1Material->GetElement(i)->GetA())*
                (CC1Material->GetFractionVector()[i]);
        }
        Ionization = CC1Material->GetIonisation()->GetMeanExcitationEnergy();
        Density = CC1Material->GetDensity()/(g/cm3);
        Radlen = CC1Material->GetRadlen();
        cout<<"CC1: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
        KalFitMaterial FitCC1Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
        _BesKalmanFitMaterials.push_back(FitCC1Material);
        cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
    */        
        ///---air
        if(j>0){
            ss.str("");
            ss << "CgemLayer_logic" << j ;
//            ss << "Cgem_logic" ;
            s = ss.str();
            G4LogicalVolume* logicalCLayerVolume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume(s));
            G4Material* CLayerMaterial = logicalCLayerVolume->GetMaterial();
            Z = 0.;
            A = 0.;
            for(i=0; i<CLayerMaterial->GetElementVector()->size(); i++){
                Z += (CLayerMaterial->GetElement(i)->GetZ())*
                    (CLayerMaterial->GetFractionVector()[i]);
                A += (CLayerMaterial->GetElement(i)->GetA())*
                    (CLayerMaterial->GetFractionVector()[i]);
            }
            Ionization = CLayerMaterial->GetIonisation()->GetMeanExcitationEnergy();
            Density = CLayerMaterial->GetDensity()/(g/cm3);
            Radlen = CLayerMaterial->GetRadlen();
            cout<<"CLayer: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
            KalFitMaterial FitCLayerMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
            _BesKalmanFitMaterials.push_back(FitCLayerMaterial);
            cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
        }
 
    }
 
    ///////////////////////////////////////////////////////////////////////////////////////////////////  
    G4LogicalVolume *logicalBes = 0;
    BesG4Geo* aBesG4Geo = new BesG4Geo();
    logicalBes = aBesG4Geo->GetTopVolume();
 
    /// air
    G4LogicalVolume* logicalAirVolume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume("logicalWorld"));
    G4Material* airMaterial = logicalAirVolume->GetMaterial();
    Z = 0.;
    A = 0.;
    for(i=0; i<airMaterial->GetElementVector()->size(); i++){
        Z += (airMaterial->GetElement(i)->GetZ())*
            (airMaterial->GetFractionVector()[i]);
        A += (airMaterial->GetElement(i)->GetA())*
            (airMaterial->GetFractionVector()[i]);
    }
 
    Ionization = airMaterial->GetIonisation()->GetMeanExcitationEnergy();
    Density = airMaterial->GetDensity()/(g/cm3);
    Radlen = airMaterial->GetRadlen();
    cout<<"air: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
    KalFitMaterial FitAirMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
    _BesKalmanFitMaterials.push_back(FitAirMaterial);
    cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
    /// outer beryllium pipe 
    G4LogicalVolume* logicalOuterBeVolume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume("logicalouterBe"));
    G4Material* outerBeMaterial = logicalOuterBeVolume->GetMaterial();
 
    G4Tubs* outerBeTub = dynamic_cast<G4Tubs*>(logicalOuterBeVolume->GetSolid());
    Z = 0.;
    A = 0.;
    for(i=0; i<outerBeMaterial->GetElementVector()->size(); i++){   
        Z += (outerBeMaterial->GetElement(i)->GetZ())*
            (outerBeMaterial->GetFractionVector()[i]);   
        A += (outerBeMaterial->GetElement(i)->GetA())*   
            (outerBeMaterial->GetFractionVector()[i]);
    }
    Ionization =  outerBeMaterial->GetIonisation()->GetMeanExcitationEnergy();
    Density = outerBeMaterial->GetDensity()/(g/cm3);
    Radlen = outerBeMaterial->GetRadlen();
    cout<<"outer beryllium: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
    KalFitMaterial FitOuterBeMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
    _BesKalmanFitMaterials.push_back(FitOuterBeMaterial);
    cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
 
    /// cooling oil 
    G4LogicalVolume* logicalOilLayerVolume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume("logicaloilLayer"));
    G4Material* oilLayerMaterial = logicalOilLayerVolume->GetMaterial();
    G4Tubs* oilLayerTub = dynamic_cast<G4Tubs*>(logicalOilLayerVolume->GetSolid());
 
    Z = 0.;
    A = 0.;
    for(i=0; i<oilLayerMaterial->GetElementVector()->size(); i++){        
        Z += (oilLayerMaterial->GetElement(i)->GetZ())*
            (oilLayerMaterial->GetFractionVector()[i]);             
        A += (oilLayerMaterial->GetElement(i)->GetA())*             
            (oilLayerMaterial->GetFractionVector()[i]);
    }
    Ionization = oilLayerMaterial->GetIonisation()->GetMeanExcitationEnergy();
    Density = oilLayerMaterial->GetDensity()/(g/cm3);
    Radlen = oilLayerMaterial->GetRadlen();
    cout<<"cooling oil: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
    KalFitMaterial FitOilLayerMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
    _BesKalmanFitMaterials.push_back(FitOilLayerMaterial);
    cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
 
    /// inner beryllium pipe 
    G4LogicalVolume* logicalInnerBeVolume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume("logicalinnerBe"));
    G4Material* innerBeMaterial = logicalInnerBeVolume->GetMaterial();
    G4Tubs* innerBeTub = dynamic_cast<G4Tubs*>(logicalInnerBeVolume->GetSolid());
    Z = 0.;
    A = 0.;
    for(i=0; i<innerBeMaterial->GetElementVector()->size(); i++){
        Z += (innerBeMaterial->GetElement(i)->GetZ())*
            (innerBeMaterial->GetFractionVector()[i]);
        A += (innerBeMaterial->GetElement(i)->GetA())*
            (innerBeMaterial->GetFractionVector()[i]);
    }
 
    Ionization = innerBeMaterial->GetIonisation()->GetMeanExcitationEnergy();
    Density = innerBeMaterial->GetDensity()/(g/cm3);
    Radlen = innerBeMaterial->GetRadlen();
    cout<<"inner beryllium: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
    KalFitMaterial FitInnerBeMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
    _BesKalmanFitMaterials.push_back(FitInnerBeMaterial);
    cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
 
    /// gold
    G4LogicalVolume* logicalGoldLayerVolume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume("logicalgoldLayer"));
    G4Material* goldLayerMaterial = logicalGoldLayerVolume->GetMaterial();
    G4Tubs* goldLayerTub = dynamic_cast<G4Tubs*>(logicalGoldLayerVolume->GetSolid());
 
    Z = 0.;
    A = 0.;
    for(i=0; i<goldLayerMaterial->GetElementVector()->size(); i++){
        Z += (goldLayerMaterial->GetElement(i)->GetZ())*
            (goldLayerMaterial->GetFractionVector()[i]);
        A += (goldLayerMaterial->GetElement(i)->GetA())*
            (goldLayerMaterial->GetFractionVector()[i]);
    }
    Ionization = goldLayerMaterial->GetIonisation()->GetMeanExcitationEnergy();
    Density = goldLayerMaterial->GetDensity()/(g/cm3);
    Radlen = goldLayerMaterial->GetRadlen();
    cout<<"gold layer: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<endl;
    KalFitMaterial FitGoldLayerMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
    _BesKalmanFitMaterials.push_back(FitGoldLayerMaterial);
    cout << "@@@@" << _BesKalmanFitMaterials.size() << endl;
 
 
    /// now construct the cylinders
    double radius, thick, length , z0;
    int k=0;
  
    /*
        /// film1 of the innerwall of inner drift chamber
        radius = innerwallFilm1Tub->GetInnerRadius()/(cm);
        thick  = innerwallFilm1Tub->GetOuterRadius()/(cm) - innerwallFilm1Tub->GetInnerRadius()/(cm);
        length = 2.0*innerwallFilm1Tub->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"innerwallFilm1: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder innerwallFilm1Cylinder(&_BesKalmanFitMaterials[1], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(innerwallFilm1Cylinder);
 
 
        /// innerwall of inner drift chamber
        radius = innerwallTub->GetInnerRadius()/(cm);
        thick  = innerwallTub->GetOuterRadius()/(cm) - innerwallTub->GetInnerRadius()/(cm);
        length = 2.0*innerwallTub->GetZHalfLength()/(cm);
        z0     = 0.0;
        cout<<"innerwall: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<endl;
        KalFitCylinder innerwallCylinder(&_BesKalmanFitMaterials[2], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(innerwallCylinder);
 
        /// film0 of the innerwall of inner drift chamber
        radius = innerwallFilm0Tub->GetInnerRadius()/(cm);
        thick  = innerwallFilm0Tub->GetOuterRadius()/(cm) - innerwallFilm0Tub->GetInnerRadius()/(cm);
        length = 2.0*innerwallFilm0Tub->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"innerwallFilm0: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder innerwallFilm0Cylinder(&_BesKalmanFitMaterials[3], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(innerwallFilm0Cylinder);
    
    */
    /// Separator
    radius = SeparatorTub->GetInnerRadius()/(cm);
    thick  = SeparatorTub->GetOuterRadius()/(cm) - SeparatorTub->GetInnerRadius()/(cm);
    length = 2.0*SeparatorTub->GetZHalfLength()/(cm);
    z0     = 0.0;
    std::cout<<"Separator: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
    KalFitCylinder SeparatorCylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
    _BesKalmanFitWalls.push_back(SeparatorCylinder);
    cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
    for(int i=2;i>=0;i--){
 
        /// shield kapton2
        /*
        radius = SK2Tub[i]->GetInnerRadius()/(cm);
        thick  = SK2Tub[i]->GetOuterRadius()/(cm) - SK2Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*SK2Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"SK2: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder SK2Cylinder(&_BesKalmanFitMaterials[1+i*32], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(SK2Cylinder);
        */
 
        /// shield honeycomb
        /*
        radius = HCTub[i]->GetInnerRadius()/(cm);
        thick  = HCTub[i]->GetOuterRadius()/(cm) - HCTub[i]->GetInnerRadius()/(cm);
        length = 2.0*HCTub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"HC: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder HCCylinder(&_BesKalmanFitMaterials[2+i*32], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(HCCylinder);
        */
 
        /// shield kapton1
        /*
        radius = SK1Tub[i]->GetInnerRadius()/(cm);
        thick  = SK1Tub[i]->GetOuterRadius()/(cm) - SK1Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*SK1Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"SK1: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder SK1Cylinder(&_BesKalmanFitMaterials[3+i*32], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(SK1Cylinder);
        */
  
        /// Anode Kapton4
        radius = AK4Tub[i]->GetInnerRadius()/(cm);
        thick  = AK4Tub[i]->GetOuterRadius()/(cm) - AK4Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*AK4Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"AK4: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder AK4Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(AK4Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
  
        /// Anode Au2
        /*
        radius = AA2Tub[i]->GetInnerRadius()/(cm);
        thick  = AA2Tub[i]->GetOuterRadius()/(cm) - AA2Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*AA2Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"AA2: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder AA2Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(AA2Cylinder);
        */
 
        /// Anode Cu3
        radius = AC3Tub[i]->GetInnerRadius()/(cm);
        thick  = AC3Tub[i]->GetOuterRadius()/(cm) - AC3Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*AC3Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"AC3: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder AC3Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(AC3Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        /// Anode Epoxy5
        radius = AE5Tub[i]->GetInnerRadius()/(cm);
        thick  = AE5Tub[i]->GetOuterRadius()/(cm) - AE5Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*AE5Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"AE5: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder AE5Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(AE5Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        /// Anode Rohacell2
        radius = AR2Tub[i]->GetInnerRadius()/(cm);
        thick  = AR2Tub[i]->GetOuterRadius()/(cm) - AR2Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*AR2Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"AR2: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder AR2Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(AR2Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        /// Anode Epoxy4
        radius = AE4Tub[i]->GetInnerRadius()/(cm);
        thick  = AE4Tub[i]->GetOuterRadius()/(cm) - AE4Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*AE4Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"AE4: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder AE4Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(AE4Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        /// Anode Kapton3
        radius = AK3Tub[i]->GetInnerRadius()/(cm);
        thick  = AK3Tub[i]->GetOuterRadius()/(cm) - AK3Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*AK3Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"AK3: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder AK3Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(AK3Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        /// Anode Epoxy3
        radius = AE3Tub[i]->GetInnerRadius()/(cm);
        thick  = AE3Tub[i]->GetOuterRadius()/(cm) - AE3Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*AE3Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"AE3: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder AE3Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(AE3Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        /// Anode Rohacell1
        radius = AR1Tub[i]->GetInnerRadius()/(cm);
        thick  = AR1Tub[i]->GetOuterRadius()/(cm) - AR1Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*AR1Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"AR1: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder AR1Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(AR1Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        /// Anode Epoxy2
        radius = AE2Tub[i]->GetInnerRadius()/(cm);
        thick  = AE2Tub[i]->GetOuterRadius()/(cm) - AE2Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*AE2Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"AE2: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder AE2Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(AE2Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        /// Anode Kapton2
        radius = AK2Tub[i]->GetInnerRadius()/(cm);
        thick  = AK2Tub[i]->GetOuterRadius()/(cm) - AK2Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*AK2Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"AK2: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder AK2Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(AK2Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
        
        /// Anode Epoxy1
        radius = AE1Tub[i]->GetInnerRadius()/(cm);
        thick  = AE1Tub[i]->GetOuterRadius()/(cm) - AE1Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*AE1Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;   
        std::cout<<"AE1: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder AE1Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(AE1Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
        
        /// Anode Cu2
        radius = AC2Tub[i]->GetInnerRadius()/(cm);
        thick  = AC2Tub[i]->GetOuterRadius()/(cm) - AC2Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*AC2Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"AC2: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder AC2Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(AC2Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        // Anode Kapton1
        radius = AK1Tub[i]->GetInnerRadius()/(cm);
        thick  = AK1Tub[i]->GetOuterRadius()/(cm) - AK1Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*AK1Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"AK1: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder AK1Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(AK1Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        /// Anode Cu1
        radius = AC1Tub[i]->GetInnerRadius()/(cm);
        thick  = AC1Tub[i]->GetOuterRadius()/(cm) - AC1Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*AC1Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;   
        std::cout<<"AC1: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder AC1Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(AC1Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        /// Anode Au1
        /*
        radius = AA1Tub[i]->GetInnerRadius()/(cm);
        thick  = AA1Tub[i]->GetOuterRadius()/(cm) - AA1Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*AA1Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;   
        std::cout<<"AA1: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder AA1Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(AA1Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
        */
 
        /// GAP I
        radius = GAPITub[i]->GetInnerRadius()/(cm);
        thick  = GAPITub[i]->GetOuterRadius()/(cm) - GAPITub[i]->GetInnerRadius()/(cm);
        length = 2.0*GAPITub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;    
        std::cout<<"GAPI: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder GAPICylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(GAPICylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        /// Foil Gem2
        /// Cu2
        radius = FC22Tub[i]->GetInnerRadius()/(cm);
        thick  = FC22Tub[i]->GetOuterRadius()/(cm) - FC22Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*FC22Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;    
        std::cout<<"FC22: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder FC22Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(FC22Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        /// Kapton
        radius = FK2Tub[i]->GetInnerRadius()/(cm);
        thick  = FK2Tub[i]->GetOuterRadius()/(cm) - FK2Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*FK2Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;    
        std::cout<<"FK2: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder FK2Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(FK2Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        /// Cu1
        radius = FC12Tub[i]->GetInnerRadius()/(cm);
        thick  = FC12Tub[i]->GetOuterRadius()/(cm) - FC12Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*FC12Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;    
        std::cout<<"FC12: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder FC12Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(FC12Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        ///Gap T2
        radius = GAPT2Tub[i]->GetInnerRadius()/(cm);
        thick  = GAPT2Tub[i]->GetOuterRadius()/(cm) - GAPT2Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*GAPT2Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;    
        std::cout<<"GAPT2: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder GAPT2Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(GAPT2Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        //Gem Foil1
        //Cu2
        radius = FC21Tub[i]->GetInnerRadius()/(cm);
        thick  = FC21Tub[i]->GetOuterRadius()/(cm) - FC21Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*FC21Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;    
        std::cout<<"FC21: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder FC21Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(FC21Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        // Kapton
        radius = FK1Tub[i]->GetInnerRadius()/(cm);
        thick  = FK1Tub[i]->GetOuterRadius()/(cm) - FK1Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*FK1Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;    
        std::cout<<"FK1: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder FK1Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(FK1Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        // Cu1
        radius = FC11Tub[i]->GetInnerRadius()/(cm);
        thick  = FC11Tub[i]->GetOuterRadius()/(cm) - FC11Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*FC11Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;    
        std::cout<<"FC11: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder FC11Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(FC11Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        // Gap T1
        radius = GAPT1Tub[i]->GetInnerRadius()/(cm);
        thick  = GAPT1Tub[i]->GetOuterRadius()/(cm) - GAPT1Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*GAPT1Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"GAPT1: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder GAPT1Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(GAPT1Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        // Gem Foil0
        // Cu2
        radius = FC20Tub[i]->GetInnerRadius()/(cm);
        thick  = FC20Tub[i]->GetOuterRadius()/(cm) - FC20Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*FC20Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"FC20: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder FC20Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(FC20Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        // Kapton
        radius = FK0Tub[i]->GetInnerRadius()/(cm);
        thick  = FK0Tub[i]->GetOuterRadius()/(cm) - FK0Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*FK0Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;  
        std::cout<<"FK0: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder FK0Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(FK0Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        // Cu1
        radius = FC10Tub[i]->GetInnerRadius()/(cm);
        //thick  = 0.0002;//FC10Tub[i]->GetOuterRadius()/(cm) - FC10Tub[i]->GetInnerRadius()/(cm);
        thick  = FC10Tub[i]->GetOuterRadius()/(cm) - FC10Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*FC10Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;  
        std::cout<<"FC10: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder FC10Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(FC10Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        // Gap D
        radius = GAPDTub[i]->GetInnerRadius()/(cm);
        thick  = GAPDTub[i]->GetOuterRadius()/(cm) - GAPDTub[i]->GetInnerRadius()/(cm);
        length = 2.0*GAPDTub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;  
        std::cout<<"GAPD: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder GAPDCylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(GAPDCylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        // Cathode Cu
        radius = CCuTub[i]->GetInnerRadius()/(cm);
        thick  = CCuTub[i]->GetOuterRadius()/(cm) - CCuTub[i]->GetInnerRadius()/(cm);
        length = 2.0*CCuTub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;  
        std::cout<<"CCu: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder CCuCylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(CCuCylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        // Cathode Kapton3
        radius = CK3Tub[i]->GetInnerRadius()/(cm);
        thick  = CK3Tub[i]->GetOuterRadius()/(cm) - CK3Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*CK3Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;  
        std::cout<<"CK3: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder CK3Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(CK3Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        // Cathode Epoxy4
        radius = CE4Tub[i]->GetInnerRadius()/(cm);
        thick  = CE4Tub[i]->GetOuterRadius()/(cm) - CE4Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*CE4Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;  
        std::cout<<"CE4: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder CE4Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(CE4Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        // Cathode Rohacell2
        radius = CR2Tub[i]->GetInnerRadius()/(cm);
        thick  = CR2Tub[i]->GetOuterRadius()/(cm) - CR2Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*CR2Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;  
        std::cout<<"CR2: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder CR2Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(CR2Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        // Cathode Epoxy3
        radius = CE3Tub[i]->GetInnerRadius()/(cm);
        thick  = CE3Tub[i]->GetOuterRadius()/(cm) - CE3Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*CE3Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;  
        std::cout<<"CE3: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder CE3Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(CE3Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        // Cathode Kapton2
        radius = CK2Tub[i]->GetInnerRadius()/(cm);
        thick  = CK2Tub[i]->GetOuterRadius()/(cm) - CK2Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*CK2Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;  
        std::cout<<"CK2: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder CK2Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(CK2Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        // Cathode Epoxy2
        radius = CE2Tub[i]->GetInnerRadius()/(cm);
        thick  = CE2Tub[i]->GetOuterRadius()/(cm) - CE2Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*CE2Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;  
        std::cout<<"CE2: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder CE2Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(CE2Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        // Cathode Rohacell1
        radius = CR1Tub[i]->GetInnerRadius()/(cm);
        thick  = CR1Tub[i]->GetOuterRadius()/(cm) - CR1Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*CR1Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;  
        std::cout<<"CR1: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder CR1Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(CR1Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        // Cathode Epoxy1
        radius = CE1Tub[i]->GetInnerRadius()/(cm);
        thick  = CE1Tub[i]->GetOuterRadius()/(cm) - CE1Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*CE1Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;  
        std::cout<<"CE1: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder CE1Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(CE1Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        //Cathode Honeycomb
        /*
        radius = CHTub[i]->GetInnerRadius()/(cm);
        thick  = CHTub[i]->GetOuterRadius()/(cm) - CHTub[i]->GetInnerRadius()/(cm);
        length = 2.0*CHTub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;  
        std::cout<<"CH: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder CHCylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(CHCylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
        */
 
        //Cathode Kapton1
        radius = CK1Tub[i]->GetInnerRadius()/(cm);
        thick  = CK1Tub[i]->GetOuterRadius()/(cm) - CK1Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*CK1Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;  
        std::cout<<"CK1: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder CK1Cylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(CK1Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
        // Cathode Cu1
        /*
        radius = CC1Tub[i]->GetInnerRadius()/(cm);
        thick  = CC1Tub[i]->GetOuterRadius()/(cm) - CC1Tub[i]->GetInnerRadius()/(cm);
        length = 2.0*CC1Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;  
        std::cout<<"CC1: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder CC1Cylinder(&_BesKalmanFitMaterials[31+i*32], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(CC1Cylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
        */
 
        //air between different CgemLayer
        if(i>=1){
        radius = AK4Tub[i-1]->GetOuterRadius()/(cm);
        thick  = CK1Tub[i]->GetInnerRadius()/(cm) - AK4Tub[i-1]->GetOuterRadius()/(cm);
        length = 2.0*CK1Tub[i]->GetZHalfLength()/(cm);
        z0     = 0.0;
        std::cout<<"air between layer: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
        KalFitCylinder AirBCylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
        _BesKalmanFitWalls.push_back(AirBCylinder);
        cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
        }
    }
 
    /// outer air, be attention the calculation of the radius and thick of the air cylinder is special 
    radius = outerBeTub->GetOuterRadius()/(cm);
    thick  = CK1Tub[0]->GetInnerRadius()/(cm) - outerBeTub->GetOuterRadius()/(cm);
    length = 2.0*CK1Tub[0]->GetZHalfLength()/(cm);
    z0     = 0.0;
    cout<<"outer air: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<endl;
    KalFitCylinder outerAirCylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
    _BesKalmanFitWalls.push_back(outerAirCylinder);
    cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
    /// outer Beryllium layer
    radius = outerBeTub->GetInnerRadius()/(cm);
    thick  = outerBeTub->GetOuterRadius()/(cm) - outerBeTub->GetInnerRadius()/(cm);
    length = 2.0*outerBeTub->GetZHalfLength()/(cm);
    z0     = 0.0;
    cout<<"outer Be: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<endl; 
    KalFitCylinder outerBeCylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
    _BesKalmanFitWalls.push_back(outerBeCylinder);
    cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
    /// oil layer
    radius = oilLayerTub->GetInnerRadius()/(cm);
    thick  = oilLayerTub->GetOuterRadius()/(cm) - oilLayerTub->GetInnerRadius()/(cm);
    length = 2.0*oilLayerTub->GetZHalfLength()/(cm);
    z0     = 0.0;
    cout<<"oil layer: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<endl; 
    KalFitCylinder oilLayerCylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
    _BesKalmanFitWalls.push_back(oilLayerCylinder);
    cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
    /// inner Beryllium layer
    radius = innerBeTub->GetInnerRadius()/(cm);
    thick  = innerBeTub->GetOuterRadius()/(cm) - innerBeTub->GetInnerRadius()/(cm);
    length = 2.0*innerBeTub->GetZHalfLength()/(cm);
    z0     = 0.0;
    cout<<"inner Be: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<endl; 
    KalFitCylinder innerBeCylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
    _BesKalmanFitWalls.push_back(innerBeCylinder);
    cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
 
    /// gold layer
    radius = goldLayerTub->GetInnerRadius()/(cm);
    thick  = goldLayerTub->GetOuterRadius()/(cm) - goldLayerTub->GetInnerRadius()/(cm);
    length = 2.0*goldLayerTub->GetZHalfLength()/(cm);
    z0     = 0.0;
    cout<<"gold layer: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<endl; 
    KalFitCylinder goldLayerCylinder(&_BesKalmanFitMaterials[++k], radius, thick, length , z0);
    _BesKalmanFitWalls.push_back(goldLayerCylinder);
    cout<<"wall: "<<k<<"  Z: "<<_BesKalmanFitMaterials[k].Z()<<endl;
    
 
    // --- GEM
    //double rGem[4]={7.7,10.7,13.7,16.7};  //cm
    //double LGem[4]={774,798,828,858};//cm
    //radius=
    //_BesGemWalls.push_back();
}//end of setBesFromGdml

Referenced by initialize().

setBesFromGdml() [2/2]

void KalFitAlg::setBesFromGdml

(

void

)

setCalibSvc_init() [1/2]

void KalFitAlg::setCalibSvc_init

(

void

)

initialize for the services

Definition at line 247 of file KalFitAlg2.cxx.

 {
  IMdcCalibFunSvc* imdcCalibSvc; 
  MsgStream log(msgSvc(), name());
  StatusCode sc = service ("MdcCalibFunSvc", imdcCalibSvc);
  m_mdcCalibFunSvc_ = dynamic_cast<MdcCalibFunSvc*>(imdcCalibSvc);
  if ( sc.isFailure() ){
    log << MSG::FATAL << "Could not load MdcCalibFunSvc!" << endreq;
  }
 KalFitTrack::setMdcCalibFunSvc( m_mdcCalibFunSvc_);
 }

Referenced by initialize().

setCalibSvc_init() [2/2]

void KalFitAlg::setCalibSvc_init

(

void

)

initialize for the services

setCylinder_Mdc() [1/2]

void KalFitAlg::setCylinder_Mdc

(

void

)

Initialize the cylinders (walls and cathodes) for Mdc.

setCylinder_Mdc() [2/2]

void KalFitAlg::setCylinder_Mdc

(

void

)

Initialize the cylinders (walls and cathodes) for Mdc.

setDchisqCut() [1/2]

void KalFitAlg::setDchisqCut

(

void

)

set dchi2cutf_anal

set dchi2cuts_anal

temporary

set dchi2cutf_calib

temporary

set dchi2cuts_calib

temporary

Definition at line 658 of file KalFitAlg.cxx.

{
    int layid = 0;
 
    /// set dchi2cutf_anal
    for(layid = 0; layid<2; layid++) {
        KalFitTrack::dchi2cutf_anal[layid] = dchi2cut_inner_;
    }
    KalFitTrack::dchi2cutf_anal[2] = dchi2cut_layid2_;
    KalFitTrack::dchi2cutf_anal[3] = dchi2cut_layid3_;
    for(layid = 4; layid<12; layid++) {
        KalFitTrack::dchi2cutf_anal[layid] = dchi2cut_mid1_;
    }
    for(layid = 12; layid<20; layid++) {
        KalFitTrack::dchi2cutf_anal[layid] = dchi2cut_mid2_;
    }
    for(layid = 20; layid<43; layid++) {
        KalFitTrack::dchi2cutf_anal[layid] = dchi2cut_outer_;
    }
 
 
    /// set dchi2cuts_anal
    for(layid = 0; layid<2; layid++) {
        KalFitTrack::dchi2cuts_anal[layid] = dchi2cut_inner_;
    }
 
    KalFitTrack::dchi2cuts_anal[2] = dchi2cut_layid2_;
    KalFitTrack::dchi2cuts_anal[3] = dchi2cut_layid3_;
    for(layid = 4; layid<12; layid++) {
        KalFitTrack::dchi2cuts_anal[layid] = dchi2cut_mid1_;
    }
    for(layid = 12; layid<20; layid++) {
        KalFitTrack::dchi2cuts_anal[layid] = dchi2cut_mid2_;
    }
    for(layid = 20; layid<43; layid++) {
        KalFitTrack::dchi2cuts_anal[layid] = dchi2cut_outer_;
    }
 
    /// temporary 
    //  for(layid = 0; layid<43; layid++) {
    //    KalFitTrack::dchi2cuts_anal[layid] = 10.0;
    //  }
 
 
    /// set dchi2cutf_calib
    for(layid = 0; layid<2; layid++) {
        KalFitTrack::dchi2cutf_calib[layid] = dchi2cut_inner_;
    }
 
    KalFitTrack::dchi2cutf_calib[2] = dchi2cut_layid2_;
    KalFitTrack::dchi2cutf_calib[3] = dchi2cut_layid3_;
 
    for(layid = 4; layid<12; layid++) {
        KalFitTrack::dchi2cutf_calib[layid] = dchi2cut_mid1_;
    }
 
    for(layid = 12; layid<20; layid++) {
        KalFitTrack::dchi2cutf_calib[layid] = dchi2cut_mid2_;
    }
 
    for(layid = 20; layid<43; layid++) {
        KalFitTrack::dchi2cutf_calib[layid] = dchi2cut_outer_;
    }
 
    /// temporary 
    if(usage_<2){
        for(layid = 0; layid<43; layid++) {
            KalFitTrack::dchi2cutf_calib[layid] = 10.0;
        }
    }
 
 
    /// set dchi2cuts_calib
    for(layid = 0; layid<2; layid++) {
        KalFitTrack::dchi2cuts_calib[layid] = dchi2cut_inner_;
    }
 
    KalFitTrack::dchi2cuts_calib[2] = dchi2cut_layid2_;
    KalFitTrack::dchi2cuts_calib[3] = dchi2cut_layid3_;
 
    for(layid = 4; layid<12; layid++) {
        KalFitTrack::dchi2cuts_calib[layid] = dchi2cut_mid1_;
    }       
 
    for(layid = 12; layid<20; layid++) {
        KalFitTrack::dchi2cuts_calib[layid] = dchi2cut_mid2_;
    }
 
    for(layid = 20; layid<43; layid++) {
        KalFitTrack::dchi2cuts_calib[layid] = dchi2cut_outer_;
    } 
 
    /// temporary 
    if(usage_<2){
        for(layid = 0; layid<43; layid++) {
            KalFitTrack::dchi2cuts_calib[layid] = 10.0;
        }
    }
}

Referenced by initialize().

setDchisqCut() [2/2]

void KalFitAlg::setDchisqCut

(

void

)

setGeomSvc_init() [1/2]

void KalFitAlg::setGeomSvc_init

(

void

)

Definition at line 259 of file KalFitAlg2.cxx.

 {
  IMdcGeomSvc*  imdcGeomSvc;
  MsgStream log(msgSvc(), name());
  StatusCode sc = service ("MdcGeomSvc", imdcGeomSvc);
//  m_mdcGeomSvc_ = dynamic_cast<MdcGeomSvc*>(imdcGeomSvc);
  if ( sc.isFailure() ){
    log << MSG::FATAL << "Could not load MdcGeomSvc!" << endreq;
  }
 imdcGeomSvc_ = imdcGeomSvc;
 
 KalFitTrack::setIMdcGeomSvc( imdcGeomSvc);
 }

Referenced by beginRun().

setGeomSvc_init() [2/2]

void KalFitAlg::setGeomSvc_init

(

void

)

setMagneticFieldSvc_init() [1/2]

void KalFitAlg::setMagneticFieldSvc_init

(

void

)

setMagneticFieldSvc_init() [2/2]

void KalFitAlg::setMagneticFieldSvc_init

(

void

)

setMaterial_Mdc() [1/2]

void KalFitAlg::setMaterial_Mdc

(

void

)

Initialize the material for Mdc.

setMaterial_Mdc() [2/2]

void KalFitAlg::setMaterial_Mdc

(

void

)

Initialize the material for Mdc.

smoother_anal() [1/2]

void KalFitAlg::smoother_anal	(	KalFitTrack &	trk,
		int	way
	)

Kalman filter (smoothing or backward part)

be attention to this inital error matrix of smoother, how is track.Ea() in the next sentence when use it?

oh, to be the last hit

calculate the lsat point in MDC

calculate fiTerm

for protection purpose

Definition at line 2450 of file KalFitAlg.cxx.

{
    // retrieve Mdc  geometry information
    IMdcGeomSvc* igeomsvc;
    StatusCode sc = Gaudi::svcLocator()->service("MdcGeomSvc", igeomsvc);
    if(sc==StatusCode::FAILURE) cout << "GeoSvc failing!!!!!!!SC=" << sc << endl;
    MdcGeomSvc* geomsvc = dynamic_cast<MdcGeomSvc*>(igeomsvc);
    if(!geomsvc){
        std::cout<<"ERROR OCCUR when dynamic_cast in KalFitTrack.cxx !!"<<std::endl;
    }
 
    HepPoint3D ip(0,0,0);
    if(m_usevtxdb==1){
        Hep3Vector xorigin(0,0,0);
        IVertexDbSvc*  vtxsvc;
        Gaudi::svcLocator()->service("VertexDbSvc", vtxsvc);
        if(vtxsvc->isVertexValid()){
            double* dbv = vtxsvc->PrimaryVertex(); 
            double*  vv = vtxsvc->SigmaPrimaryVertex();  
            xorigin.setX(dbv[0]);
            xorigin.setY(dbv[1]);
            xorigin.setZ(dbv[2]);
        }
        ip[0] = xorigin[0];
        ip[1] = xorigin[1];
        ip[2] = xorigin[2];
    }
 
    // Estimation of the path length from ip to 1st cylinder
 
    Helix work = *(Helix*)&track;
    work.ignoreErrorMatrix();
    work.pivot(ip);
 
 
    double tanl = track.tanl();
    double phi_old = work.phi0();
    double phi = track.phi0();
 
    if (fabs(phi - phi_old) > M_PI) {
        if (phi > phi_old) phi -= 2 * M_PI;
        else phi_old -= 2 * M_PI;
    }
 
    double path_zero = fabs(track.radius() * (phi_old-phi)* sqrt(1 + tanl * tanl));
    // track.addPathSM(path_zero);
 
 
    HepSymMatrix Eakal(5,0);
    track.pivot(ip);
    /// be attention to this inital error matrix of smoother,
    /// how is track.Ea() in the next sentence when use it?
    Eakal = track.Ea()*matrixg_;
    track.Ea(Eakal);
 
    // Mdc part :
    unsigned int nhit = track.HitsMdc().size();
    int layer_prev = -1;
 
    HepVector pos_old(3,0);
    double r0kal_prec(0);
    int  nhits_read(0);
    for( unsigned i=0 ; i < nhit; i++ ) {
        int ihit = (nhit-1)-i;
        KalFitHitMdc& HitMdc = track.HitMdc(ihit);
        const KalFitWire& Wire = HitMdc.wire();
 
        int wireid = Wire.geoID();
        nhits_read++;
 
        int layer = Wire.layer().layerId();
        if (pathl_ && layer != layer_prev) {
 
            if (debug_ == 4) cout<<"in smoother,layerid "<<layer<<"  layer_prev  "
                <<layer_prev <<"  pathl_   "<<pathl_<<endl;
 
            // track.PathL(Wire.layer().layerId());
            layer_prev = layer;
        }
 
        HepPoint3D fwd(Wire.fwd());
        HepPoint3D bck(Wire.bck());
        Hep3Vector wire = (CLHEP::Hep3Vector)fwd - (CLHEP::Hep3Vector)bck;
        Helix work = *(Helix*)&track;
        work.ignoreErrorMatrix();
        work.pivot((fwd + bck) * .5);
        HepPoint3D x0kal = (work.x(0).z() - bck.z()) / wire.z() * wire + bck;
 
        if(4 == debug_) std::cout<<" x0kal before sag: "<<x0kal<<std::endl;
        if (wsag_ == 4){
            Hep3Vector result;
            const MdcGeoWire* geowire = geomsvc->Wire(wireid); 
            double tension = geowire->Tension();
 
            //std::cout<<" tension: "<<tension<<std::endl;
            double zinit(x0kal.z()), lzx(Wire.lzx());
 
            // double A(Wire.Acoef());
            double A = 47.35E-6/tension;
            double Zp = (zinit - bck.z())*lzx/wire.z();
 
            if(4 == debug_){
                std::cout<<" sag in smoother_anal: "<<std::endl;    
                std::cout<<" x0kal.x(): "<<std::setprecision(10)<<x0kal.x()<<std::endl;
                std::cout<<" wire.x()*(zinit-bck.z())/wire.z(): "<<std::setprecision(10)
                                           <<(wire.x()*(zinit-bck.z())/wire.z())<<std::endl;
                std::cout<<"bck.x(): "<<std::setprecision(10)<<bck.x()<<std::endl;
                std::cout<<" wire.x()*(zinit-bck.z())/wire.z() + bck.x(): "<<std::setprecision(10)
                                                 <<(wire.x()*(zinit-bck.z())/wire.z() + bck.x())<<std::endl;
            }
 
            result.setX(wire.x()*(zinit-bck.z())/wire.z() + bck.x());
            result.setY((A*(Zp-lzx)+wire.y()/lzx)*Zp+bck.y());
            result.setZ((A*(2*Zp-lzx)*lzx+wire.y())/wire.z());
 
            wire.setX(wire.x()/wire.z());
            wire.setY(result.z());
            wire.setZ(1);
 
            x0kal.setX(result.x());
            x0kal.setY(result.y());
        }
 
        if(4 == debug_) std::cout<<" x0kal after sag: "<<x0kal<<std::endl;
 
        // If x0kal is after the inner wall and x0kal_prec before :
        double r0kal = x0kal.perp();
        if (debug_ == 4) {
            cout<<"wire direction "<<wire<<endl;
            cout<<"x0kal "<<x0kal<<endl;
            cout<<"smoother::r0kal "<<r0kal<<"  r0kal_prec  "<<r0kal_prec <<endl;
        }
 
        // change PIVOT :
        /*cout<<endl<<"before change pivot: "<<endl;//wangll
          cout<<"track.pivot = "<<track.pivot()<<endl;//wangll
          cout<<"track.helix = "<<track.a()<<endl;//wangll
          */
        double pathl(0);
        track.pivot_numf(x0kal, pathl);
        track.addPathSM(pathl);
        /*cout<<endl<<"after change pivot: "<<endl;//wangll
          cout<<"track.pivot = "<<track.pivot()<<endl;//wangll
          cout<<"track.helix = "<<track.a()<<endl;//wangll
          */
 
        // calculate the tof time in this layer
        double pmag( sqrt( 1.0 + track.a()[4]*track.a()[4]) / track.a()[2]);
        double mass_over_p( track.mass()/ pmag );
        double beta( 1.0 / sqrt( 1.0 + mass_over_p * mass_over_p ) );
        double tofest = pathl / ( 29.9792458 * beta );
        track.addTofSM(tofest);
 
        // std::cout<<" in layer: "<<layer<<" pathl: "<<pathl<<" tof: "<<tofest<<std::endl;
 
        if(KalFitElement::muls()) track.msgasmdc(pathl, way);
        /*cout<<endl<<"after muls: "<<endl;//wangll
          cout<<"track.pivot = "<<track.pivot()<<endl;//wangll
          cout<<"track.helix = "<<track.a()<<endl;//wangll
          */
        if(!(way<0&&fabs(track.kappa())>1000.0)) {
            if(KalFitElement::loss()) track.eloss(pathl, _BesKalmanFitMaterials[0], way);
        }
 
 
        // Add info hit wire :
        /*cout<<endl<<"after eloss: "<<endl;//wangll
          cout<<"track.pivot = "<<track.pivot()<<endl;//wangll
          cout<<"track.helix = "<<track.a()<<endl;//wangll
          */
        if(fabs(track.kappa())>0&&fabs(track.kappa())<1000.0&&fabs(track.tanl())<7.02) {
            HepVector Va(5,0);
            HepSymMatrix Ma(5,0);
            KalFitHelixSeg  HelixSeg(&HitMdc,x0kal,Va,Ma);   
 
            Hep3Vector meas = track.momentum(0).cross(wire).unit();
            double dchi2=-1; 
            track.smoother_Mdc(HitMdc, meas, HelixSeg, dchi2, m_csmflag);
            if(dchi2>0.0) {
                track.HelixSegs().push_back(HelixSeg);
            }
        }
 
        /// oh, to be the last hit 
 
        if(i == nhit-1){
 
            /// calculate the lsat point in MDC
            HepPoint3D point;
            point.setX(x0kal.x() + track.a()[0]*cos(track.a()[1]));
            point.setY(x0kal.y() + track.a()[0]*sin(track.a()[1]));
            point.setZ(x0kal.z() + track.a()[3]);
            track.point_last(point);
 
            /// calculate fiTerm
            double phi_old = track.a()[1];
            KalFitTrack temp(x0kal, track.a(), track.Ea(), 0, 0, 0);
            temp.pivot(ip);
            double phi_new = temp.a()[1];        
            double fi = phi_new - phi_old;
            /// for protection purpose
            //if(fabs(fi) >= CLHEP::twopi) fi = fmod(fi+2*CLHEP::twopi,CLHEP::twopi);
 
            if(fabs(fi) >= CLHEP::twopi) fi = fmod(fi+2*CLHEP::twopi,CLHEP::twopi);
 
            track.fiTerm(fi);
        }
 
        if (debug_) cout<<"track----7-----"<<track.a()<<endl;
        r0kal_prec = r0kal;
    }
}

Referenced by complete_track().

smoother_anal() [2/2]

void KalFitAlg::smoother_anal	(	KalFitTrack &	trk,
		int	way
	)

Kalman filter (smoothing or backward part)

smoother_calib() [1/2]

void KalFitAlg::smoother_calib	(	KalFitTrack &	trk,
		int	way
	)

Definition at line 2665 of file KalFitAlg.cxx.

{
 
    // retrieve Mdc  geometry information
    IMdcGeomSvc* igeomsvc;
    StatusCode sc = Gaudi::svcLocator()->service("MdcGeomSvc", igeomsvc);
    if(sc==StatusCode::FAILURE) cout << "GeoSvc failing!!!!!!!SC=" << sc << endl;
    MdcGeomSvc* geomsvc = dynamic_cast<MdcGeomSvc*>(igeomsvc);
    if(!geomsvc){
        std::cout<<"ERROR OCCUR when dynamic_cast in KalFitTrack.cxx !!"<<std::endl;
    }
 
    HepSymMatrix Eakal(5,0);
    // Estimation of the path length from ip to 1st cylinder
    HepPoint3D ip(0,0,0);
    track.pivot(ip);
    Eakal = track.getInitMatrix();
    if( debug_ == 4) {
        std::cout<<"the initial error matrix in smoothing is "<<Eakal<<std::endl;
    }   
    track.Ea(Eakal);
 
    // Mdc part :
    unsigned int nseg = track.HelixSegs().size();
    int layer_prev = -1;
 
    HepVector pos_old(3,0);
    double r0kal_prec(0);
    int  nsegs_read(0);
    for( unsigned i=0 ; i < nseg; i++ ) {
 
        int flag=0;
        int iseg = (nseg-1)-i;
        KalFitHelixSeg& HelixSeg = track.HelixSeg(iseg);
        const KalFitWire& Wire = HelixSeg.HitMdc()->wire();
 
        int wireid = Wire.geoID();
        nsegs_read++;
 
        int layer = Wire.layer().layerId();
        if (pathl_ && layer != layer_prev) {
 
            if (debug_ == 4) cout<<"in smoother,layerid "<<layer<<"  layer_prev  "
                <<layer_prev <<"  pathl_   "<<pathl_<<endl;
 
            // track.PathL(Wire.layer().layerId());
            layer_prev = layer;
        }
 
        HepPoint3D fwd(Wire.fwd());
        HepPoint3D bck(Wire.bck());
        Hep3Vector wire = (CLHEP::Hep3Vector)fwd -(CLHEP::Hep3Vector)bck;
        Helix work = *(Helix*)&track;
        work.ignoreErrorMatrix();
        work.pivot((fwd + bck) * .5);
        HepPoint3D x0kal = (work.x(0).z() - bck.z()) / wire.z() * wire + bck;
 
 
        if(4 == debug_) std::cout<<" x0kal before sag: "<<x0kal<<std::endl;
 
        if (wsag_ == 4){
 
            Hep3Vector result;
            const MdcGeoWire* geowire = geomsvc->Wire(wireid); 
            double tension = geowire->Tension();
 
            //std::cout<<" tension: "<<tension<<std::endl;
            double zinit(x0kal.z()), lzx(Wire.lzx());
 
            // double A(Wire.Acoef());
 
            double A = 47.35E-6/tension;
            double Zp = (zinit - bck.z())*lzx/wire.z();
 
            if(4 == debug_){
 
                std::cout<<" sag in smoother_calib: "<<std::endl;
                std::cout<<" x0kal.x(): "<<std::setprecision(10)<<x0kal.x()<<std::endl;
                std::cout<<" wire.x()*(zinit-bck.z())/wire.z(): "<<std::setprecision(10)
                                           <<(wire.x()*(zinit-bck.z())/wire.z())<<std::endl;
                std::cout<<"bck.x(): "<<std::setprecision(10)<<bck.x()<<std::endl;
                std::cout<<" wire.x()*(zinit-bck.z())/wire.z() + bck.x(): "<<std::setprecision(10)
                                                 <<(wire.x()*(zinit-bck.z())/wire.z() + bck.x())<<std::endl;
            }
 
            result.setX(wire.x()*(zinit-bck.z())/wire.z() + bck.x());
            result.setY((A*(Zp-lzx)+wire.y()/lzx)*Zp+bck.y());
            result.setZ((A*(2*Zp-lzx)*lzx+wire.y())/wire.z());
 
            wire.setX(wire.x()/wire.z());
            wire.setY(result.z());
            wire.setZ(1);
 
            x0kal.setX(result.x());
            x0kal.setY(result.y());
        }
 
        if(4 == debug_) std::cout<<" x0kal after sag: "<<x0kal<<std::endl;
 
 
        // If x0kal is after the inner wall and x0kal_prec before :
        double r0kal = x0kal.perp();
        if (debug_ == 4) {
            cout<<"wire direction "<<wire<<endl;
            cout<<"x0kal "<<x0kal<<endl;
            cout<<"smoother::r0kal "<<r0kal<<"  r0kal_prec  "<<r0kal_prec <<endl;
        }
 
        // change PIVOT :
        double pathl(0);
        track.pivot_numf(x0kal, pathl);
 
        if (debug_ == 4) cout<<"track----6-----"<<track.a()<<" ...path..."<<pathl
            <<"momentum"<<track.momentum(0)<<endl;
        if(KalFitElement::muls()) track.msgasmdc(pathl, way);
        if(KalFitElement::loss()) track.eloss(pathl, _BesKalmanFitMaterials[0], way);
 
        // Add info hit wire :
        if(fabs(track.kappa())>0&&fabs(track.kappa())<1000.0&&fabs(track.tanl())<7.02) {
            // attention to this measure value ,what is the measurement value !!
            Hep3Vector meas = track.momentum(0).cross(wire).unit();
 
            if(usage_>1) track.smoother_Mdc_csmalign(HelixSeg, meas,flag, m_csmflag);
            else   track.smoother_Mdc(HelixSeg, meas,flag, m_csmflag);
            // cout<<"layer, cell, track.a: "<<Wire.layer().layerId()<<" , "<<Wire.localId()<<" , "<<track.a()<<endl;
        }
 
        if (debug_) cout<<"track----7-----"<<track.a()<<endl;
        r0kal_prec = r0kal;
        // can this kind of operation be right??
        if(flag == 0) {
            track.HelixSegs().erase(track.HelixSegs().begin()+iseg);
        }
    }
}

Referenced by complete_track().

smoother_calib() [2/2]

void KalFitAlg::smoother_calib	(	KalFitTrack &	trk,
		int	way
	)

start_seed() [1/2]

void KalFitAlg::start_seed	(	KalFitTrack &	track,
		int	lead_,
		int	way,
		MdcRec_trk &	trk
	)

Definition at line 6120 of file KalFitAlg.cxx.

{
    if (debug_ == 4) 
        cout << "start_seed begin... " << std::endl;
    // keep initial helix parameters
    Hep3Vector x_init(track.pivot());
    HepSymMatrix Ea_init(5,0);
    Ea_init = track.Ea();
    HepVector a_init(5);
    a_init = track.a();
 
    // LR assumption :
    unsigned int nhit_included(10);
    int LR[8][3] = { 
        {1,1,1},
        {1,1,-1},
        {1,-1,1},
        {1,-1,-1},
        {-1,1,1},
        {-1,1,-1},
        {-1,-1,1},
        {-1,-1,-1}
    };
 
    unsigned int nhit = track.HitsMdc().size();
    double chi2_min(DBL_MAX);
    int i_min(-1);
    for (int ktrial = 0; ktrial < 8; ktrial++) {
 
        // Come back to trasan seed :
        track.pivot(x_init);
        track.a(a_init);
        track.Ea(Ea_init);
 
        track.chiSq(0);
        track.chiSq_back(0);
        track.nchits(0);
        track.nster(0);
        track.ndf_back(0);
 
        HepSymMatrix Eakal(5,0);
 
        init_matrix(choice_,TrasanTRK, Eakal);
        // initialize the Mdc hits :
        for( unsigned i=0 ; i < nhit; i++ ){
            KalFitHitMdc& HitMdc = track.HitMdc(i);
            int lr_decision(0);
            if (i<3) lr_decision = LR[ktrial][i];
            HitMdc.LR(lr_decision);
            if (i<nhit_included)
                HitMdc.chi2(0);
            else 
                HitMdc.chi2(-1);
        }
        // Mdc fit the ... first hits :
 
        if(usage_==0) filter_fwd_anal(track, lead_, way, Eakal);
        way=999;
        if(usage_>0) filter_fwd_calib(track, lead_, way, Eakal);
 
        // Check the chi2 
        if (debug_ == 4) 
            cout << "---- Result for " << ktrial << " case : chi2 = " << track.chiSq()
                << ", nhits included = " << track.nchits() << " for nhits available = "
                << nhit << std::endl;
 
        if (track.chiSq() < chi2_min && 
                (track.nchits() == nhit_included || track.nchits() == nhit)){
            chi2_min = track.chiSq();
            i_min = ktrial;
        }
    }
 
    // Initialize to the best solution :
    if (debug_ == 4) 
        cout << "*** i_min = " << i_min << " with a chi2 = " << chi2_min << std::endl;
 
    for( unsigned i=0 ; i < nhit; i++ ){
        KalFitHitMdc& HitMdc = track.HitMdc(i);
        int lr_decision(0);
        if (i_min >= 0 && i < 3) 
            lr_decision = LR[i_min][i];
        HitMdc.LR(lr_decision);
        HitMdc.chi2(0);
        HitMdc.chi2_back(0);
    }
    track.pivot(x_init);
    track.a(a_init);
    track.Ea(Ea_init);
    track.chiSq(0);
    track.chiSq_back(0);
    track.nchits(0);
    track.nster(0);
    track.ndf_back(0);
 
    // For debugging purpose :
    if (debug_ == 4) {
        for( unsigned i=0 ; i < 3; i++ ){
            KalFitHitMdc& HitMdc = track.HitMdc(i);
            cout << " LR(" << i << ") = " << HitMdc.LR()
                << ", stereo = " << HitMdc.wire().stereo() 
                << ", layer = " << HitMdc.wire().layer().layerId() << std::endl;
        }
    }
}

Referenced by kalman_fitting_anal(), kalman_fitting_calib(), kalman_fitting_csmalign(), and kalman_fitting_MdcxReco_Csmc_Sew().

start_seed() [2/2]

void KalFitAlg::start_seed	(	KalFitTrack &	track,
		int	lead_,
		int	way,
		MdcRec_trk &	trk
	)

Member Data Documentation

activeonly_

int KalFitAlg::activeonly_

Definition at line 207 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by beginRun(), execute(), initialize(), and KalFitAlg().

back_

int KalFitAlg::back_

flag to perform smoothing

Definition at line 189 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track(), initialize(), and KalFitAlg().

choice_

int KalFitAlg::choice_

Definition at line 183 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track(), KalFitAlg(), kalman_fitting_anal(), kalman_fitting_calib(), kalman_fitting_csmalign(), kalman_fitting_MdcxReco_Csmc_Sew(), and start_seed().

cylfile_

string KalFitAlg::cylfile_

Definition at line 231 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by KalFitAlg().

dchi2cut_inner_

double KalFitAlg::dchi2cut_inner_

Definition at line 235 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by KalFitAlg(), and setDchisqCut().

dchi2cut_layid2_

double KalFitAlg::dchi2cut_layid2_

Definition at line 235 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by KalFitAlg(), and setDchisqCut().

dchi2cut_layid3_

double KalFitAlg::dchi2cut_layid3_

Definition at line 235 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by KalFitAlg(), and setDchisqCut().

dchi2cut_mid1_

double KalFitAlg::dchi2cut_mid1_

Definition at line 235 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by KalFitAlg(), and setDchisqCut().

dchi2cut_mid2_

double KalFitAlg::dchi2cut_mid2_

Definition at line 235 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by KalFitAlg(), and setDchisqCut().

dchi2cut_outer_

double KalFitAlg::dchi2cut_outer_

Definition at line 235 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by KalFitAlg(), and setDchisqCut().

dchi2cutf_

double KalFitAlg::dchi2cutf_

Definition at line 233 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by initialize(), and KalFitAlg().

dchi2cuts_

double KalFitAlg::dchi2cuts_

Definition at line 233 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by initialize(), and KalFitAlg().

debug_

int KalFitAlg::debug_

Debug flag for the track finder part.

Definition at line 227 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by beginRun(), Cgem_filter_anal(), clearTables(), complete_track(), execute(), fillTds(), fillTds_back(), fillTds_ip(), fillTds_lead(), filter_fwd_anal(), filter_fwd_calib(), fitGemHits(), init_matrix(), initialize(), innerwall(), KalFitAlg(), kalman_fitting_anal(), kalman_fitting_calib(), kalman_fitting_csmalign(), kalman_fitting_MdcxReco_Csmc_Sew(), makeGemHitsCol(), set_Mdc(), smoother_anal(), smoother_calib(), and start_seed().

debug_kft_

int KalFitAlg::debug_kft_

Definition at line 227 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by initialize(), and KalFitAlg().

drifttime_choice_

int KalFitAlg::drifttime_choice_

Definition at line 222 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by initialize(), and KalFitAlg().

enhance_

int KalFitAlg::enhance_

flag to enhance the error matrix at the inner hit of Mdc (cosmic)

Definition at line 209 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track().

eventno

int KalFitAlg::eventno

Definition at line 191 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by execute().

eventNo

int KalFitAlg::eventNo

Definition at line 245 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by Cgem_filter_anal(), execute(), fillTds_back(), and residual().

fac_h1_

double KalFitAlg::fac_h1_

Definition at line 210 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track().

fac_h2_

double KalFitAlg::fac_h2_

Definition at line 210 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track().

fac_h3_

double KalFitAlg::fac_h3_

Definition at line 210 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track().

fac_h4_

double KalFitAlg::fac_h4_

Definition at line 210 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track().

fac_h5_

double KalFitAlg::fac_h5_

Definition at line 210 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track().

fitnocut_

int KalFitAlg::fitnocut_

Definition at line 220 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by fillTds(), fillTds_ip(), fillTds_lead(), and KalFitAlg().

fstrag_

double KalFitAlg::fstrag_

factor of energy loss straggling for electron

Definition at line 238 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by initialize(), and KalFitAlg().

gain1_

double KalFitAlg::gain1_

Definition at line 212 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by init_matrix(), and KalFitAlg().

gain2_

double KalFitAlg::gain2_

Definition at line 212 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by init_matrix(), and KalFitAlg().

gain3_

double KalFitAlg::gain3_

Definition at line 212 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by init_matrix(), and KalFitAlg().

gain4_

double KalFitAlg::gain4_

Definition at line 212 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by init_matrix(), and KalFitAlg().

gain5_

double KalFitAlg::gain5_

Definition at line 212 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by init_matrix(), and KalFitAlg().

i_back_

int KalFitAlg::i_back_

mass assumption for backward filter (if <0 means use leading mass)

Definition at line 224 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track(), and KalFitAlg().

i_front_

int KalFitAlg::i_front_

Definition at line 225 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track(), and KalFitAlg().

inner_steps_

int KalFitAlg::inner_steps_

Definition at line 216 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by initialize(), and KalFitAlg().

iqual_back_

int KalFitAlg::iqual_back_

Definition at line 241 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by execute(), and fillTds_back().

iqual_front_

int KalFitAlg::iqual_front_

Definition at line 241 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by execute(), fillTds_back(), fillTds_ip(), fillTds_lead(), and kalman_fitting_anal().

lead_

int KalFitAlg::lead_

leading mass assumption

Definition at line 197 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track(), fillTds_back(), fillTds_ip(), initialize(), KalFitAlg(), kalman_fitting_anal(), kalman_fitting_calib(), kalman_fitting_csmalign(), kalman_fitting_MdcxReco_Csmc_Sew(), and start_seed().

loss_

int KalFitAlg::loss_

Definition at line 207 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by fitGemHits(), fromFHitToInnerWall(), initialize(), and KalFitAlg().

lr_

int KalFitAlg::lr_

Definition at line 207 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by initialize(), and KalFitAlg().

m_alpha

double KalFitAlg::m_alpha

Definition at line 249 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by fitGemHits().

m_csmflag

int KalFitAlg::m_csmflag

Definition at line 247 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by Cgem_filter_anal(), filter_fwd_anal(), filter_fwd_calib(), KalFitAlg(), smoother_anal(), and smoother_calib().

m_dangcut

double KalFitAlg::m_dangcut

Definition at line 248 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by execute(), and KalFitAlg().

m_dphicut

double KalFitAlg::m_dphicut

Definition at line 248 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by execute(), and KalFitAlg().

m_usevtxdb

int KalFitAlg::m_usevtxdb

Definition at line 246 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by KalFitAlg(), and smoother_anal().

matfile_

string KalFitAlg::matfile_

Definition at line 231 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by KalFitAlg().

matrixg_

double KalFitAlg::matrixg_

Definition at line 210 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track(), fillTds_back(), init_matrix(), initialize(), KalFitAlg(), kalman_fitting_anal(), kalman_fitting_calib(), kalman_fitting_csmalign(), kalman_fitting_MdcxReco_Csmc_Sew(), and smoother_anal().

mhyp_

int KalFitAlg::mhyp_

Definition at line 199 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track(), and initialize().

muls_

int KalFitAlg::muls_

Flag account to multiple scattering and energy loss, where lr flag from and whether use active hits only

Definition at line 207 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by beginRun(), fitGemHits(), fromFHitToInnerWall(), initialize(), and KalFitAlg().

ntuple_

int KalFitAlg::ntuple_

Fill ntuples of KalFit.

Definition at line 229 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by execute(), fillTds_back(), filter_fwd_anal(), filter_fwd_calib(), fitGemHits(), hist_def(), initialize(), KalFitAlg(), kalman_fitting_anal(), kalman_fitting_calib(), kalman_fitting_csmalign(), and kalman_fitting_MdcxReco_Csmc_Sew().

numf_

int KalFitAlg::numf_

Definition at line 215 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by initialize(), and KalFitAlg().

numf_in_

int KalFitAlg::numf_in_

Definition at line 218 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

numf_out_

int KalFitAlg::numf_out_

Definition at line 219 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

numfcor_

int KalFitAlg::numfcor_

Definition at line 214 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by initialize(), and KalFitAlg().

outer_steps_

int KalFitAlg::outer_steps_

Definition at line 217 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by initialize(), and KalFitAlg().

pathl_

int KalFitAlg::pathl_

Definition at line 185 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by fillTds_back(), initialize(), smoother_anal(), and smoother_calib().

pe_cut_

double KalFitAlg::pe_cut_

value of the momentum cut to decide refit

Definition at line 201 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track(), and KalFitAlg().

pk_cut_

double KalFitAlg::pk_cut_

Definition at line 201 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track(), and KalFitAlg().

pmu_cut_

double KalFitAlg::pmu_cut_

Definition at line 201 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track(), and KalFitAlg().

pp_cut_

double KalFitAlg::pp_cut_

Definition at line 201 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track(), and KalFitAlg().

ppi_cut_

double KalFitAlg::ppi_cut_

Definition at line 201 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track(), and KalFitAlg().

pT_

double KalFitAlg::pT_

value of the pT cut for backward filter

Definition at line 195 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track(), initialize(), and KalFitAlg().

pt_cut_

double KalFitAlg::pt_cut_

Definition at line 202 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track(), KalFitAlg(), kalman_fitting_anal(), kalman_fitting_calib(), kalman_fitting_csmalign(), and kalman_fitting_MdcxReco_Csmc_Sew().

resolution_

int KalFitAlg::resolution_

Definition at line 240 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by initialize(), and KalFitAlg().

steplev_

int KalFitAlg::steplev_

Definition at line 213 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by initialize(), and KalFitAlg().

Tds_back_no

int KalFitAlg::Tds_back_no

Definition at line 193 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

theta_cut_

double KalFitAlg::theta_cut_

Definition at line 202 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track(), KalFitAlg(), kalman_fitting_anal(), kalman_fitting_calib(), kalman_fitting_csmalign(), and kalman_fitting_MdcxReco_Csmc_Sew().

tof_hyp_

int KalFitAlg::tof_hyp_

Definition at line 207 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by initialize(), and KalFitAlg().

tofflag_

int KalFitAlg::tofflag_

Definition at line 207 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by initialize(), and KalFitAlg().

tprop_

int KalFitAlg::tprop_

propagation correction

Definition at line 244 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by initialize(), and KalFitAlg().

usage_

int KalFitAlg::usage_

this usage is used to control the usage of this algorithm ,to be analysis or calibration.

Definition at line 181 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by complete_track(), execute(), fillTds_back(), filter_fwd_calib(), KalFitAlg(), setDchisqCut(), smoother_calib(), and start_seed().

wsag_

int KalFitAlg::wsag_

flag to take account the wire sag into account

Definition at line 187 of file InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h.

Referenced by execute(), filter_fwd_anal(), filter_fwd_calib(), initialize(), KalFitAlg(), smoother_anal(), and smoother_calib().

---

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

• InstallArea/include/KalFitAlg/KalFitAlg/KalFitAlg.h
• Reconstruction/KalFitAlg/KalFitAlg-00-15-08/KalFitAlg/KalFitAlg.h
• KalFitAlg.cxx
• KalFitAlg2.cxx
• KalFitReadGdml.cxx