EGraphRecProc Class Reference

#include <EGraphRecProc.h>

Collaboration diagram for EGraphRecProc:

Public Member Functions
	EGraphRecProc ()
void	SetBrickToProc (ProcBrick_t &brickToProc)
void	SetProcId (ProcId_t &procId)
void	SetScanProc (EdbScanProc *scanProc)
void	SetVertexRecOpt (VertexRecOpt_t &recOpt)
EdbPVRec *	VertexRec ()
virtual	~EGraphRecProc ()

Private Member Functions
void	PropagateTracks ()
void	SetCondBT ()
void	SetEVR ()

Private Attributes
ProcBrick_t	fBrickToProc
Float_t	fMass
	particle mass More...
Float_t	fMomentum
	GeV. More...
Int_t	fNgapmax
	maximal gap for propagation More...
Int_t	fNsegmin
	minimal number of segments to propagate this track More...
Float_t	fProbMinP
	minimal probability to accept segment on propagation More...
ProcId_t	fProcId
EdbPVRec *	fPVRec
EdbScanCond *	fScanCond
EdbScanProc *	fScanProc
EdbScanSet *	fScanSetVTX
EdbVertexRec *	fVertexRec
VertexRecOpt_t	fVertexRecOpt

Constructor & Destructor Documentation

EGraphRecProc()

EGraphRecProc::EGraphRecProc

(

)

{
  fNsegmin  = 1;     // minimal number of segments to propagate this track
  fNgapmax  = 2;     // maximal gap for propagation
  fMomentum = 0.5;   // GeV
  fMass     = 0.139; // particle mass
  fProbMinP = 0.001; // minimal probability to accept segment on propagation
 
  fScanSetVTX  = NULL;
  fVertexRec   = NULL;
  fPVRec       = NULL;
  fScanCond    = new EdbScanCond();
}

~EGraphRecProc()

EGraphRecProc::~EGraphRecProc ( )

virtual

{
  SafeDelete(fScanCond);
  SafeDelete(fScanSetVTX);
  SafeDelete(fPVRec);
}

Member Function Documentation

PropagateTracks()

void EGraphRecProc::PropagateTracks ( )

private

example of additional propagation and other tracking operations if necessary

{
 
  Int_t ntracks = fPVRec->eTracks->GetEntries();
 
  // set tracks IDs
 
  for (Int_t i = 0; i < ntracks; i++) {
    EdbTrackP *track = (EdbTrackP*)(fPVRec->eTracks->At(i));
    track->SetID(i);
    track->SetSegmentsTrack();
    track->SetErrorP(0.2*0.2*fMomentum*fMomentum);
 
    if (track->Flag() < 0) continue;
    fPVRec->PropagateTrack(*track, true, 0.001, 3, 0);
  }
}

SetBrickToProc()

void EGraphRecProc::SetBrickToProc ( ProcBrick_t &  brickToProc )

inline

{fBrickToProc = brickToProc;}

SetCondBT()

void EGraphRecProc::SetCondBT ( )

private

{
  fScanCond->SetDefault();
 
  // sigma0 "x, y, tx, ty" at zero angle
 
  fScanCond->SetSigma0(5., 5., 0.002, 0.002); 
  fScanCond->SetDegrad(5.);             // sigma(tx) = sigma0*(1+degrad*tx)
  fScanCond->SetBins(3, 3, 3, 3);       // bins in [sigma] for checks
  fScanCond->SetPulsRamp0(5., 5.);      // in range (Pmin:Pmax) Signal/All 
                                        // is nearly linear
  fScanCond->SetPulsRamp04(5., 5.);
  fScanCond->SetChi2Max(6.5);
  fScanCond->SetChi2PMax(6.5);
  fScanCond->SetChi2Mode(3);
  fScanCond->SetRadX0(5810.);
  fScanCond->SetName("OPERA_basetrack");
}

SetEVR()

void EGraphRecProc::SetEVR ( )

private

{
  SafeDelete(fVertexRec);
  fVertexRec = new EdbVertexRec();
 
  fVertexRec->eEdbTracks   = fPVRec->eTracks;
  fVertexRec->eVTX         = fPVRec->eVTX;
  fVertexRec->SetPVRec(fPVRec);
  fVertexRec->eDZmax       = fVertexRecOpt.DZmax;
  fVertexRec->eProbMin     = fVertexRecOpt.ProbMinV;
  fVertexRec->eImpMax      = fVertexRecOpt.ImpMax;
  fVertexRec->eUseMom      = fVertexRecOpt.UseMom;
  fVertexRec->eUseSegPar   = fVertexRecOpt.UseSegPar;
  fVertexRec->eQualityMode = fVertexRecOpt.QualityMode;
}

SetProcId()

void EGraphRecProc::SetProcId ( ProcId_t &  procId )

inline

{fProcId = procId;}

SetScanProc()

void EGraphRecProc::SetScanProc ( EdbScanProc *  scanProc )

inline

{fScanProc = scanProc;}

SetVertexRecOpt()

void EGraphRecProc::SetVertexRecOpt ( VertexRecOpt_t &  recOpt )

inline

{fVertexRecOpt = recOpt;}

VertexRec()

EdbPVRec * EGraphRecProc::VertexRec

(

)

Vertex reconstruction

{
 
  SafeDelete(fScanSetVTX);
  SafeDelete(fPVRec);
 
  fScanSetVTX = new EdbScanSet();
  fPVRec      = new EdbPVRec();
 
  SetCondBT(); // init track reconstruction conditions
  fPVRec->SetScanCond(fScanCond);
 
  // brick initialization
 
  Int_t pID_VS[4] = {fBrickToProc.brickId, 0, fBrickToProc.ver,
             fProcId.volumeScan};
 
  Int_t firstPlate = fBrickToProc.firstPlate;
  Int_t lastPlate  = fBrickToProc.lastPlate;
  Int_t step=(lastPlate>=firstPlate)?fBrickToProc.step : -1*fBrickToProc.step;
  
  fScanSetVTX->Brick().SetID(fBrickToProc.brickId);
 
  // make a brick assuming that all plates are linked and aligned
 
  for (Int_t plate = firstPlate; plate != lastPlate + step; plate += step) {
    pID_VS[1] = plate;
    fScanSetVTX->AddID(new EdbID(pID_VS), step);
  }
 
  fScanProc->AssembleScanSet(*fScanSetVTX);
  fScanSetVTX->SetAsReferencePlate(firstPlate);
 
  // get the tracks passing through our cuts
 
  TCut cut = "eN1==1&&eN2==1&&eCHI2P<3.5&&s.eW>16";
  TCut QC = "s.eW>15+3*s.eChi2";
  cut += QC;
 
  fScanProc->ReadScanSetCP(*fScanSetVTX, *fPVRec, cut);
 
  // tracking
 
  fPVRec->SetCouplesPeriodic(0,1);
  EdbDataProc::LinkTracksWithFlag(fPVRec, fMomentum, fProbMinP, fNsegmin,
                  fNgapmax, 0);
 
  PropagateTracks();
  fPVRec->FillCell(30,30,0.009,0.009);
  SetEVR();
 
  cout << fVertexRec->eEdbTracks->GetEntries() << " tracks for vertexing" 
       << endl;
  cout << fVertexRec->FindVertex() << " 2-track vertexes was found" << endl;
  fVertexRec->ProbVertexN();
 
  fPVRec->eVTX = fVertexRec->eVTX;
 
  return fPVRec;
}

Member Data Documentation

fBrickToProc

ProcBrick_t EGraphRecProc::fBrickToProc

private

fMass

Float_t EGraphRecProc::fMass

private

particle mass

fMomentum

Float_t EGraphRecProc::fMomentum

private

GeV.

fNgapmax

Int_t EGraphRecProc::fNgapmax

private

maximal gap for propagation

fNsegmin

Int_t EGraphRecProc::fNsegmin

private

minimal number of segments to propagate this track

fProbMinP

Float_t EGraphRecProc::fProbMinP

private

minimal probability to accept segment on propagation

fProcId

ProcId_t EGraphRecProc::fProcId

private

fPVRec

EdbPVRec* EGraphRecProc::fPVRec

private

fScanCond

EdbScanCond* EGraphRecProc::fScanCond

private

fScanProc

EdbScanProc* EGraphRecProc::fScanProc

private

fScanSetVTX

EdbScanSet* EGraphRecProc::fScanSetVTX

private

fVertexRec

EdbVertexRec* EGraphRecProc::fVertexRec

private

fVertexRecOpt

VertexRecOpt_t EGraphRecProc::fVertexRecOpt

private

---

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

• /home/antonio/fedra_doxygen/src/libEGraphTool/EGraphRecProc.h
• /home/antonio/fedra_doxygen/src/libEGraphTool/EGraphRecProc.cxx