diff --git a/analysis/PWGDIL/dimuon/CbmAnaDimuonAnalysis.cxx b/analysis/PWGDIL/dimuon/CbmAnaDimuonAnalysis.cxx
index 3e912ea02badbd694a787f22c0187ccb29d6a4bb..d83ff362d8973d1e7eba7bc76d12b12382ea6af4 100644
--- a/analysis/PWGDIL/dimuon/CbmAnaDimuonAnalysis.cxx
+++ b/analysis/PWGDIL/dimuon/CbmAnaDimuonAnalysis.cxx
@@ -17,9 +17,6 @@
#include "CbmAnaMuonCandidate.h"
#include "CbmGlobalTrack.h"
-#include "CbmGlobalTrackFitterKF.h"
-#include "CbmKFTrack.h"
-#include "CbmKFVertex.h"
#include "CbmMCTrack.h"
#include "CbmMatch.h"
#include "CbmMuchGeoScheme.h"
@@ -81,7 +78,6 @@ CbmAnaDimuonAnalysis::CbmAnaDimuonAnalysis(TString name, TString setup)
, fInputTree(NULL)
, fPlutoFile(NULL)
, fFitter(NULL)
- , fFitterGlobal(NULL)
, fVertex(NULL)
, fChi2StsCut(2)
, fChi2MuchCut(3)
@@ -160,9 +156,6 @@ InitStatus CbmAnaDimuonAnalysis::Init()
fFitter = new CbmStsKFTrackFitter();
fFitter->Init();
- fFitterGlobal = new CbmGlobalTrackFitterKF();
- fFitterGlobal->Init();
-
YPt_pluto = new TH2D("YPt_pluto", "PLUTO signal", YBINNING, PTBINNING);
if (fPlutoFileName != "") {
diff --git a/analysis/PWGDIL/dimuon/CbmAnaDimuonAnalysis.h b/analysis/PWGDIL/dimuon/CbmAnaDimuonAnalysis.h
index e7e5f12bd6d168a3f76c1c90201ae048421ed95f..ab671dd18f06c787dfe39ec94580d8891524dee7 100644
--- a/analysis/PWGDIL/dimuon/CbmAnaDimuonAnalysis.h
+++ b/analysis/PWGDIL/dimuon/CbmAnaDimuonAnalysis.h
@@ -27,7 +27,6 @@ class CbmMuchTrack;
class CbmTofHit;
class CbmMuchGeoScheme;
class CbmStsKFTrackFitter;
-class CbmGlobalTrackFitterKF;
class CbmVertex;
class TClonesArray;
class TLorentzVector;
@@ -98,7 +97,6 @@ class CbmAnaDimuonAnalysis : public FairTask {
TFile* fPlutoFile;
CbmStsKFTrackFitter* fFitter;
- CbmGlobalTrackFitterKF* fFitterGlobal;
CbmVertex* fVertex;
diff --git a/analysis/PWGHAD/hadron/CbmHadronAnalysis.cxx b/analysis/PWGHAD/hadron/CbmHadronAnalysis.cxx
index b1da44180deb967ae02a4b5e150ccb9fed3b6326..b57089af1eb43e5cc0e0b77500293afa1da82d12 100644
--- a/analysis/PWGHAD/hadron/CbmHadronAnalysis.cxx
+++ b/analysis/PWGHAD/hadron/CbmHadronAnalysis.cxx
@@ -15,7 +15,6 @@ using namespace std;
#include "CbmGlobalTrack.h"
#include "CbmHadron.h"
#include "CbmHadronAnalysis.h"
-#include "CbmKFVertex.h"
#include "CbmLink.h"
#include "CbmMCDataArray.h"
#include "CbmMCDataManager.h"
diff --git a/reco/KF/CbmKFSecondaryVertexFinder.cxx b/reco/KF/CbmKFSecondaryVertexFinder.cxx
deleted file mode 100644
index 10dc46bc25bb657b2751229dd34cbb81812d49e7..0000000000000000000000000000000000000000
--- a/reco/KF/CbmKFSecondaryVertexFinder.cxx
+++ /dev/null
@@ -1,672 +0,0 @@
-/* Copyright (C) 2006-2016 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Sergey Gorbunov, Ivan Kisel, Denis Bertini [committer] */
-
-/** Implementation of the CbmKFSecondaryVertexFinder class
- *
- * @author S.Gorbunov, I.Kisel
- * @version 1.0
- * @since 06.02.06
- *
- */
-
-#include "CbmKFSecondaryVertexFinder.h"
-
-#include "CbmKF.h"
-#include "CbmKFTrack.h"
-
-#include <cmath>
-
-using std::fabs;
-using std::vector;
-
-ClassImp(CbmKFSecondaryVertexFinder)
-
- void CbmKFSecondaryVertexFinder::Clear(Option_t* /*opt*/)
-{
- vTracks.clear();
- VGuess = nullptr;
- VParent = nullptr;
- MassConstraint = -1;
-}
-
-void CbmKFSecondaryVertexFinder::ClearTracks() { vTracks.clear(); }
-
-void CbmKFSecondaryVertexFinder::AddTrack(CbmKFTrackInterface* Track) { vTracks.push_back(Track); }
-
-void CbmKFSecondaryVertexFinder::SetTracks(vector<CbmKFTrackInterface*>& vTr) { vTracks = vTr; }
-
-void CbmKFSecondaryVertexFinder::SetApproximation(CbmKFVertexInterface* Guess) { VGuess = Guess; }
-
-void CbmKFSecondaryVertexFinder::SetMassConstraint(Double_t MotherMass) { MassConstraint = MotherMass; }
-
-void CbmKFSecondaryVertexFinder::SetTopoConstraint(CbmKFVertexInterface* VP) { VParent = VP; }
-
-void CbmKFSecondaryVertexFinder::Fit()
-{
- const Int_t MaxIter = 3;
-
- if (VGuess) {
- r[0] = VGuess->GetRefX();
- r[1] = VGuess->GetRefY();
- r[2] = VGuess->GetRefZ();
- }
- else {
- if (CbmKF::Instance()->vTargets.empty()) {
- r[0] = r[1] = r[2] = 0.;
- }
- else {
- CbmKFTube& t = CbmKF::Instance()->vTargets[0];
- r[0] = r[1] = 0.;
- r[2] = t.z;
- }
- }
-
- r[3] = 0;
- r[4] = 0;
- r[5] = 0;
- r[6] = 0;
- r[7] = 0;
-
- for (Int_t iteration = 0; iteration < MaxIter; ++iteration) {
-
- for (int i = 0; i < 8; i++) {
- r0[i] = r[i];
- }
-
- r[3] = 0;
- r[4] = 0;
- r[5] = 0;
- r[6] = 0;
-
- for (Int_t i = 0; i < 36; ++i) {
- C[i] = 0.0;
- }
-
- C[0] = C[2] = C[5] = 100.0;
- C[35] = 1.E4;
- NDF = -3;
- Chi2 = 0.;
-
- for (vector<CbmKFTrackInterface*>::iterator tr = vTracks.begin(); tr != vTracks.end(); ++tr) {
- CbmKFTrack T(**tr);
-
- T.Extrapolate(r0[2]);
-
- Double_t* m = T.GetTrack();
- Double_t* V = T.GetCovMatrix();
-
- //* Fit of vertex track slopes and momentum (a,b,qp) to r0 vertex
-
- Double_t a = m[2], b = m[3], qp = m[4];
- {
- Double_t s = V[0] * V[2] - V[1] * V[1];
- s = (s > 1.E-20) ? 1. / s : 0;
- Double_t zetas[2] = {(r0[0] - m[0]) * s, (r0[1] - m[1]) * s};
- a += (V[3] * V[2] - V[4] * V[1]) * zetas[0] + (-V[3] * V[1] + V[4] * V[0]) * zetas[1];
- b += (V[6] * V[2] - V[7] * V[1]) * zetas[0] + (-V[6] * V[1] + V[7] * V[0]) * zetas[1];
- qp += (V[10] * V[2] - V[11] * V[1]) * zetas[0] + (-V[10] * V[1] + V[11] * V[0]) * zetas[1];
- }
-
- //* convert the track to (x,y,px,py,pz,e) parameterization
- double mm[6], VV[21];
- {
- double c2 = 1. / (1. + a * a + b * b);
- double p = 1. / qp;
- double p2 = p * p;
- double pz = sqrt(p2 * c2);
- double px = a * pz;
- double py = b * pz;
- double E = sqrt(T.GetMass() * T.GetMass() + p2);
-
- double da = (m[2] - a);
- double db = (m[3] - b);
- double dq = (m[4] - qp);
-
- double H[3] = {-px * c2, -py * c2, -pz * p};
- double HE = -p * p2 / E;
-
- double dpz = H[0] * da + H[1] * db + H[2] * dq;
-
- mm[0] = m[0];
- mm[1] = m[1];
- mm[2] = px + da + a * dpz;
- mm[3] = py + db + b * dpz;
- mm[4] = pz + dpz;
- mm[5] = E + HE * dq;
-
- double cxpz = H[0] * V[3] + H[1] * V[6] + H[2] * V[10];
- double cypz = H[0] * V[4] + H[1] * V[7] + H[2] * V[11];
- double capz = H[0] * V[5] + H[1] * V[8] + H[2] * V[12];
- double cbpz = H[0] * V[8] + H[1] * V[9] + H[2] * V[13];
- double cqpz = H[0] * V[12] + H[1] * V[13] + H[2] * V[14];
- double cpzpz = H[0] * H[0] * V[5] + H[1] * H[1] * V[9] + H[2] * H[2] * V[14]
- + 2 * (H[0] * H[1] * V[8] + H[0] * H[2] * V[12] + H[1] * H[2] * V[13]);
-
- VV[0] = V[0];
- VV[1] = V[1];
- VV[2] = V[2];
- VV[3] = V[3] * pz + a * cxpz;
- VV[4] = V[4] * pz + a * cypz;
- VV[5] = V[5] * pz * pz + 2 * a * pz * capz + a * a * cpzpz;
- VV[6] = V[6] * pz + b * cxpz;
- VV[7] = V[7] * pz + b * cypz;
- VV[8] = V[8] * pz * pz + a * pz * cbpz + b * pz * capz + a * b * cpzpz;
- VV[9] = V[9] * pz * pz + 2 * b * pz * cbpz + b * b * cpzpz;
- VV[10] = cxpz;
- VV[11] = cypz;
- VV[12] = capz * pz + a * cpzpz;
- VV[13] = cbpz * pz + b * cpzpz;
- VV[14] = cpzpz;
- VV[15] = HE * V[10];
- VV[16] = HE * V[11];
- VV[17] = HE * (V[12] * pz + a * cqpz);
- VV[18] = HE * (V[13] * pz + b * cqpz);
- VV[19] = HE * cqpz;
- VV[20] = HE * HE * V[14];
- }
-
-
- //* Measure the state vector with the track estimate
-
- Chi2 += T.GetRefChi2();
- NDF += T.GetRefNDF() - 3;
-
- //* Update the state vector with the momentum part of the track estimate
-
- r[3] += mm[2];
- r[4] += mm[3];
- r[5] += mm[4];
- r[6] += mm[5];
-
- C[9] += VV[5];
- C[13] += VV[8];
- C[14] += VV[9];
- C[18] += VV[12];
- C[19] += VV[13];
- C[20] += VV[14];
- C[24] += VV[17];
- C[25] += VV[18];
- C[26] += VV[19];
- C[27] += VV[20];
-
- NDF += 3;
- Chi2 += 0.;
-
- //* Update the state vector with the coordinate part of the track estimate
-
- //* Residual (measured - estimated)
-
- Double_t zeta[2] = {mm[0] - (r[0] - a * (r[2] - r0[2])), mm[1] - (r[1] - b * (r[2] - r0[2]))};
-
- //* Measurement matrix H= { { 1, 0, -a, 0..0}, { 0, 1, -b,0..0} };
-
- //* S = (H*C*H' + V )^{-1}
-
- Double_t S[3] = {VV[0] + C[0] - 2 * a * C[3] + a * a * C[5], VV[1] + C[1] - b * C[3] - a * C[4] + a * b * C[5],
- VV[2] + C[2] - 2 * b * C[4] + b * b * C[5]};
-
- //* Invert S
- {
- Double_t s = S[0] * S[2] - S[1] * S[1];
-
- if (s < 1.E-20) {
- continue;
- }
- s = 1. / s;
- Double_t S0 = S[0];
- S[0] = s * S[2];
- S[1] = -s * S[1];
- S[2] = s * S0;
- }
-
- //* CHt = CH' - D'
-
- Double_t CHt0[7], CHt1[7];
-
- CHt0[0] = C[0] - a * C[3];
- CHt1[0] = C[1] - b * C[3];
- CHt0[1] = C[1] - a * C[4];
- CHt1[1] = C[2] - b * C[4];
- CHt0[2] = C[3] - a * C[5];
- CHt1[2] = C[4] - b * C[5];
- CHt0[3] = C[6] - a * C[8] - VV[3];
- CHt1[3] = C[7] - b * C[8] - VV[4];
- CHt0[4] = C[10] - a * C[12] - VV[6];
- CHt1[4] = C[11] - b * C[12] - VV[7];
- CHt0[5] = C[15] - a * C[17] - VV[10];
- CHt1[5] = C[16] - b * C[17] - VV[11];
- CHt0[6] = C[21] - a * C[23] - VV[15];
- CHt1[6] = C[22] - b * C[23] - VV[16];
-
- //* Kalman gain K = CH'*S
-
- Double_t K0[7], K1[7];
-
- for (Int_t i = 0; i < 7; ++i) {
- K0[i] = CHt0[i] * S[0] + CHt1[i] * S[1];
- K1[i] = CHt0[i] * S[1] + CHt1[i] * S[2];
- }
-
- //* New estimation of the vertex position r += K*zeta
-
- for (Int_t i = 0; i < 7; ++i) {
- r[i] += K0[i] * zeta[0] + K1[i] * zeta[1];
- }
-
- //* New covariance matrix C -= K*(CH')'
-
- for (Int_t i = 0, k = 0; i < 7; ++i) {
- for (Int_t j = 0; j <= i; ++j, ++k) {
- C[k] -= K0[i] * CHt0[j] + K1[i] * CHt1[j];
- }
- }
-
- //* Calculate Chi^2 & NDF
-
- NDF += 2;
- Chi2 += zeta[0] * zeta[0] * S[0] + 2 * zeta[0] * zeta[1] * S[1] + zeta[1] * zeta[1] * S[2];
-
- } // add tracks
-
- // Put constraints if they exist
-
- AddTopoConstraint();
- AddMassConstraint();
-
- } // iterations
-}
-
-
-void CbmKFSecondaryVertexFinder::GetVertex(CbmKFVertexInterface& vtx)
-{
- vtx.GetRefX() = r[0];
- vtx.GetRefY() = r[1];
- vtx.GetRefZ() = r[2];
- for (int i = 0; i < 6; i++) {
- vtx.GetCovMatrix()[i] = C[i];
- }
- vtx.GetRefChi2() = Chi2;
- vtx.GetRefNDF() = NDF;
-}
-
-void CbmKFSecondaryVertexFinder::GetVertex(CbmVertex& vtx)
-{
- CbmKFVertexInterface vi;
- GetVertex(vi);
- vi.GetVertex(vtx);
-}
-
-
-void CbmKFSecondaryVertexFinder::GetMotherTrack(Double_t Par[], Double_t Cov[])
-{
-
- if (!Par) {
- return;
- }
-
- Double_t px = r[3], py = r[4], pz = r[5];
-
- Double_t p = sqrt(px * px + py * py + pz * pz);
- double pzi = 1 / pz;
- double qp = 1 / p;
- Par[0] = r[0];
- Par[1] = r[1];
- Par[2] = px * pzi;
- Par[3] = py * pzi;
- Par[4] = qp;
- Par[5] = r[2];
-
- if (!Cov) {
- return;
- }
-
- double qp3 = qp * qp * qp;
- Double_t J[5][6];
-
- for (Int_t i = 0; i < 5; i++) {
- for (Int_t j = 0; j < 6; ++j) {
- J[i][j] = 0.0;
- }
- }
-
-
- J[0][0] = 1;
- J[0][2] = -Par[2];
- J[1][1] = 1;
- J[1][2] = -Par[3];
- J[2][3] = pzi;
- J[2][5] = -Par[2] * pzi;
- J[3][4] = pzi;
- J[3][5] = -Par[3] * pzi;
- J[4][3] = -qp3 * px;
- J[4][4] = -qp3 * py;
- J[4][4] = -qp3 * pz;
-
- Double_t JC[5][6];
-
- for (Int_t i = 0; i < 5; i++) {
- for (Int_t j = 0; j < 6; j++) {
- JC[i][j] = 0;
- for (Int_t k = 0; k < 6; k++) {
- JC[i][j] += J[i][k] * Cij(k, j);
- }
- }
- }
-
- Int_t ii = 0;
- for (Int_t i = 0; i < 5; i++) {
- for (Int_t j = i; j < 5; j++, ii++) {
- Cov[ii] = 0;
- for (Int_t k = 0; k < 6; k++) {
- Cov[ii] += JC[i][k] * J[j][k];
- }
- }
- }
-}
-
-
-void CbmKFSecondaryVertexFinder::GetMass(Double_t* M, Double_t* Error_)
-{
- // S = sigma^2 of m2/2
-
- Double_t S = (r[3] * r[3] * C[9] + r[4] * r[4] * C[14] + r[5] * r[5] * C[20] + r[6] * r[6] * C[27]
- + 2
- * (+r[3] * r[4] * C[13] + r[5] * (r[3] * C[18] + r[4] * C[19])
- - r[6] * (r[3] * C[24] + r[4] * C[25] + r[5] * C[26])));
- Double_t m2 = r[6] * r[6] - r[3] * r[3] - r[4] * r[4] - r[5] * r[5];
-
- if (M) {
- *M = (m2 > 1.e-20) ? sqrt(m2) : 0.;
- }
- if (Error_) {
- *Error_ = (S >= 0 && m2 > 1.e-20) ? sqrt(S / m2) : 1.e4;
- }
-}
-
-
-void CbmKFSecondaryVertexFinder::AddMassConstraint()
-{
- if (MassConstraint < 0) {
- return;
- }
- double H[8];
- H[0] = H[1] = H[2] = 0.;
- H[3] = -2 * r0[3];
- H[4] = -2 * r0[4];
- H[5] = -2 * r0[5];
- H[6] = 2 * r0[6];
- H[7] = 0;
- double m2 = r0[6] * r0[6] - r0[3] * r0[3] - r0[4] * r0[4] - r0[5] * r0[5];
-
- double zeta = MassConstraint * MassConstraint - m2;
- for (Int_t i = 0; i < 8; ++i) {
- zeta -= H[i] * (r[i] - r0[i]);
- }
-
- Double_t S = 0.;
- Double_t CHt[8];
- for (Int_t i = 0; i < 8; ++i) {
- CHt[i] = 0.0;
- for (Int_t j = 0; j < 8; ++j) {
- CHt[i] += Cij(i, j) * H[j];
- }
- S += H[i] * CHt[i];
- }
-
- if (S < 1.e-20) {
- return;
- }
- S = 1. / S;
- Chi2 += zeta * zeta * S;
- NDF += 1;
- for (Int_t i = 0, ii = 0; i < 8; ++i) {
- Double_t Ki = CHt[i] * S;
- r[i] += Ki * zeta;
- for (Int_t j = 0; j <= i; ++j) {
- C[ii++] -= Ki * CHt[j];
- }
- }
-}
-
-
-void CbmKFSecondaryVertexFinder::Extrapolate(double T)
-{
-
- r0[0] += T * r0[3];
- r0[1] += T * r0[4];
- r0[2] += T * r0[5];
-
- r[0] += T * r[3];
- r[1] += T * r[4];
- r[2] += T * r[5];
-
- double C30 = C[6] + T * C[9];
- double C41 = C[11] + T * C[14];
- double C52 = C[17] + T * C[20];
- double T54 = T * C[19];
-
- C[0] += T * (C[6] + C30);
- C[1] += T * (C[7] + C[10]);
- C[2] += T * (C[11] + C41);
- C[10] += T * C[13];
- C[6] = C30;
- C[11] = C41;
-
- C[15] += T * C[18];
- C[16] += T54;
- C[3] += T * (C[8] + C[15]);
- C[4] += T * (C[12] + C[16]);
- C[5] += T * (C[17] + C52);
- C[17] = C52;
- C[12] += T54;
-
- C[7] += T * C[13];
- C[8] += T * C[18];
-
- C[21] += T * C[24];
- C[22] += T * C[25];
- C[23] += T * C[26];
- C[28] += T * C[31];
- C[29] += T * C[32];
- C[30] += T * C[33];
-}
-
-void CbmKFSecondaryVertexFinder::AddTopoConstraint()
-{
- if (!VParent) {
- return;
- }
-
- double m[3], *V;
- {
- m[0] = VParent->GetRefX();
- m[1] = VParent->GetRefY();
- m[2] = VParent->GetRefZ();
- V = VParent->GetCovMatrix();
- }
-
- Extrapolate(-r0[7]);
-
- {
- double inf = 1.e8;
- double xinf = r0[0] * inf;
- double yinf = r0[1] * inf;
- double zinf = r0[2] * inf;
- C[0] += r0[0] * xinf;
- C[1] += r0[0] * yinf;
- C[2] += r0[1] * yinf;
- C[3] += r0[0] * zinf;
- C[4] += r0[1] * zinf;
- C[5] += r0[2] * zinf;
- C[28] = -2 * xinf;
- C[29] = -2 * yinf;
- C[30] = -2 * zinf;
- C[31] = 0;
- C[32] = 0;
- C[33] = 0;
- C[34] = 0;
- C[35] = inf;
- }
- r[7] = r0[7];
-
- double Ai[6];
- Ai[0] = C[4] * C[4] - C[2] * C[5];
- Ai[1] = C[1] * C[5] - C[3] * C[4];
- Ai[3] = C[2] * C[3] - C[1] * C[4];
- double det = (C[0] * Ai[0] + C[1] * Ai[1] + C[3] * Ai[3]);
- det = (det > 1.e-8) ? 1. / det : 0;
- Ai[0] *= det;
- Ai[1] *= det;
- Ai[3] *= det;
- Ai[2] = (C[3] * C[3] - C[0] * C[5]) * det;
- Ai[4] = (C[0] * C[4] - C[1] * C[3]) * det;
- Ai[5] = (C[1] * C[1] - C[0] * C[2]) * det;
-
- double B[5][3];
- B[0][0] = C[6] * Ai[0] + C[7] * Ai[1] + C[8] * Ai[3];
- B[0][1] = C[6] * Ai[1] + C[7] * Ai[2] + C[8] * Ai[4];
- B[0][2] = C[6] * Ai[3] + C[7] * Ai[4] + C[8] * Ai[5];
-
- B[1][0] = C[10] * Ai[0] + C[11] * Ai[1] + C[12] * Ai[3];
- B[1][1] = C[10] * Ai[1] + C[11] * Ai[2] + C[12] * Ai[4];
- B[1][2] = C[10] * Ai[3] + C[11] * Ai[4] + C[12] * Ai[5];
-
- B[2][0] = C[15] * Ai[0] + C[16] * Ai[1] + C[17] * Ai[3];
- B[2][1] = C[15] * Ai[1] + C[16] * Ai[2] + C[17] * Ai[4];
- B[2][2] = C[15] * Ai[3] + C[16] * Ai[4] + C[17] * Ai[5];
-
- B[3][0] = C[21] * Ai[0] + C[22] * Ai[1] + C[23] * Ai[3];
- B[3][1] = C[21] * Ai[1] + C[22] * Ai[2] + C[23] * Ai[4];
- B[3][2] = C[21] * Ai[3] + C[22] * Ai[4] + C[23] * Ai[5];
-
- B[4][0] = C[28] * Ai[0] + C[29] * Ai[1] + C[30] * Ai[3];
- B[4][1] = C[28] * Ai[1] + C[29] * Ai[2] + C[30] * Ai[4];
- B[4][2] = C[28] * Ai[3] + C[29] * Ai[4] + C[30] * Ai[5];
-
- double z[3] = {m[0] - r[0], m[1] - r[1], m[2] - r[2]};
- r[0] = m[0];
- r[1] = m[1];
- r[2] = m[2];
- r[3] += B[0][0] * z[0] + B[0][1] * z[1] + B[0][2] * z[2];
- r[4] += B[1][0] * z[0] + B[1][1] * z[1] + B[1][2] * z[2];
- r[5] += B[2][0] * z[0] + B[2][1] * z[1] + B[2][2] * z[2];
- r[6] += B[3][0] * z[0] + B[3][1] * z[1] + B[3][2] * z[2];
- r[7] += B[4][0] * z[0] + B[4][1] * z[1] + B[4][2] * z[2];
-
- {
- double AV[6] = {C[0] - V[0], C[1] - V[1], C[2] - V[2], C[3] - V[3], C[4] - V[4], C[5] - V[5]};
- double AVi[6];
- AVi[0] = AV[4] * AV[4] - AV[2] * AV[5];
- AVi[1] = AV[1] * AV[5] - AV[3] * AV[4];
- AVi[2] = AV[3] * AV[3] - AV[0] * AV[5];
- AVi[3] = AV[2] * AV[3] - AV[1] * AV[4];
- AVi[4] = AV[0] * AV[4] - AV[1] * AV[3];
- AVi[5] = -123; // FIXME assing correct value
- det = (AV[0] * AVi[0] + AV[1] * AVi[1] + AV[3] * AVi[3]);
- det = (det > 1.e-8) ? 1. / det : 0;
- NDF += 2;
- Chi2 +=
- (+(AVi[0] * z[0] + AVi[1] * z[1] + AVi[3] * z[2]) * z[0] + (AVi[1] * z[0] + AVi[2] * z[1] + AVi[4] * z[2]) * z[1]
- + (AVi[3] * z[0] + AVi[4] * z[1] + AVi[5] * z[2]) * z[2])
- * det;
- }
-
- double d0, d1, d2;
- C[0] = V[0];
- C[1] = V[1];
- C[2] = V[2];
- C[3] = V[3];
- C[4] = V[4];
- C[5] = V[5];
-
- d0 = B[0][0] * V[0] + B[0][1] * V[1] + B[0][2] * V[3] - C[6];
- d1 = B[0][0] * V[1] + B[0][1] * V[2] + B[0][2] * V[4] - C[7];
- d2 = B[0][0] * V[3] + B[0][1] * V[4] + B[0][2] * V[5] - C[8];
-
- C[6] += d0;
- C[7] += d1;
- C[8] += d2;
- C[9] += d0 * B[0][0] + d1 * B[0][1] + d2 * B[0][2];
-
- d0 = B[1][0] * V[0] + B[1][1] * V[1] + B[1][2] * V[3] - C[10];
- d1 = B[1][0] * V[1] + B[1][1] * V[2] + B[1][2] * V[4] - C[11];
- d2 = B[1][0] * V[3] + B[1][1] * V[4] + B[1][2] * V[5] - C[12];
-
- C[10] += d0;
- C[11] += d1;
- C[12] += d2;
- C[13] += d0 * B[0][0] + d1 * B[0][1] + d2 * B[0][2];
- C[14] += d0 * B[1][0] + d1 * B[1][1] + d2 * B[1][2];
-
- d0 = B[2][0] * V[0] + B[2][1] * V[1] + B[2][2] * V[3] - C[15];
- d1 = B[2][0] * V[1] + B[2][1] * V[2] + B[2][2] * V[4] - C[16];
- d2 = B[2][0] * V[3] + B[2][1] * V[4] + B[2][2] * V[5] - C[17];
-
- C[15] += d0;
- C[16] += d1;
- C[17] += d2;
- C[18] += d0 * B[0][0] + d1 * B[0][1] + d2 * B[0][2];
- C[19] += d0 * B[1][0] + d1 * B[1][1] + d2 * B[1][2];
- C[20] += d0 * B[2][0] + d1 * B[2][1] + d2 * B[2][2];
-
- d0 = B[3][0] * V[0] + B[3][1] * V[1] + B[3][2] * V[3] - C[21];
- d1 = B[3][0] * V[1] + B[3][1] * V[2] + B[3][2] * V[4] - C[22];
- d2 = B[3][0] * V[3] + B[3][1] * V[4] + B[3][2] * V[5] - C[23];
-
- C[21] += d0;
- C[22] += d1;
- C[23] += d2;
- C[24] += d0 * B[0][0] + d1 * B[0][1] + d2 * B[0][2];
- C[25] += d0 * B[1][0] + d1 * B[1][1] + d2 * B[1][2];
- C[26] += d0 * B[2][0] + d1 * B[2][1] + d2 * B[2][2];
- C[27] += d0 * B[3][0] + d1 * B[3][1] + d2 * B[3][2];
-
- d0 = B[4][0] * V[0] + B[4][1] * V[1] + B[4][2] * V[3] - C[28];
- d1 = B[4][0] * V[1] + B[4][1] * V[2] + B[4][2] * V[4] - C[29];
- d2 = B[4][0] * V[3] + B[4][1] * V[4] + B[4][2] * V[5] - C[30];
-
- C[28] += d0;
- C[29] += d1;
- C[30] += d2;
- C[31] += d0 * B[0][0] + d1 * B[0][1] + d2 * B[0][2];
- C[32] += d0 * B[1][0] + d1 * B[1][1] + d2 * B[1][2];
- C[33] += d0 * B[2][0] + d1 * B[2][1] + d2 * B[2][2];
- C[34] += d0 * B[3][0] + d1 * B[3][1] + d2 * B[3][2];
- C[35] += d0 * B[4][0] + d1 * B[4][1] + d2 * B[4][2];
-
- {
- Extrapolate(r[7]);
-
- double CH00 = C[0] + r0[0] * C[28];
- double CH10 = C[1] + r0[0] * C[29];
- double CH11 = C[2] + r0[1] * C[29];
- double CH20 = C[3] + r0[0] * C[30];
- double CH21 = C[4] + r0[1] * C[30];
- double CH22 = C[5] + r0[2] * C[30];
-
- C[28] += r0[0] * C[35];
- C[29] += r0[1] * C[35];
- C[30] += r0[2] * C[35];
-
- C[0] = CH00 + r0[0] * C[28];
- C[1] = CH10 + r0[1] * C[28];
- C[2] = CH11 + r0[1] * C[29];
- C[3] = CH20 + r0[2] * C[28];
- C[4] = CH21 + r0[2] * C[29];
- C[5] = CH22 + r0[2] * C[30];
-
- C[6] += r0[0] * C[31];
- C[7] += r0[1] * C[31];
- C[8] += r0[2] * C[31];
- C[10] += r0[0] * C[32];
- C[11] += r0[1] * C[32];
- C[12] += r0[2] * C[32];
- C[15] += r0[0] * C[33];
- C[16] += r0[1] * C[33];
- C[17] += r0[2] * C[33];
- C[21] += r0[0] * C[34];
- C[22] += r0[1] * C[34];
- C[23] += r0[2] * C[34];
- }
-}
diff --git a/reco/KF/CbmKFSecondaryVertexFinder.h b/reco/KF/CbmKFSecondaryVertexFinder.h
deleted file mode 100644
index 20a3aa495fa11822bf7145f4c8c3ab7dfca7afe7..0000000000000000000000000000000000000000
--- a/reco/KF/CbmKFSecondaryVertexFinder.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/* Copyright (C) 2006-2015 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Sergey Gorbunov, Ivan Kisel, Denis Bertini [committer], Igor Kulakov */
-
-/** The CbmKFSecondaryVertexFinder class
- *
- * @author S.Gorbunov, I.Kisel
- * @version 1.0
- * @since 06.02.06
- *
- * Class to fit secondary vertex with the Kalman Filter method
- *
- */
-#ifndef CBMKFSECONDARYVERTEXFINDER_H
-#define CBMKFSECONDARYVERTEXFINDER_H
-
-#include "CbmKFTrackInterface.h"
-#include "CbmKFVertexInterface.h"
-
-#include <vector>
-
-class CbmKFSecondaryVertexFinder : public TObject {
-
- std::vector<CbmKFTrackInterface*> vTracks;
- Int_t NDF;
- Double_t Chi2, MassConstraint;
- Double_t r[8], r0[8], C[36];
- CbmKFVertexInterface *VParent, *VGuess;
-
- void AddMassConstraint();
- void AddTopoConstraint();
- Double_t& Cij(Int_t i, Int_t j) { return C[(j <= i) ? i * (i + 1) / 2 + j : j * (j + 1) / 2 + i]; }
-
- public:
- CbmKFSecondaryVertexFinder() : vTracks(), NDF(0), Chi2(0), MassConstraint(0), VParent(nullptr), VGuess(nullptr)
- {
- Clear();
- };
- ~CbmKFSecondaryVertexFinder(){};
-
- virtual void Clear(Option_t* opt = "");
- void ClearTracks();
- void AddTrack(CbmKFTrackInterface* Track);
- void SetTracks(std::vector<CbmKFTrackInterface*>& vTracks);
- void SetApproximation(CbmKFVertexInterface* Guess = nullptr);
- void SetMassConstraint(Double_t MotherMass = -1);
- void SetTopoConstraint(CbmKFVertexInterface* Parent = nullptr);
- void Fit();
- void GetVertex(CbmKFVertexInterface& vtx);
- void GetVertex(CbmVertex& vtx);
- void GetMotherTrack(Double_t T[], Double_t C[]);
- void GetMass(Double_t* M, Double_t* Error);
- void Extrapolate(double T);
-
- ClassDef(CbmKFSecondaryVertexFinder, 1);
-
- private:
- CbmKFSecondaryVertexFinder(const CbmKFSecondaryVertexFinder&);
- void operator=(const CbmKFSecondaryVertexFinder&);
-};
-#endif /* !CBMKFSECONDARYVERTEXFINDER_H */
diff --git a/reco/KF/Interface/CbmEcalTrackExtrapolationKF.cxx b/reco/KF/Interface/CbmEcalTrackExtrapolationKF.cxx
deleted file mode 100644
index 7b1c7a86ec41df7ec7a5322d4fc62d59e912ef93..0000000000000000000000000000000000000000
--- a/reco/KF/Interface/CbmEcalTrackExtrapolationKF.cxx
+++ /dev/null
@@ -1,115 +0,0 @@
-/* Copyright (C) 2008-2012 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Sergey Gorbunov [committer] */
-
-#include "CbmEcalTrackExtrapolationKF.h"
-
-#include "CbmEcalInf.h"
-#include "CbmEcalStructure.h"
-#include "CbmGlobalTrack.h"
-#include "CbmKFTrack.h"
-#include "CbmMCTrack.h"
-#include "CbmStsKFTrackFitter.h"
-#include "CbmStsTrack.h"
-#include "FairRootManager.h"
-#include "FairTrackParam.h"
-#include "TClonesArray.h"
-
-#include <iostream>
-
-using namespace std;
-
-// ----- Default constructor -------------------------------------------
-CbmEcalTrackExtrapolationKF::CbmEcalTrackExtrapolationKF()
- : CbmEcalTrackExtrapolation(1)
- , fTrackParamArray(NULL)
- , fSTSArray(NULL)
- , iEx(-1)
-{
- ;
-}
-// -------------------------------------------------------------------------
-
-
-// ----- Standard constructor ------------------------------------------
-CbmEcalTrackExtrapolationKF::CbmEcalTrackExtrapolationKF(Int_t verbose)
- : CbmEcalTrackExtrapolation(verbose)
- , fTrackParamArray(NULL)
- , fSTSArray(NULL)
- , iEx(-1)
-{
- ;
-}
-// -------------------------------------------------------------------------
-
-
-// ----- Destructor ----------------------------------------------------
-CbmEcalTrackExtrapolationKF::~CbmEcalTrackExtrapolationKF() { ; }
-// -------------------------------------------------------------------------
-
-
-// ----- Public method Init --------------------------------------------
-void CbmEcalTrackExtrapolationKF::Init()
-{
- CbmEcalTrackExtrapolation::Init();
- //Get and check FairRootManager
- FairRootManager* ioman = FairRootManager::Instance();
- if (!ioman) {
- Fatal("CbmEcalTrackExtrapolationKF::Init()", "Can't instantise Rootmanager");
- }
-
- //Get STS track array
- fSTSArray = (TClonesArray*) ioman->GetObject("StsTrack");
- if (!fSTSArray) {
- cout << "-W- CbmEcalTrackExtrapolationKF::Init: No sts track array!" << endl;
- }
-}
-// -------------------------------------------------------------------------
-
-
-// ----- Public method DoExtrapolate ------------------------------------------
-Int_t CbmEcalTrackExtrapolationKF::DoExtrapolate(TClonesArray* gTrackArray, TClonesArray* fTrackParamArray_)
-{
- if (!fTrackParamArray_) {
- cout << "-E- CbmEcalTrackExtrapolationKF::DoExtrapolate: ";
- cout << "TrackParamArray missing! " << endl;
- return -1;
- }
-
- if (!gTrackArray) {
- cout << "-E- CbmEcalTrackExtrapolationKF::DoExtrapolate: ";
- cout << "Track Array missing! " << endl;
- return -1;
- }
- Int_t nTr = 0;
- Int_t i = 0;
- Int_t n = gTrackArray->GetEntriesFast();
- CbmGlobalTrack* tr;
- CbmKFTrack kfTr;
- FairTrackParam trpar;
- for (; i < n; i++) {
- Map()[nTr] = -1111;
- tr = (CbmGlobalTrack*) gTrackArray->At(i);
- if (!tr) {
- continue;
- }
- if (tr->GetStsTrackIndex() < 0 || tr->GetTrdTrackIndex() < 0) {
- continue;
- }
- kfTr.SetTrackParam(*(const_cast<FairTrackParam*>(tr->GetParamLast())));
- kfTr.Extrapolate(Str()->GetEcalInf()->GetZPos());
- kfTr.GetTrackParam(trpar);
- Map()[nTr] = i;
- new ((*fTrackParamArray_)[nTr++]) FairTrackParam(trpar);
- }
-
- return nTr;
-}
-// -------------------------------------------------------------------------
-
-
-// ----- Public method Finish ------------------------------------------
-void CbmEcalTrackExtrapolationKF::Finish() { ; }
-//-----------------------------------------------------------------------------------
-
-ClassImp(CbmEcalTrackExtrapolationKF)
diff --git a/reco/KF/Interface/CbmEcalTrackExtrapolationKF.h b/reco/KF/Interface/CbmEcalTrackExtrapolationKF.h
deleted file mode 100644
index 61356f5ce36db8eb90b0769ef8a0d59c1e8a512c..0000000000000000000000000000000000000000
--- a/reco/KF/Interface/CbmEcalTrackExtrapolationKF.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/* Copyright (C) 2008-2012 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Claudia Hoehne, Sergey Gorbunov [committer] */
-
-/******************************************************************************
-* $Id: CbmEcalTrackExtrapolationKF.h,v 1.1 2006/02/17 23:13:37 sgorboun Exp $
-*
-* Class : CbmEcalTrackExtrapolationKF
-* Description: "TrackExtrapolation" from STS tracks (Kalman Fitter)
-* It reads the track array form STS and extrapolates those to
-* be projected to the Rich Photodetector to some z-Plane in RICH
-*
-* Author : Claudia Hoehne
-* E-mail : c.hoehne@gsi.de
-*
-*******************************************************************************
-* $Log: CbmEcalTrackExtrapolationKF.h,v $
-* Revision 1.1 2006/02/17 23:13:37 sgorboun
-* Update of KF&L1 classes
-*
-* Revision 1.2 2006/01/30 11:00:55 hoehne
-* bug fix: Point Array at z-plane was not filled correctly (counters not correct)
-*
-* Revision 1.1 2006/01/26 09:53:22 hoehne
-* initial version for track extrapolation (base class + concrete implementations + task) to z-plane in RICH
-*
-*
-*
-*******************************************************************************/
-
-#ifndef CBMECALTRACKEXTRAPOLATIONKF
-#define CBMECALTRACKEXTRAPOLATIONKF
-
-#include "CbmEcalTrackExtrapolation.h"
-
-class TClonesArray;
-class CbmGlobalTrack;
-
-class CbmEcalTrackExtrapolationKF : public CbmEcalTrackExtrapolation {
- public:
- /** Default constructor **/
- CbmEcalTrackExtrapolationKF();
- /** Standard constructor **/
- CbmEcalTrackExtrapolationKF(Int_t verbose);
- /** Destructor **/
- virtual ~CbmEcalTrackExtrapolationKF();
- /** Initialisation **/
- virtual void Init();
- /** Finish **/
- virtual void Finish();
- /** Method DoExtrapolate.
- ** Task: Read the track array and fill the point array at given z-Plane in RICH detector
- ** pointers to which are given as argument
- **
- *@param rTrackArray Array of tracks
- *@param rTrackParamArray Array of FairTrackParam
- *@value Number of tracks extrapolated
- **/
- virtual Int_t DoExtrapolate(TClonesArray* gTrackArray, TClonesArray* fTrackParamArray);
-
- private:
- /** Arrays **/
- TClonesArray* fTrackParamArray;
- TClonesArray* fSTSArray;
-
- Int_t iEx; /** number of extrapolated tracks */
- ClassDef(CbmEcalTrackExtrapolationKF, 1);
-
- private:
- CbmEcalTrackExtrapolationKF(const CbmEcalTrackExtrapolationKF&);
- void operator=(const CbmEcalTrackExtrapolationKF&);
-};
-
-#endif
diff --git a/reco/KF/Interface/CbmGlobalTrackFitterKF.cxx b/reco/KF/Interface/CbmGlobalTrackFitterKF.cxx
deleted file mode 100644
index 2c1efd86a26b665cc75794569a7bc20ffa74203d..0000000000000000000000000000000000000000
--- a/reco/KF/Interface/CbmGlobalTrackFitterKF.cxx
+++ /dev/null
@@ -1,260 +0,0 @@
-/* Copyright (C) 2006-2017 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Dmytro Kresan, Denis Bertini [committer], Florian Uhlig */
-
-// ------------------------------------------------------------------
-// ----- CbmGlobalTrackFitterKF -----
-// ----- Created 07/03/2006 by D.Kresan -----
-// ------------------------------------------------------------------
-#include "CbmGlobalTrackFitterKF.h"
-
-#include "CbmGlobalTrack.h"
-#include "CbmKFStsHit.h"
-#include "CbmKFTrack.h"
-#include "CbmKFTrdHit.h"
-#include "CbmStsHit.h"
-#include "CbmStsTrack.h"
-#include "CbmTofHit.h"
-#include "CbmTrdHit.h"
-#include "CbmTrdTrack.h"
-#include "CbmVertex.h"
-#include "FairRootManager.h"
-#include "TClonesArray.h"
-#include "TMath.h"
-
-#include <iostream>
-
-using std::cout;
-using std::endl;
-using std::vector;
-
-//___________________________________________________________________
-//
-// CbmGlobalTrackFitterKF
-//
-// Concrete implementation of global track fitting based on the
-// Kalman filter
-//
-
-
-// ------------------------------------------------------------------
-CbmGlobalTrackFitterKF::CbmGlobalTrackFitterKF()
- : fArrayStsHit(nullptr)
- , fArrayTrdHit(nullptr)
- , fArrayTofHit(nullptr)
- , fArrayStsTrack(nullptr)
- , fArrayTrdTrack(nullptr)
- , fPrimVertex(nullptr)
- , fKfTrack(nullptr)
-{
- // Default constructor
-
- fKfTrack = new CbmKFTrack();
- // Set mass hypothesis
- fKfTrack->SetPID(211);
- fVerbose = 0;
-}
-// ------------------------------------------------------------------
-
-
-// ------------------------------------------------------------------
-CbmGlobalTrackFitterKF::~CbmGlobalTrackFitterKF()
-{
- // Destructor
- delete fKfTrack;
-}
-// ------------------------------------------------------------------
-
-
-// ------------------------------------------------------------------
-void CbmGlobalTrackFitterKF::Init()
-{
- // Initialisation
-
- // Get pointer to the ROOT I/O manager
- FairRootManager* rootMgr = FairRootManager::Instance();
- if (nullptr == rootMgr) {
- cout << "-E- CbmGlobalTrackFitterKF::Init :"
- << " ROOT manager is not instantiated" << endl;
- return;
- }
- // Get hit arrays
- fArrayStsHit = (TClonesArray*) rootMgr->GetObject("StsHit");
- if (nullptr == fArrayStsHit) {
- cout << "-W- CbmGlobalTrackFitterKF::Init :"
- << " no Sts hit array" << endl;
- }
- fArrayTrdHit = (TClonesArray*) rootMgr->GetObject("TrdHit");
- if (nullptr == fArrayTrdHit) {
- cout << "-W- CbmGlobalTrackFitterKF::Init :"
- << " no TRD hit array" << endl;
- }
- fArrayTofHit = (TClonesArray*) rootMgr->GetObject("TofHit");
- if (nullptr == fArrayTofHit) {
- cout << "-W- CbmGlobalTrackFitterKF::Init :"
- << " no TOF hit array" << endl;
- }
- // Get track arrays
- fArrayStsTrack = (TClonesArray*) rootMgr->GetObject("StsTrack");
- if (nullptr == fArrayStsTrack) {
- cout << "-W- CbmGlobalTrackFitterKF::Init : "
- << "no STS track array!" << endl;
- }
- fArrayTrdTrack = (TClonesArray*) rootMgr->GetObject("TrdTrack");
- if (nullptr == fArrayTrdTrack) {
- cout << "-W- CbmGlobalTrackFitterKF::Init : "
- << "no TRD track array!" << endl;
- }
-
- // Get pointer to PrimaryVertex object from IOManager if it exists
- // The old name for the object is "PrimaryVertex" the new one
- // "PrimaryVertex." Check first for the new name
- fPrimVertex = dynamic_cast<CbmVertex*>(rootMgr->GetObject("PrimaryVertex."));
- if (nullptr == fPrimVertex) {
- fPrimVertex = dynamic_cast<CbmVertex*>(rootMgr->GetObject("PrimaryVertex"));
- }
- if (nullptr == fPrimVertex) {
- cout << "-W- CbmGlobalTrackFitterKF::Init : "
- << "no Primary Vertex!" << endl;
- }
-}
-// ------------------------------------------------------------------
-
-
-// ------------------------------------------------------------------
-void CbmGlobalTrackFitterKF::DoFit(CbmGlobalTrack* glbTrack)
-{
- // Implementation of the fitting algorithm
- if (nullptr == glbTrack || nullptr == fArrayStsTrack || nullptr == fArrayTrdTrack || nullptr == fArrayStsHit
- || nullptr == fArrayTrdHit || nullptr == fPrimVertex) {
- return;
- }
-
-
- Double_t x_old;
- Double_t y_old;
- Double_t z_old;
- Double_t x_new;
- Double_t y_new;
- Double_t z_new;
- Double_t z = fPrimVertex->GetZ();
- Double_t length = 0.;
-
-
- // Get STS track index
- Int_t stsTrackIndex = glbTrack->GetStsTrackIndex();
- if (-1 == stsTrackIndex) {
- return;
- }
- // Get STS track
- CbmStsTrack* stsTrack = (CbmStsTrack*) fArrayStsTrack->At(stsTrackIndex);
- if (nullptr == stsTrack) {
- return;
- }
- const FairTrackParam* paramFirst;
- paramFirst = stsTrack->GetParamFirst();
- fKfTrack->SetTrackParam(*paramFirst);
- fKfTrack->Extrapolate(z);
- x_old = fKfTrack->GetTrack()[0];
- y_old = fKfTrack->GetTrack()[1];
- z_old = z;
- Double_t p = 1.;
- if (paramFirst->GetQp()) {
- p = TMath::Abs(1. / paramFirst->GetQp());
- }
-
- // Int_t stsHitIndex;
- // CbmStsHit* stsHit;
- // // Loop over hits of the STS track
- // for(Int_t iHit = 0; iHit < stsTrack->GetNStsHits(); iHit++) {
- // // Get hit index
- // stsHitIndex = stsTrack->GetStsHitIndex(iHit);
- // // Get hit
- // stsHit = (CbmStsHit*) fArrayStsHit->At(stsHitIndex);
- // x_new = stsHit->GetX();
- // y_new = stsHit->GetY();
- // z_new = stsHit->GetZ();
- // length += TMath::Sqrt(TMath::Power(x_new-x_old, 2) +
- // TMath::Power(y_new-y_old, 2) +
- // TMath::Power(z_new-z_old, 2));
- // // cout << z_old << " -> " << z_new << " => " << length << endl;
- // x_old = x_new;
- // y_old = y_new;
- // z_old = z_new;
- // }
-
-
- // Get TRD track index
- Int_t trdTrackIndex = glbTrack->GetTrdTrackIndex();
- if (-1 == trdTrackIndex) {
- return;
- }
- // Get TRD track
- CbmTrdTrack* trdTrack = (CbmTrdTrack*) fArrayTrdTrack->At(trdTrackIndex);
- if (nullptr == trdTrack) {
- return;
- }
- if (trdTrack->GetNofHits() < 2) {
- return;
- }
- Int_t trdHitIndex = trdTrack->GetHitIndex(0);
- CbmTrdHit* trdHit = (CbmTrdHit*) fArrayTrdHit->At(trdHitIndex);
-
- while (z < (trdHit->GetZ() - 2.)) {
- z += p * 1.;
-
- fKfTrack->Extrapolate(z);
- x_new = fKfTrack->GetTrack()[0];
- y_new = fKfTrack->GetTrack()[1];
- z_new = z;
-
- length +=
- TMath::Sqrt(TMath::Power(x_new - x_old, 2) + TMath::Power(y_new - y_old, 2) + TMath::Power(z_new - z_old, 2));
- x_old = x_new;
- y_old = y_new;
- z_old = z_new;
- }
-
- // Loop over hits of the TRD track
- for (Int_t iTrd = 1; iTrd < trdTrack->GetNofHits(); iTrd++) {
- // Get hit index
- trdHitIndex = trdTrack->GetHitIndex(iTrd);
- // Get hit
- trdHit = (CbmTrdHit*) fArrayTrdHit->At(trdHitIndex);
- z = trdHit->GetZ();
- fKfTrack->Extrapolate(z);
- if (trdHit->GetDx() > trdHit->GetDy()) {
- x_new = fKfTrack->GetTrack()[0];
- y_new = trdHit->GetY();
- }
- else {
- x_new = trdHit->GetX();
- y_new = fKfTrack->GetTrack()[1];
- }
- z_new = z;
- length +=
- TMath::Sqrt(TMath::Power(x_new - x_old, 2) + TMath::Power(y_new - y_old, 2) + TMath::Power(z_new - z_old, 2));
- x_old = x_new;
- y_old = y_new;
- z_old = z_new;
- }
-
-
- Int_t tofIndex = glbTrack->GetTofHitIndex();
- if (-1 == tofIndex) {
- return;
- }
- CbmTofHit* tofHit = (CbmTofHit*) fArrayTofHit->At(tofIndex);
- x_new = tofHit->GetX();
- y_new = tofHit->GetY();
- z_new = tofHit->GetZ();
- length +=
- TMath::Sqrt(TMath::Power(x_new - x_old, 2) + TMath::Power(y_new - y_old, 2) + TMath::Power(z_new - z_old, 2));
-
-
- glbTrack->SetLength(length);
-}
-// ------------------------------------------------------------------
-
-
-ClassImp(CbmGlobalTrackFitterKF);
diff --git a/reco/KF/Interface/CbmGlobalTrackFitterKF.h b/reco/KF/Interface/CbmGlobalTrackFitterKF.h
deleted file mode 100644
index 186d8a2c8dece4811dd3cb4b33c7870679cae884..0000000000000000000000000000000000000000
--- a/reco/KF/Interface/CbmGlobalTrackFitterKF.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/* Copyright (C) 2006-2012 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Dmytro Kresan, Denis Bertini [committer], Igor Kulakov */
-
-// ------------------------------------------------------------------
-// ----- CbmGlobalTrackFitterKF -----
-// ----- Created 07/03/2006 by D.Kresan -----
-// ------------------------------------------------------------------
-#ifndef CBMGLOBALTRACKFITTERKF
-#define CBMGLOBALTRACKFITTERKF
-
-#include "CbmGlobalTrackFitter.h"
-
-class TClonesArray;
-class CbmKFTrack;
-class CbmVertex;
-
-
-class CbmGlobalTrackFitterKF : public CbmGlobalTrackFitter {
-
- private:
- TClonesArray* fArrayStsHit; // Array of STS hits
- TClonesArray* fArrayTrdHit; // Array of TRD hits
- TClonesArray* fArrayTofHit; // Array of TOF hits
- TClonesArray* fArrayStsTrack; // Array of STS tracks
- TClonesArray* fArrayTrdTrack; // Array of TRD tracks
- CbmVertex* fPrimVertex; // Primary vertex
- CbmKFTrack* fKfTrack; // KF track
-
- public:
- CbmGlobalTrackFitterKF();
- virtual ~CbmGlobalTrackFitterKF();
-
- void Init();
- void DoFit(CbmGlobalTrack* glbTrack);
-
- ClassDef(CbmGlobalTrackFitterKF, 1);
-
- private:
- CbmGlobalTrackFitterKF(const CbmGlobalTrackFitterKF&);
- void operator=(const CbmGlobalTrackFitterKF&);
-};
-
-
-#endif
diff --git a/reco/KF/Interface/CbmKFTofHit.cxx b/reco/KF/Interface/CbmKFTofHit.cxx
deleted file mode 100644
index 80dc237922329063cf7a7b76f3254e3d98616775..0000000000000000000000000000000000000000
--- a/reco/KF/Interface/CbmKFTofHit.cxx
+++ /dev/null
@@ -1,94 +0,0 @@
-/* Copyright (C) 2005-2016 PI-UHd, GSI
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Dmytro Kresan, Norbert Herrmann [committer] */
-
-// ----------------------------------------------------------------------
-// ----- CbmKFTofHit -----
-// ----- Created 12/12/2005 by D.Kresan -----
-// ----------------------------------------------------------------------
-
-#include "CbmKFTofHit.h"
-
-#include "CbmKF.h"
-#include "CbmKFMaterial.h"
-#include "CbmTofHit.h"
-#include "TMath.h"
-#include "TVector3.h"
-
-#include <iostream>
-
-using std::cout;
-using std::endl;
-
-
-// ------------------------ Create from CbmTofHit -----------------------
-void CbmKFTofHit::Create(CbmTofHit* hit)
-{
- // Get pointer to the Kalman filter
- CbmKF* KF = CbmKF::Instance();
- if (nullptr == KF) {
- cout << "-E- CbmKFTofHit::Create : "
- << "Kalman filter is not instantiated." << endl;
- return;
- }
- // Get index of material
- MaterialIndex = KF->GetMaterialIndex(hit->GetPlaneId());
- // Store pointer to the material
- wall = (MaterialIndex >= 0) ? (CbmKFWall*) KF->vMaterial[MaterialIndex] : nullptr;
-
- // Get position and position error
- TVector3 pos, err;
- hit->Position(pos);
- hit->PositionError(err);
- // Store values
- /* FitPoint.x = pos.X();
- FitPoint.y = pos.Y();
- FitPoint.z = pos.Z();
- FitPoint.V[0] = 1e-8 * err.X() * err.X();
- FitPoint.V[1] = 0;
- FitPoint.V[2] = 1e-8 * err.Y() * err.Y();*/
- Double_t u = pos.X();
- Double_t phi = 0.;
- Double_t sigma2 = err.X() * err.X();
- if (err.Y() < err.X()) {
- u = pos.Y();
- phi = TMath::Pi() / 2.;
- sigma2 = err.Y() * err.Y();
- }
- FitPoint.Set(pos.Z(), u, phi, sigma2);
-}
-// ----------------------------------------------------------------------
-
-
-// ------------------------------ Filter --------------------------------
-Int_t CbmKFTofHit::Filter(CbmKFTrackInterface& track, Bool_t /*downstream*/, Double_t& QP0)
-{
- Bool_t err = 0;
- /*
- Double_t zfst, zlst, zend;
- if( downstream ) {
- zfst = wall->ZReference - wall->ZThickness/4.;
- zlst = wall->ZReference + wall->ZThickness/4.;
- zend = wall->ZReference + wall->ZThickness/2.;
- }
- else {
- zfst = wall->ZReference + wall->ZThickness/4.;
- zlst = wall->ZReference - wall->ZThickness/4.;
- zend = wall->ZReference - wall->ZThickness/2.;
- }
- Double_t zthick = wall->ZThickness/2.;
-*/
- // wall->Pass( zfst, zthick, track, downstream, QP0 );
- // KF->Propagate( track, FitPoint.z, QP0 );
-
- err = err || track.Propagate(FitPoint.z, QP0);
- err = err || FitPoint.Filter(track);
- // cout<<" Filter z "<<FitPoint.z<<", QP0 "<<QP0<<endl;
- // wall->Pass( zlst, zthick, track, downstream, QP0 );
- // KF->Propagate( track, zend, QP0 );
- return err;
-}
-// ----------------------------------------------------------------------
-
-
-ClassImp(CbmKFTofHit);
diff --git a/reco/KF/Interface/CbmKFTofHit.h b/reco/KF/Interface/CbmKFTofHit.h
deleted file mode 100644
index 48c33fc2a163c666c4af0baf8889af2efd4d850a..0000000000000000000000000000000000000000
--- a/reco/KF/Interface/CbmKFTofHit.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/* Copyright (C) 2015 PI-UHd, GSI
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Dmytro Kresan, Norbert Herrmann [committer] */
-
-// ----------------------------------------------------------------------
-// ----- CbmKFTofHit -----
-// ----- Created 12/12/2005 by D.Kresan -----
-// ----------------------------------------------------------------------
-
-
-/** CbmKFTofHit
- *@author D.Kresan <D.Kresan@gsi.de>
- ** Interface class, representing CbmTofHit in Kalman Filter.
- **/
-
-
-#ifndef CBMKFTOFHIT
-#define CBMKFTOFHIT 1
-
-#include "CbmKFHit.h"
-#include "CbmKFUMeasurement.h"
-
-class CbmKFWall;
-class CbmTofHit;
-
-class CbmKFTofHit : public CbmKFHit {
-
- public:
- /** Default constructor **/
- CbmKFTofHit() : FitPoint(), wall(nullptr){};
-
- /** Destructor **/
- ~CbmKFTofHit(){};
-
- /** Measurement point **/
- // CbmKFPixelMeasurement FitPoint;
- CbmKFUMeasurement FitPoint;
-
- /** Material **/
- CbmKFWall* wall;
-
- /** Copy data from CbmTofHit **/
- void Create(CbmTofHit* hit);
-
- /** Filter **/
- Int_t Filter(CbmKFTrackInterface& track, Bool_t downstream, Double_t& QP0);
-
- const CbmKFTofHit& operator=(const CbmKFTofHit& a)
- {
- wall = a.wall;
- FitPoint = a.FitPoint;
- return *this;
- };
-
- CbmKFTofHit(const CbmKFTofHit& a) : FitPoint(a.FitPoint), wall(a.wall){};
-
- ClassDef(CbmKFTofHit, 1);
-};
-
-
-#endif
diff --git a/reco/KF/Interface/CbmKFTrdHit.cxx b/reco/KF/Interface/CbmKFTrdHit.cxx
deleted file mode 100644
index ed060cbb1ece371d66fc5c7cb2d8fbac9a943144..0000000000000000000000000000000000000000
--- a/reco/KF/Interface/CbmKFTrdHit.cxx
+++ /dev/null
@@ -1,94 +0,0 @@
-/* Copyright (C) 2005-2016 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Dmytro Kresan, Denis Bertini [committer], Florian Uhlig */
-
-// ----------------------------------------------------------------------
-// ----- CbmKFTrdHit -----
-// ----- Created 12/12/2005 by D.Kresan -----
-// ----------------------------------------------------------------------
-
-#include "CbmKFTrdHit.h"
-
-#include "CbmKF.h"
-#include "CbmKFMaterial.h"
-#include "CbmTrdHit.h"
-#include "TMath.h"
-#include "TVector3.h"
-
-#include <iostream>
-
-using std::cout;
-using std::endl;
-
-
-// ------------------------ Create from CbmTrdHit -----------------------
-void CbmKFTrdHit::Create(CbmTrdHit* hit)
-{
- // Get pointer to the Kalman filter
- CbmKF* KF = CbmKF::Instance();
- if (nullptr == KF) {
- cout << "-E- CbmKFTrdHit::Create : "
- << "Kalman filter is not instantiated." << endl;
- return;
- }
- // Get index of material
- MaterialIndex = KF->GetMaterialIndex(hit->GetPlaneId());
- // Store pointer to the material
- wall = (MaterialIndex >= 0) ? (CbmKFWall*) KF->vMaterial[MaterialIndex] : nullptr;
-
- // Get position and position error
- TVector3 pos, err;
- hit->Position(pos);
- hit->PositionError(err);
- // Store values
- /* FitPoint.x = pos.X();
- FitPoint.y = pos.Y();
- FitPoint.z = pos.Z();
- FitPoint.V[0] = 1e-8 * err.X() * err.X();
- FitPoint.V[1] = 0;
- FitPoint.V[2] = 1e-8 * err.Y() * err.Y();*/
- Double_t u = pos.X();
- Double_t phi = 0.;
- Double_t sigma2 = err.X() * err.X();
- if (err.Y() < err.X()) {
- u = pos.Y();
- phi = TMath::Pi() / 2.;
- sigma2 = err.Y() * err.Y();
- }
- FitPoint.Set(pos.Z(), u, phi, sigma2);
-}
-// ----------------------------------------------------------------------
-
-
-// ------------------------------ Filter --------------------------------
-Int_t CbmKFTrdHit::Filter(CbmKFTrackInterface& track, Bool_t /*downstream*/, Double_t& QP0)
-{
- Bool_t err = 0;
- /*
- Double_t zfst, zlst, zend;
- if( downstream ) {
- zfst = wall->ZReference - wall->ZThickness/4.;
- zlst = wall->ZReference + wall->ZThickness/4.;
- zend = wall->ZReference + wall->ZThickness/2.;
- }
- else {
- zfst = wall->ZReference + wall->ZThickness/4.;
- zlst = wall->ZReference - wall->ZThickness/4.;
- zend = wall->ZReference - wall->ZThickness/2.;
- }
- Double_t zthick = wall->ZThickness/2.;
-*/
- // wall->Pass( zfst, zthick, track, downstream, QP0 );
- // KF->Propagate( track, FitPoint.z, QP0 );
-
- err = err || track.Propagate(FitPoint.z, QP0);
- err = err || FitPoint.Filter(track);
-
- // wall->Pass( zlst, zthick, track, downstream, QP0 );
- // KF->Propagate( track, zend, QP0 );
- return err;
-}
-// ----------------------------------------------------------------------
-
-
-ClassImp(CbmKFTrdHit);
diff --git a/reco/KF/Interface/CbmKFTrdHit.h b/reco/KF/Interface/CbmKFTrdHit.h
deleted file mode 100644
index 12859959293dc079502891468050ddb08e324431..0000000000000000000000000000000000000000
--- a/reco/KF/Interface/CbmKFTrdHit.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/* Copyright (C) 2006-2012 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Dmytro Kresan, Denis Bertini [committer], Igor Kulakov */
-
-// ----------------------------------------------------------------------
-// ----- CbmKFTrdHit -----
-// ----- Created 12/12/2005 by D.Kresan -----
-// ----------------------------------------------------------------------
-
-
-/** CbmKFTrdHit
- *@author D.Kresan <D.Kresan@gsi.de>
- ** Interface class, representing CbmTrdHit in Kalman Filter.
- **/
-
-
-#ifndef CBMKFTRDHIT
-#define CBMKFTRDHIT 1
-
-#include "CbmKFHit.h"
-#include "CbmKFUMeasurement.h"
-
-class CbmKFWall;
-class CbmTrdHit;
-
-class CbmKFTrdHit : public CbmKFHit {
-
- public:
- /** Default constructor **/
- CbmKFTrdHit() : FitPoint(), wall(nullptr){};
-
- /** Destructor **/
- ~CbmKFTrdHit(){};
-
- /** Measurement point **/
- // CbmKFPixelMeasurement FitPoint;
- CbmKFUMeasurement FitPoint;
-
- /** Material **/
- CbmKFWall* wall;
-
- /** Copy data from CbmTrdHit **/
- void Create(CbmTrdHit* hit);
-
- /** Filter **/
- Int_t Filter(CbmKFTrackInterface& track, Bool_t downstream, Double_t& QP0);
-
- const CbmKFTrdHit& operator=(const CbmKFTrdHit& a)
- {
- wall = a.wall;
- FitPoint = a.FitPoint;
- return *this;
- };
-
- CbmKFTrdHit(const CbmKFTrdHit& a) : FitPoint(a.FitPoint), wall(a.wall){};
-
- ClassDef(CbmKFTrdHit, 1);
-};
-
-
-#endif
diff --git a/reco/KF/Interface/CbmStsFitPerformanceTask.cxx b/reco/KF/Interface/CbmStsFitPerformanceTask.cxx
deleted file mode 100644
index 0ffa2f6b08a74bfbfdcd79d1c6a4bc97e5d2bbff..0000000000000000000000000000000000000000
--- a/reco/KF/Interface/CbmStsFitPerformanceTask.cxx
+++ /dev/null
@@ -1,1166 +0,0 @@
-/* Copyright (C) 2005-2021 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Evgeny Kryshen, Denis Bertini [committer], Florian Uhlig */
-
-// -------------------------------------------------------------------------
-// ----- CbmStsFitPerformanceTask source file -----
-// ----- Created 02/02/05 by E. Kryshen -----
-// -------------------------------------------------------------------------
-
-#include "CbmStsFitPerformanceTask.h"
-
-#include "CbmKF.h"
-#include "CbmKFMath.h"
-#include "CbmKFPrimaryVertexFinder.h"
-#include "CbmKFTrack.h"
-#include "CbmKFTrackInterface.h"
-#include "CbmKFVertex.h"
-#include "CbmKFVertexInterface.h"
-#include "CbmMCTrack.h"
-#include "CbmMvdHit.h"
-#include "CbmPVFinderKF.h"
-#include "CbmStsAddress.h"
-#include "CbmStsHit.h"
-#include "CbmStsKFSecondaryVertexFinder.h"
-#include "CbmStsKFTrackFitter.h"
-#include "CbmStsSetup.h"
-#include "CbmStsTrack.h"
-#include "CbmTrackMatch.h"
-#include "CbmVertex.h"
-#include "FairMCApplication.h"
-#include "FairRootManager.h"
-#include "TDatabasePDG.h"
-#include "TF1.h"
-#include "TParticlePDG.h"
-#include "TVector3.h"
-
-#include <cmath>
-#include <iomanip>
-#include <iostream>
-
-using std::cout;
-using std::endl;
-using std::fabs;
-using std::vector;
-
-ClassImp(CbmStsFitPerformanceTask);
-
-// -------------------------------------------------------------------------
-
-void writedir2current(TObject* obj)
-{
- if (!obj->IsFolder()) {
- obj->Write();
- }
- else {
- TDirectory* cur = gDirectory;
- TDirectory* sub = cur->mkdir(obj->GetName());
- sub->cd();
- TList* listSub = ((TDirectory*) obj)->GetList();
- TIter it(listSub);
- while (TObject* obj1 = it()) {
- writedir2current(obj1);
- }
- cur->cd();
- }
-}
-
-void CbmStsFitPerformanceTask::CreateTrackHisto(TH1D* hist[10], const char* name, const char* title)
-{
- struct {
- const char* name;
- const char* title;
- Int_t n;
- Double_t l, r;
- } Table[10] = {{"x", "Residual X [#mum]", 100, -100., 100.},
- {"y", "Residual Y [#mum]", 100, -100., 100.},
- {"tx", "Residual Tx [mrad]", 100, -2., 2.},
- {"ty", "Residual Ty [mrad]", 100, -2., 2.},
- {"P", "Resolution P/Q [100%]", 100, -.1, .1},
- {"px", "Pull X [residual/estimated_error]", 100, -10., 10.},
- {"py", "Pull Y [residual/estimated_error]", 100, -10., 10.},
- {"ptx", "Pull Tx [residual/estimated_error]", 100, -10., 10.},
- {"pty", "Pull Ty [residual/estimated_error]", 100, -10., 10.},
- {"pQP", "Pull Q/P [residual/estimated_error]", 100, -10., 10.}};
-
- for (int i = 0; i < 10; i++) {
- char n[225], t[255];
- sprintf(n, "%s_%s", name, Table[i].name);
- sprintf(t, "%s %s", title, Table[i].title);
- hist[i] = new TH1D(n, t, Table[i].n, Table[i].l, Table[i].r);
- }
-}
-
-void CbmStsFitPerformanceTask::CreateVertexHisto(TH1D* hist[9], const char* name, const char* title)
-{
- struct {
- const char* name;
- const char* title;
- Int_t n;
- Double_t l, r;
- } Table[9] = {
- {"x", "Residual X [#mum]", 100, -5., 5.},
- {"y", "Residual Y [#mum]", 100, -5., 5.},
- {"z", "Residual Z [#mum]", 100, -40., 40.},
- {"px", "Pull X [residual/estimated_error]", 100, -10., 10.},
- {"py", "Pull Y [residual/estimated_error]", 100, -10., 10.},
- {"pz", "Pull Z [residual/estimated_error]", 100, -10., 10.},
- {"chi2", "Chi2/NDF", 100, 0., 10.},
- {"prob", "Prob(Chi2,NDF)", 100, 0., 1.},
- {"ntracks", "N tracks", 100, 0., 1000.},
- };
-
- for (int i = 0; i < 9; i++) {
- char n[225], t[255];
- sprintf(n, "%s_%s", name, Table[i].name);
- sprintf(t, "%s %s", title, Table[i].title);
- hist[i] = new TH1D(n, t, Table[i].n, Table[i].l, Table[i].r);
- }
-}
-
-void CbmStsFitPerformanceTask::CreateD0Histo(TH1D* hist[15], const char* name, const char* title)
-{
- struct {
- const char* name;
- const char* title;
- Int_t n;
- Double_t l, r;
- } Table[14] = {{"x", "Residual X [#mum]", 100, -100., 100.},
- {"y", "Residual Y [#mum]", 100, -100., 100.},
- {"z", "Residual Z [#mum]", 100, -500., 500.},
- {"px", "Pull X [residual/estimated_error]", 100, -10., 10.},
- {"py", "Pull Y [residual/estimated_error]", 100, -10., 10.},
- {"pz", "Pull Z [residual/estimated_error]", 100, -10., 10.},
- {"chi2", "Chi2/NDF", 100, 0., 10.},
- {"prob", "Prob(Chi2,NDF)", 100, 0., 1.},
- {"mass", "Residual Mass", 100, -.1, .1},
- {"pmass", "Pull Mass [residual/estimated_error]", 100, -10., 10.},
- {"KaonP", "Kaon P resolution", 100, -.05, .05},
- {"PionP", "Pion P resolution", 100, -.05, .05},
- {"KaonP0", "Kaon P resolution before fit", 100, -.05, .05},
- {"PionP0", "Pion P resolutionbefore fit", 100, -.05, .05}};
-
- for (int i = 0; i < 14; i++) {
- char n[225], t[255];
- sprintf(n, "%s_%s", name, Table[i].name);
- sprintf(t, "%s %s", title, Table[i].title);
- hist[i] = new TH1D(n, t, Table[i].n, Table[i].l, Table[i].r);
- }
-}
-
-
-// ----- Standard constructor ------------------------------------------
-CbmStsFitPerformanceTask::CbmStsFitPerformanceTask(const char* name, Int_t iVerbose)
- : FairTask(name, iVerbose)
- , fEvent(0)
- , fVertexAnalysis(0)
- , fD0Analysis(0)
- , fTrackAnalysis(1)
- ,
-
- fMCTrackArray(nullptr)
- , ///< MCTracks
- fStsPointArray(nullptr)
- , ///< StsPoints
- fMvdPointArray(nullptr)
- , ///< StsPoints
- fRecStsTrackArray(nullptr)
- , ///< Reconstructed StsTracks
- fStsHitArray(nullptr)
- , ///< Sts hits
- fMvdHitArray(nullptr)
- , ///< Sts hits
- fPrimaryVertex(nullptr)
- , ///< Primary vertex
- fSTSTrackMatch(nullptr)
- , ///< Related MC tracks
-
- fhChi2(nullptr)
- , // x=chi2(), y=entries for all
- fhProb(nullptr)
- , // x=Prob function(), y=entries for all
- fhDP(nullptr)
- , fhDP2(nullptr)
- , fhDsP(nullptr)
- , fhDsP2(nullptr)
- ,
-
- fhZMCf(nullptr)
- , fhZMCl(nullptr)
- , // z first/last of MC track
- fhZRecof(nullptr)
- , fhZRecol(nullptr)
- , // z first/last of Reco track
-
- fhRes_vs_Mom_f(nullptr)
- , fhRes_vs_Mom_l(nullptr)
- , // resolution vs momentum
- fhExtraTracks2ndMVD(nullptr)
- , // extra tracks not detected in the second mvd chamber
-
- // TH1D* fhFrst[10](),
- // TH1D* fhMid[10](),
- // TH1D* fhLast[10](),
- // TH1D* fhImp[10](),
- // TH1D* fhImpPi[10](),
- // TH1D* fhVfit[10](),
- // TH1D* fhVtx[9](),
- // TH1D* fhV[13][9](),
- fhPq()
- ,
- // fhD0[4][14](),
-
- // fhHitDensity[10](),
- // fhTrackDensity[8](),
- fhTrackDensity0L(nullptr)
- ,
-
- histodir(nullptr)
- , fFitter()
-{
-}
-// -------------------------------------------------------------------------
-
-
-// ----- Destructor ----------------------------------------------------
-CbmStsFitPerformanceTask::~CbmStsFitPerformanceTask() {}
-
-// ----- Init CbmStsFitPerformanceTask task -------------------------------
-InitStatus CbmStsFitPerformanceTask::Init()
-{
- fEvent = 0;
-
- TDirectory* curdir = gDirectory;
- histodir = gDirectory->mkdir("StsFitPerformance");
- histodir->cd();
-
- gDirectory->mkdir("TrackFit");
- gDirectory->cd("TrackFit");
- {
- fhChi2 = new TH1D("hChi2", "hChi2", 100, 0, 10);
- fhProb = new TH1D("hProb", "hProb", 100, 0, 1.0);
-
- fhDP = new TH1D("hDP", "hDP", 1000, -.005, .005);
- fhDP2 = new TH2D("hDP2", "hDP2", 100, 0., 5.0, 1000, -.005, .005);
-
- fhDsP = new TH1D("hDsP", "hDsP", 100, -1, 1);
- fhDsP2 = new TH2D("hDsP2", "hDsP2", 100, 0., 5.0, 100, -1, 1);
-
- fhZMCf = new TH1D("hZMCf", "h Z MC first", 102, -1.0, 101.0);
- fhZRecof = new TH1D("hZRecof", "h Z Reco first", 102, -1.0, 101.0);
- fhZMCl = new TH1D("hZMCl", "h Z MC last", 102, -1.0, 101.0);
- fhZRecol = new TH1D("hZRecol", "h Z Reco last", 102, -1.0, 101.0);
-
- fhRes_vs_Mom_f =
- new TH2D("hRes_vs_Mom_f", "TX Resolusion vs Momentum (first hit)", 100, 0.0, 5.0, 100, -50.0, 50.0);
- fhRes_vs_Mom_l = new TH2D("hRes_vs_Mom_l", "TX Resolusion vs Momentum (last hit)", 100, 0.0, 5.0, 100, -10.0, 10.0);
-
- fhExtraTracks2ndMVD =
- new TH2D("hExtraTracks2ndMVD", "ExtraTracks in the 2nd MVD", 200, -10.0, 10.0, 200, -10.0, 10.0);
-
- gDirectory->mkdir("AtFirstHit");
- gDirectory->cd("AtFirstHit");
- CreateTrackHisto(fhFrst, "fst", "at first STS Hit");
- gDirectory->cd("..");
- gDirectory->mkdir("AtLastHit");
- gDirectory->cd("AtLastHit");
- CreateTrackHisto(fhLast, "lst", "at last STS Hit");
- gDirectory->cd("..");
- gDirectory->mkdir("AtImpactPoint");
- gDirectory->cd("AtImpactPoint");
- CreateTrackHisto(fhImp, "imp", "at impact point");
- gDirectory->cd("..");
- gDirectory->mkdir("AtImpactPointPion");
- gDirectory->cd("AtImpactPointPion");
- CreateTrackHisto(fhImpPi, "impPi", "at impact point");
- gDirectory->cd("..");
- gDirectory->mkdir("InTheMiddle");
- gDirectory->cd("InTheMiddle");
- CreateTrackHisto(fhMid, "mid", "at 4th station");
- gDirectory->cd("..");
- gDirectory->mkdir("FittedToVertex");
- gDirectory->cd("FittedToVertex");
- CreateTrackHisto(fhVfit, "vfit", "for vertex fitted track");
- gDirectory->cd("..");
-
- gDirectory->mkdir("PSlidesOnP");
- gDirectory->cd("PSlidesOnP");
- fhPq = new TH2D("Pq", "Resolution P/Q at impact point vs P", 100, 0, 10, 100, -.1, .1);
- gDirectory->cd("..");
- }
- gDirectory->cd("..");
-
- for (int i = 0; i < 10; i++) {
- char n[225], t[255];
- sprintf(n, "hHitDens%i", i);
- sprintf(t, "Hit Density, Sts station %i", i);
- fhHitDensity[i] = new TH1D(n, t, 300, 0, 300);
- }
- fhTrackDensity[0] = new TH1D("hTrackDensity0", "Track Density 0cm", 300, 0, 300);
- fhTrackDensity0L = new TH1D("hTrackDensity0L", "Track Density Line 0cm", 300, 0, 300);
- fhTrackDensity[1] = new TH1D("hTrackDensity1", "Track Density 1cm", 300, 0, 300);
- fhTrackDensity[2] = new TH1D("hTrackDensity2", "Track Density 2cm", 300, 0, 300);
- fhTrackDensity[3] = new TH1D("hTrackDensity3", "Track Density 3cm", 300, 0, 300);
- fhTrackDensity[4] = new TH1D("hTrackDensity4", "Track Density 4cm", 300, 0, 300);
- fhTrackDensity[5] = new TH1D("hTrackDensity5", "Track Density 5cm", 300, 0, 300);
- fhTrackDensity[6] = new TH1D("hTrackDensity10", "Track Density 10cm", 300, 0, 300);
- fhTrackDensity[7] = new TH1D("hTrackDensity100", "Track Density 1m", 300, 0, 300);
-
- gDirectory->mkdir("VertexFit");
- gDirectory->cd("VertexFit");
- {
- CreateVertexHisto(fhVtx, "vtx", "for Primary Vertex");
- gDirectory->mkdir("VertexOnNTracks");
- gDirectory->cd("VertexOnNTracks");
- for (int i = 0; i < 13; i++) {
- char name[225], namedir[225], title[225];
- if (i == 0) {
- sprintf(namedir, "AllTracks");
- sprintf(name, "Vall");
- sprintf(title, "for Primary Vertex on all tracks");
- }
- else {
- sprintf(namedir, "%iTracks", i * 50);
- sprintf(name, "V%i", i * 50);
- sprintf(title, "for Primary Vertex on %i tracks", i * 50);
- }
- gDirectory->mkdir(namedir);
- gDirectory->cd(namedir);
- CreateVertexHisto(fhV[i], name, title);
- gDirectory->cd("..");
- }
- gDirectory->cd("..");
- }
- gDirectory->cd("..");
-
- gDirectory->mkdir("D0Fit");
- gDirectory->cd("D0Fit");
- {
- gDirectory->mkdir("No constraints");
- gDirectory->cd("No constraints");
- CreateD0Histo(fhD0[0], "D0", "for D0 Sec. Vertex");
- gDirectory->cd("..");
- gDirectory->mkdir("Topological constraint");
- gDirectory->cd("Topological constraint");
- CreateD0Histo(fhD0[1], "D0T", "for D0 Topo Sec. Vertex");
- gDirectory->cd("..");
- gDirectory->mkdir("Mass constraint");
- gDirectory->cd("Mass constraint");
- CreateD0Histo(fhD0[2], "D0M", "for D0 Mass Sec. Vertex");
- gDirectory->cd("..");
- gDirectory->mkdir("Mass+Topological constraint");
- gDirectory->cd("Mass+Topological constraint");
- CreateD0Histo(fhD0[3], "D0TM", "for D0 Topo+Mass Sec. Vertex");
- gDirectory->cd("..");
- }
- gDirectory->cd("..");
-
- curdir->cd();
- return ReInit();
-}
-
-// ----- ReInit CbmStsFitPerformanceTask task -------------------------------
-InitStatus CbmStsFitPerformanceTask::ReInit()
-{
-
- FairRootManager* fManger = FairRootManager::Instance();
- fMCTrackArray = reinterpret_cast<TClonesArray*>(fManger->GetObject("MCTrack"));
- fStsPointArray = reinterpret_cast<TClonesArray*>(fManger->GetObject("StsPoint"));
- fMvdPointArray = reinterpret_cast<TClonesArray*>(fManger->GetObject("MvdPoint"));
- fRecStsTrackArray = reinterpret_cast<TClonesArray*>(fManger->GetObject("StsTrack"));
- fStsHitArray = reinterpret_cast<TClonesArray*>(fManger->GetObject("StsHit"));
- fMvdHitArray = reinterpret_cast<TClonesArray*>(fManger->GetObject("MvdHit"));
-
- // Get pointer to PrimaryVertex object from IOManager if it exists
- // The old name for the object is "PrimaryVertex" the new one
- // "PrimaryVertex." Check first for the new name
- fPrimaryVertex = dynamic_cast<CbmVertex*>(fManger->GetObject("PrimaryVertex."));
- if (nullptr == fPrimaryVertex) {
- fPrimaryVertex = dynamic_cast<CbmVertex*>(fManger->GetObject("PrimaryVertex"));
- }
- if (nullptr == fPrimaryVertex) {
- cout << "-W- CbmStsFitPerformanceTask::ReInit : "
- << "no Primary Vertex!" << endl;
- }
-
- fSTSTrackMatch = reinterpret_cast<TClonesArray*>(fManger->GetObject("StsTrackMatch"));
- fFitter.Init();
-
- return kSUCCESS;
-}
-// -------------------------------------------------------------------------
-
-
-// ----- Exec CbmStsFitPerformanceTask task -------------------------------
-void CbmStsFitPerformanceTask::Exec(Option_t* /*option*/)
-{
- cout << "Event: " << ++fEvent << " ";
-
- Int_t nTracks = fRecStsTrackArray->GetEntriesFast();
- cout << " nTracks: " << nTracks << endl;
-
- if (!fSTSTrackMatch) {
- return;
- }
-
- Double_t mc[6];
-
- Int_t Quality[nTracks];
-
- for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
- Quality[iTrack] = 0;
- CbmStsTrack* track = (CbmStsTrack*) fRecStsTrackArray->At(iTrack);
- if (!track) {
- continue;
- }
- CbmTrackMatch* m = (CbmTrackMatch*) fSTSTrackMatch->At(iTrack);
- if (!m) {
- continue;
- }
- if (m->GetNofTrueHits() < 0.7 * (m->GetNofTrueHits() + m->GetNofWrongHits() + m->GetNofFakeHits())) {
- continue;
- }
- Int_t mcTrackID = m->GetMCTrackId();
- if (mcTrackID < 0) {
- continue;
- }
- if (!IsLong(track)) {
- continue;
- }
-
- CbmMCTrack* mcTrack = (CbmMCTrack*) fMCTrackArray->At(mcTrackID);
- if (!mcTrack) {
- continue;
- }
- if (fabs((mcTrack->GetStartZ())) > 1.) {
- continue;
- }
-
- if (mcTrack->GetMotherId() != -1) {
- continue;
- }
- Quality[iTrack] = 1;
- }
-
- if (0) {
- // CbmKF &KF = *CbmKF::Instance();
- int nStsHits = fStsHitArray->GetEntriesFast();
- int nMvdHits = fMvdHitArray->GetEntriesFast();
- cout << "Mvd hit density..." << endl;
- for (int ih = 0; ih < nMvdHits; ih++) {
- if (ih % 100 == 0) {
- cout << ih << endl;
- }
- CbmMvdHit* h1 = (CbmMvdHit*) fMvdHitArray->At(ih);
- if (!h1) {
- continue;
- }
- double V[3] = {2 * h1->GetDx() * h1->GetDx(), 2 * 0, 2 * h1->GetDy() * h1->GetDy()};
- Double_t v = 1. / (V[0] * V[2] - V[1] * V[1]);
- V[0] *= v;
- V[1] *= v;
- V[2] *= v;
- double D2 = 1.e10;
- for (int jh = 0; jh < nMvdHits; jh++) {
- if (ih == jh) {
- continue;
- }
- CbmMvdHit* h2 = (CbmMvdHit*) fMvdHitArray->At(jh);
- if (!h2) {
- continue;
- }
- if (h1->GetStationNr() != h2->GetStationNr()) {
- continue;
- }
- Double_t dx = h1->GetX() - h2->GetX();
- Double_t dy = h1->GetY() - h2->GetY();
- Double_t d2 = fabs(dx * dx * V[0] - 2 * dx * dy * V[1] + dy * dy * V[2]);
- if (d2 < D2) {
- D2 = d2;
- }
- }
- fhHitDensity[h1->GetStationNr() - 1]->Fill(sqrt(D2 / 2.));
- }
- cout << "Sts hit density..." << endl;
- for (int ih = 0; ih < nStsHits; ih++) {
- if (ih % 1000 == 0) {
- cout << ih << endl;
- }
- CbmStsHit* h1 = (CbmStsHit*) fStsHitArray->At(ih);
- if (!h1) {
- continue;
- }
- double V[3] = {2 * h1->GetDx() * h1->GetDx(), 2 * h1->GetDxy(), 2 * h1->GetDy() * h1->GetDy()};
- Double_t v = 1. / (V[0] * V[2] - V[1] * V[1]);
- V[0] *= v;
- V[1] *= v;
- V[2] *= v;
- double D2 = 1.e10;
- for (int jh = 0; jh < nStsHits; jh++) {
- if (ih == jh) {
- continue;
- }
- CbmStsHit* h2 = (CbmStsHit*) fStsHitArray->At(jh);
- if (!h2) {
- continue;
- }
- if (CbmStsSetup::Instance()->GetStationNumber(h1->GetAddress())
- != CbmStsSetup::Instance()->GetStationNumber(h2->GetAddress())) {
- continue;
- }
- // if( h1->GetBackDigiId()>=0 ){
- // if( h1->GetFrontDigiId()!=h2->GetFrontDigiId() &&
- // h1->GetBackDigiId()!=h2->GetBackDigiId() ) continue;
- // }
- Double_t dx = h1->GetX() - h2->GetX();
- Double_t dy = h1->GetY() - h2->GetY();
- Double_t d2 = fabs(dx * dx * V[0] - 2 * dx * dy * V[1] + dy * dy * V[2]);
- if (d2 < D2) {
- D2 = d2;
- }
- }
- fhHitDensity[CbmKF::Instance()->MvdStationIDMap.size()
- + CbmStsSetup::Instance()->GetStationNumber(h1->GetAddress()) - 1]
- ->Fill(sqrt(D2 / 2));
- }
- }
-
- if (0) { // track density
- cout << "Track density..." << endl;
- bool flag[nTracks];
- double sC[nTracks][8][15];
- double sT[nTracks][8][5];
- for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
- flag[iTrack] = 0;
-
- CbmStsTrack* trackI = (CbmStsTrack*) fRecStsTrackArray->At(iTrack);
- if (!IsLong(trackI)) {
- continue;
- }
- flag[iTrack] = 1;
- double z[8] = {0.2, 1, 2, 3, 4, 5, 10, 100};
- for (int iz = 0; iz < 8; iz++) {
- FairTrackParam paramI;
- fFitter.Extrapolate(trackI, z[iz], ¶mI);
- CbmKFMath::CopyTrackParam2TC(¶mI, sT[iTrack][iz], sC[iTrack][iz]);
- if (!std::isfinite(sC[iTrack][iz][0]) || sC[iTrack][iz][0] < 0 || sC[iTrack][iz][0] > 10.) {
- flag[iTrack] = 0;
- break;
- }
- }
- }
- for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
-
- if (iTrack % 10 == 0) {
- cout << iTrack << endl;
- }
- if (!flag[iTrack]) {
- continue;
- }
- double Chi2[8];
- for (int iz = 0; iz < 8; iz++) {
- Chi2[iz] = 1.e10;
- }
- double Chi2L = 1.e10;
-
- for (Int_t jTrack = 0; jTrack < nTracks; jTrack++) {
- if (jTrack == iTrack) {
- continue;
- }
- if (!flag[jTrack]) {
- continue;
- }
-
- for (int iz = 0; iz < 8; iz++) {
- Double_t C[15], d[5];
- for (int i = 0; i < 15; i++) {
- C[i] = sC[iTrack][iz][i] + sC[jTrack][iz][i];
- }
- for (int i = 0; i < 5; i++) {
- d[i] = sT[iTrack][iz][i] - sT[jTrack][iz][i];
- }
- CbmKFMath::invS(C, 5);
-
- double chi2 = 0;
- for (int i = 0; i < 5; i++) {
- double dCi = 0;
- for (int j = 0; j < 5; j++) {
- dCi += d[j] * C[CbmKFMath::indexS(i, j)];
- }
- chi2 += dCi * d[i];
- }
- chi2 = fabs(chi2);
- if (chi2 < Chi2[iz]) {
- Chi2[iz] = chi2;
- }
-
- if (iz == 0) {
- chi2 = 0;
- for (int i = 0; i < 4; i++) {
- double dCi = 0;
- for (int j = 0; j < 4; j++) {
- dCi += d[j] * C[CbmKFMath::indexS(i, j)];
- }
- chi2 += dCi * d[i];
- }
- chi2 = fabs(chi2);
- if (chi2 < Chi2L) {
- Chi2L = chi2;
- }
- }
- }
- }
- for (int iz = 0; iz < 8; iz++) {
- fhTrackDensity[iz]->Fill(sqrt(Chi2[iz] / 5));
- }
- fhTrackDensity0L->Fill(sqrt(Chi2L / 4));
- }
- }
- if (fTrackAnalysis) {
- for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
- if (Quality[iTrack] < 1) {
- continue;
- }
- CbmStsTrack* track = (CbmStsTrack*) fRecStsTrackArray->At(iTrack);
- CbmTrackMatch* m = (CbmTrackMatch*) fSTSTrackMatch->At(iTrack);
- CbmMCTrack* mcTrack = (CbmMCTrack*) fMCTrackArray->At(m->GetMCTrackId());
-
- if (mcTrack->GetMotherId() != -1) {
- continue; // not primary track //IK
- }
-
- // Get MC points;
- vector<CbmStsPoint*> vPoints;
- for (Int_t i = 0; i < track->GetNofStsHits(); i++) {
- Int_t hitID = track->GetStsHitIndex(i);
- if (hitID < 0) {
- continue;
- }
- CbmStsHit* hit = (CbmStsHit*) fStsHitArray->At(hitID);
- if (!hit) {
- continue;
- }
- Int_t pointID = hit->GetRefId();
- if (pointID < 0) {
- continue;
- }
- CbmStsPoint* point = (CbmStsPoint*) fStsPointArray->At(pointID);
- if (!point) {
- continue;
- }
- vPoints.push_back(point);
- }
- vector<CbmMvdPoint*> vMPoints;
- for (Int_t i = 0; i < track->GetNofMvdHits(); i++) {
- Int_t hitID = track->GetMvdHitIndex(i);
- if (hitID < 0) {
- continue;
- }
- CbmMvdHit* hit = (CbmMvdHit*) fMvdHitArray->At(hitID);
- if (!hit) {
- continue;
- }
- Int_t pointID = hit->GetRefIndex();
- if (pointID < 0) {
- continue;
- }
- CbmMvdPoint* point = (CbmMvdPoint*) fMvdPointArray->At(pointID);
- if (!point) {
- continue;
- }
- vMPoints.push_back(point);
- }
- // impact mc track
- Double_t mci[6];
- Double_t pzi = mcTrack->GetPz();
- if (fabs(pzi) > 1.e-4) {
- pzi = 1. / pzi;
- }
- mci[0] = mcTrack->GetStartX();
- mci[1] = mcTrack->GetStartY();
- mci[2] = mcTrack->GetPx() * pzi;
- mci[3] = mcTrack->GetPy() * pzi;
- mci[4] = (fabs(mcTrack->GetP()) > 1.e-4) ? GetCharge(mcTrack) / mcTrack->GetP() : 0;
- mci[5] = mcTrack->GetStartZ();
- if (!vPoints.empty()) {
- if (track->GetNofStsHits() + track->GetNofMvdHits() >= 8) {
- Double_t p1 = mcTrack->GetP();
- TVector3 mom;
- vPoints.back()->MomentumOut(mom);
- Double_t p2 = mom.Mag();
- Double_t s = p1 * p1 * TMath::Sqrt(TMath::Abs(track->GetParamFirst()->GetCovariance(4, 4)));
- Double_t dp = (p1 - p2) * TMath::Sqrt(1 + mci[2] * mci[2] + mci[3] * mci[3]);
- fhDP->Fill(dp);
- fhDP2->Fill(p1, dp);
- fhDsP->Fill(dp / s);
- fhDsP2->Fill(p1, dp / s);
- }
- // first point
- if (!vMPoints.empty()) {
- FillMCStateVectors(vMPoints.front(), mc);
- }
- else {
- FillMCStateVectors(vPoints.front(), mc);
- }
- FillTrackHisto(mc, track, fhFrst);
- fhZMCf->Fill(mc[5]);
- fhZRecof->Fill(track->GetParamFirst()->GetZ());
-
- // last point
- FillMCStateVectors(vPoints.back(), mc, 1);
- FillTrackHisto(mc, track, fhLast);
- fhZMCl->Fill(mc[5]);
- fhZRecol->Fill(track->GetParamLast()->GetZ());
-
- // impact point
-
- if (TMath::Abs(mcTrack->GetPdgCode()) == 211) {
- FillTrackHisto(mci, track, fhImpPi);
- }
- else {
- FillTrackHisto(mci, track, fhImp);
- }
-
- // 4th station (check smoother)
-
- for (vector<CbmStsPoint*>::iterator i = vPoints.begin(); i != vPoints.end(); i++) {
- int id = (*i)->GetDetectorID();
- CbmKF& KF = *CbmKF::Instance();
- if (KF.StsStationIDMap.find(id) == KF.StsStationIDMap.end()) {
- continue;
- }
- if (KF.StsStationIDMap[id] != 3) {
- continue;
- }
- FillMCStateVectors(*i, mc, 1);
- //FillTrackHisto( mc, track, fhMid );
- break;
- }
- }
-
- if (fPrimaryVertex && mcTrack->GetMotherId() == -1) {
-
- // fit track to Primary Vertex
-
- CbmStsTrack tt(*track);
- FairTrackParam par(*tt.GetParamFirst());
- fFitter.FitToVertex(&tt, fPrimaryVertex, &par);
- tt.SetParamFirst(&par);
- //FillTrackHisto(mci,&tt,fhVfit);
-
- // fill momentum resolution
-
- double z = mci[5];
- FairTrackParam param;
- fFitter.Extrapolate(track, z, ¶m);
- if (fabs(mci[4]) > 1.e-4 && fabs(param.GetQp()) > 1.e-4) {
- fhPq->Fill(fabs(1. / mci[4]), (mci[4] / param.GetQp() - 1.));
- }
- }
-
- if (track->GetNDF() > 0) {
- fhChi2->Fill(track->GetChiSq() / track->GetNDF());
- fhProb->Fill(TMath::Prob(track->GetChiSq(), track->GetNDF()));
- }
- }
- }
-
- if (fPrimaryVertex) {
-
- // find MC Primary vertex
-
- TVector3 MC_V(0, 0, 0);
- Bool_t Is_MC_V = 0;
- {
- TVector3 MC_Vcurr(0, 0, 0);
- Int_t nvtracks = 0, nvtrackscurr = 0;
- Int_t nMCTracks = fMCTrackArray->GetEntriesFast();
- for (Int_t iTrack = 0; iTrack < nMCTracks; iTrack++) {
- CbmMCTrack* mcTrack = (CbmMCTrack*) fMCTrackArray->At(iTrack);
- if (mcTrack->GetMotherId() != -1) {
- continue; // not primary track
- }
- double z = mcTrack->GetStartZ();
- if (!Is_MC_V || fabs(z - MC_Vcurr.Z()) > 1.e-7) { // new vertex
- Is_MC_V = 1;
- if (nvtrackscurr > nvtracks) {
- MC_V = MC_Vcurr;
- nvtracks = nvtrackscurr;
- }
- mcTrack->GetStartVertex(MC_Vcurr);
- nvtrackscurr = 1;
- }
- else {
- nvtrackscurr++;
- }
- }
- if (nvtrackscurr > nvtracks) {
- MC_V = MC_Vcurr;
- }
- }
-
-
- if (Is_MC_V) {
-
- // primary vertex fit performance
-
- FillVertexHisto(MC_V, fPrimaryVertex, fhVtx);
-
- if (fVertexAnalysis) {
-
- CbmPVFinderKF Finder;
- TClonesArray TracksToFit("CbmStsTrack");
- Int_t N = 0;
- for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
- if (Quality[iTrack] < 1) {
- continue;
- }
- new (TracksToFit[N]) CbmStsTrack();
- *(CbmStsTrack*) TracksToFit.At(N) = *(CbmStsTrack*) fRecStsTrackArray->At(iTrack);
- N++;
- if (N % 50 != 0) {
- continue;
- }
- Int_t i = N / 50;
- if (i >= 13) {
- continue;
- }
- CbmVertex V;
- Finder.FindPrimaryVertex(&TracksToFit, &V);
- FillVertexHisto(MC_V, &V, fhV[i]);
- }
- CbmVertex V;
- Finder.FindPrimaryVertex(&TracksToFit, &V);
- FillVertexHisto(MC_V, &V, fhV[0]);
- }
-
- // D0 fit performance (if there are)
-
- if (fD0Analysis && fabs(MC_V.Z()) < 1.e-5) {
- // search for Kaon
- for (Int_t iK = 0; iK < nTracks; iK++) {
- if (Quality[iK] < 1) {
- continue;
- }
- CbmStsTrack* tK = (CbmStsTrack*) fRecStsTrackArray->At(iK);
- CbmTrackMatch* m = (CbmTrackMatch*) fSTSTrackMatch->At(iK);
- CbmMCTrack* mcK = (CbmMCTrack*) fMCTrackArray->At(m->GetMCTrackId());
- if (mcK->GetMotherId() != -1) {
- continue; // not primary or D0 track
- }
- if (abs(mcK->GetPdgCode()) != 321) {
- continue;
- }
- double zK = mcK->GetPz();
- if (zK - MC_V.Z() < 1.e-5) {
- continue; // primary
- }
- double MCPK = mcK->GetP();
- fFitter.DoFit(tK, 321); // refit
- // search for Pion
- for (Int_t iP = 0; iP < nTracks; iP++) {
- if (Quality[iP] < 1) {
- continue;
- }
- CbmStsTrack* tP = (CbmStsTrack*) fRecStsTrackArray->At(iP);
- m = (CbmTrackMatch*) fSTSTrackMatch->At(iP);
- CbmMCTrack* mcP = (CbmMCTrack*) fMCTrackArray->At(m->GetMCTrackId());
- if (mcP->GetMotherId() != -1) {
- continue; // not primary or D0 track
- }
- if (abs(mcP->GetPdgCode()) != 211) {
- continue;
- }
- if (mcK->GetPdgCode() * mcP->GetPdgCode() >= 0) {
- continue; //same charge
- }
- double zP = mcP->GetStartZ();
- if (fabs(zP - zK) > 1.e-8) {
- continue; // different vertex
- }
- double MCPP = mcP->GetP();
-
- const double D0 = 1.8645;
-
- TVector3 mc_;
- mcK->GetStartVertex(mc_);
-
- CbmStsKFSecondaryVertexFinder SVFinder;
- SVFinder.AddTrack(tK);
- SVFinder.AddTrack(tP);
-
- for (int iconst = 0; iconst < 4; iconst++) {
-
- switch (iconst) {
- case 0:
- SVFinder.SetMassConstraint(); // no constraints
- SVFinder.SetTopoConstraint();
- break;
- case 1:
- SVFinder.SetMassConstraint(); // Topo constraint
- SVFinder.SetTopoConstraint(fPrimaryVertex);
- break;
- case 2:
- SVFinder.SetMassConstraint(D0); // Mass constraint
- SVFinder.SetTopoConstraint();
- break;
- case 3:
- SVFinder.SetMassConstraint(D0); // Topo + Mass constraint
- SVFinder.SetTopoConstraint(fPrimaryVertex);
- break;
- default: break;
- }
- SVFinder.Fit();
- CbmVertex sv;
- //FairTrackParam KFitted, PFitted;
- Double_t mass, mass_err;
- SVFinder.GetVertex(sv);
- //SVFinder.GetFittedTrack(0, &KFitted );
- //SVFinder.GetFittedTrack(1, &PFitted );
- SVFinder.GetMass(&mass, &mass_err);
- if (sv.GetNDF() <= 0) {
- continue;
- }
- Double_t dx = sv.GetX() - mc_.X();
- Double_t dy = sv.GetY() - mc_.Y();
- Double_t dz = sv.GetZ() - mc_.Z();
- Double_t sx = sv.GetCovariance(0, 0);
- Double_t sy = sv.GetCovariance(1, 1);
- Double_t sz = sv.GetCovariance(2, 2);
- fhD0[iconst][0]->Fill(1.E4 * dx);
- fhD0[iconst][1]->Fill(1.E4 * dy);
- fhD0[iconst][2]->Fill(1.E4 * dz);
- if (sx > 1.e-10) {
- fhD0[iconst][3]->Fill(dx / sqrt(sx));
- }
- if (sy > 1.e-10) {
- fhD0[iconst][4]->Fill(dy / sqrt(sy));
- }
- if (sz > 1.e-10) {
- fhD0[iconst][5]->Fill(dz / sqrt(sz));
- }
- if (sv.GetNDF() > 0) {
- fhD0[iconst][6]->Fill(sv.GetChi2() / sv.GetNDF());
- fhD0[iconst][7]->Fill(TMath::Prob(sv.GetChi2(), sv.GetNDF()));
- }
- fhD0[iconst][8]->Fill((mass - D0));
- if (mass_err > 1.e-10) {
- fhD0[iconst][9]->Fill((mass - D0) / mass_err);
- }
- //fhD0[iconst][10]->Fill( ( fabs(1./KFitted.GetQp()) - MCPK)/MCPK );
- //fhD0[iconst][11]->Fill( (fabs(1./PFitted.GetQp()) - MCPP)/MCPP );
- if (fabs(tK->GetParamFirst()->GetQp()) > 1.e-4 && MCPK > 1.e-4) {
- fhD0[iconst][12]->Fill((fabs(1. / tK->GetParamFirst()->GetQp()) - MCPK) / MCPK);
- }
- if (fabs(tP->GetParamFirst()->GetQp()) > 1.e-4 && MCPP > 1.e-4) {
- fhD0[iconst][13]->Fill((fabs(1. / tP->GetParamFirst()->GetQp()) - MCPP) / MCPP);
- }
- }
- }
- }
- }
- }
- } // vertex analysis
-}
-// -------------------------------------------------------------------------
-
-
-// ----- Finish CbmStsFitPerformanceTask task -----------------------------
-void CbmStsFitPerformanceTask::Finish() { writedir2current(histodir); }
-// -------------------------------------------------------------------------
-
-
-// -------------------------------------------------------------------------
-void CbmStsFitPerformanceTask::FillTrackHisto(const Double_t mc[6], CbmStsTrack* track, TH1D* hist[10])
-{
- if ((mc[5] > 31.0) || (mc[5] < 29.0)) {
- //cout << " Z out " << track->GetParamFirst()->GetZ() << endl;
- //return;
- }
- //cout << "*Z in " << track->GetParamFirst()->GetZ() << endl;
- double z = mc[5];
- FairTrackParam param;
- //cout<<1<<endl;
- fFitter.Extrapolate(track, z, ¶m);
- //cout<<2<<endl;
-
- double t[6], c[15];
- CbmKFMath::CopyTrackParam2TC(¶m, t, c);
- Bool_t ok = 1;
- for (int i = 0; i < 6; i++) {
- ok = ok && std::isfinite(t[i]);
- }
- for (int i = 0; i < 15; i++) {
- ok = ok && std::isfinite(c[i]);
- }
- if (!ok) {
- return;
- }
- //fhExtraTracks2ndMVD->Fill(t[0], t[1]);
-
- hist[0]->Fill(1.E4 * (t[0] - mc[0]));
- hist[1]->Fill(1.E4 * (t[1] - mc[1]));
- hist[2]->Fill(1.E3 * (t[2] - mc[2]));
- hist[3]->Fill(1.E3 * (t[3] - mc[3]));
- if (fabs(t[4]) > 1.e-10) {
- hist[4]->Fill((mc[4] / t[4] - 1.));
- }
- //if (z < 7.0) // first hit
- //if ( fabs( t[4] )>1.e-10 ) fhRes_vs_Mom_f->Fill(fabs(1.0/t[4]),1.E3*(t[2] - mc[2]));
- //if (z > 80.0) // last hit
- //if ( fabs( t[4] )>1.e-10 ) fhRes_vs_Mom_l->Fill(fabs(1.0/t[4]),1.E3*(t[2] - mc[2]));
-
- if (c[0] > 1.e-10) {
- hist[5]->Fill((t[0] - mc[0]) / sqrt(c[0]));
- }
- if (c[2] > 1.e-10) {
- hist[6]->Fill((t[1] - mc[1]) / sqrt(c[2]));
- }
- if (c[5] > 1.e-10) {
- hist[7]->Fill((t[2] - mc[2]) / sqrt(c[5]));
- }
- if (c[9] > 1.e-10) {
- hist[8]->Fill((t[3] - mc[3]) / sqrt(c[9]));
- }
- if (c[14] > 1.e-10) {
- hist[9]->Fill((t[4] - mc[4]) / sqrt(c[14]));
- }
-}
-// -------------------------------------------------------------------------
-
-void CbmStsFitPerformanceTask::FillVertexHisto(TVector3& mc, CbmVertex* V, TH1D* hist[8])
-{
- Double_t dx = V->GetX() - mc.X();
- Double_t dy = V->GetY() - mc.Y();
- Double_t dz = V->GetZ() - mc.Z();
- Double_t s2x = V->GetCovariance(0, 0);
- Double_t s2y = V->GetCovariance(1, 1);
- Double_t s2z = V->GetCovariance(2, 2);
-
- hist[0]->Fill(1.E4 * dx);
- hist[1]->Fill(1.E4 * dy);
- hist[2]->Fill(1.E4 * dz);
- if (s2x > 1.e-10) {
- hist[3]->Fill(dx / sqrt(s2x));
- }
- if (s2y > 1.e-10) {
- hist[4]->Fill(dy / sqrt(s2y));
- }
- if (s2z > 1.e-10) {
- hist[5]->Fill(dz / sqrt(s2z));
- }
- hist[6]->Fill(V->GetChi2() / V->GetNDF());
- hist[7]->Fill(TMath::Prob(V->GetChi2(), V->GetNDF()));
- hist[8]->Fill(V->GetNTracks());
-}
-
-// -------------------------------------------------------------------------
-void CbmStsFitPerformanceTask::FillMCStateVectors(CbmStsPoint* point, Double_t mc[], Bool_t out)
-{
- if (!point) {
- return;
- }
- Int_t mcTrackID = point->GetTrackID();
- CbmMCTrack* mcTrack = (CbmMCTrack*) fMCTrackArray->At(mcTrackID);
- if (!mcTrack) {
- return;
- }
- Double_t q = GetCharge(mcTrack);
-
- // Get MC state vector
- TVector3 r, p;
- if (!out) {
- point->Momentum(p);
- point->Position(r);
- }
- else {
- point->MomentumOut(p);
- point->PositionOut(r);
- }
- double pzi = p.z();
- if (fabs(pzi) > 1.e-4) {
- pzi = 1. / pzi;
- }
- mc[2] = p.x() * pzi;
- mc[3] = p.y() * pzi;
- mc[4] = p.Mag() > 1.e-4 ? q / p.Mag() : 0;
- mc[0] = r.x();
- mc[1] = r.y();
- mc[5] = r.z();
-}
-
-void CbmStsFitPerformanceTask::FillMCStateVectors(CbmMvdPoint* point, Double_t mc[], Bool_t out)
-{
- if (!point) {
- return;
- }
- Int_t mcTrackID = point->GetTrackID();
- CbmMCTrack* mcTrack = (CbmMCTrack*) fMCTrackArray->At(mcTrackID);
- if (!mcTrack) {
- return;
- }
- Double_t q = GetCharge(mcTrack);
-
- // Get MC state vector
- TVector3 r, p;
- if (!out) {
- point->Momentum(p);
- point->Position(r);
- }
- else {
- point->MomentumOut(p);
- point->PositionOut(r);
- }
- double pzi = p.z();
- if (fabs(pzi) > 1.e-4) {
- pzi = 1. / pzi;
- }
- mc[2] = p.x() * pzi;
- mc[3] = p.y() * pzi;
- mc[4] = p.Mag() > 1.e-4 ? q / p.Mag() : 0;
- mc[0] = r.x();
- mc[1] = r.y();
- mc[5] = r.z();
-}
-
-
-// ----- GetCharge ----------------------------------------------------
-Double_t CbmStsFitPerformanceTask::GetCharge(CbmMCTrack* mcTrack)
-{
- Double_t q;
- Int_t pdgCode = mcTrack->GetPdgCode();
- TParticlePDG* particlePDG = TDatabasePDG::Instance()->GetParticle(pdgCode);
- if (particlePDG) {
- q = particlePDG->Charge() / 3.;
- }
- else {
- q = 0;
- }
- return q;
-}
-
-
-// -------------------------------------------------------------------------
-Bool_t CbmStsFitPerformanceTask::IsLong(CbmStsTrack* track)
-{
- Int_t nHits = track->GetNofStsHits();
- if (nHits < 4) {
- return 0;
- }
- Int_t stmin = 1000, stmax = -1000;
- Int_t st, iHit, hitID;
- for (iHit = 0; iHit < nHits; iHit++) {
- hitID = track->GetStsHitIndex(iHit);
- st = ((CbmStsHit*) fStsHitArray->At(hitID))->GetAddress();
- if (st < stmin) {
- stmin = st;
- }
- if (st > stmax) {
- stmax = st;
- }
- }
- if (stmax - stmin + 1 < 4) {
- return 0;
- }
- return 1;
-}
diff --git a/reco/KF/Interface/CbmStsFitPerformanceTask.h b/reco/KF/Interface/CbmStsFitPerformanceTask.h
deleted file mode 100644
index 79c631b185530bb2eb31cddcf6eb80a0898991b0..0000000000000000000000000000000000000000
--- a/reco/KF/Interface/CbmStsFitPerformanceTask.h
+++ /dev/null
@@ -1,139 +0,0 @@
-/* Copyright (C) 2006-2012 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Sergey Gorbunov, Denis Bertini [committer], Florian Uhlig */
-
-// -------------------------------------------------------------------------
-// ----- CbmStsFitPerformanceTask header file -----
-// ----- Created 27/01/05 by E. Kryshen -----
-// -------------------------------------------------------------------------
-
-
-/** CbmStsFitPerformanceTask.h
- **@author S.Gorbunov <sgorboun@mail.desy.de>
- **@author I.Kisel <ikisel@kip.uni-heidelberg.de>
- **@author E.Kryshen <e.kryshen@gsi.de>
- **
- ** Analysis of the KalmanTrackFitter perfomance
- **/
-
-#ifndef CBMSTSFITPERFORMANCE_H
-#define CBMSTSFITPERFORMANCE_H
-
-#include "CbmMCTrack.h"
-#include "CbmMvdPoint.h"
-#include "CbmStsKFTrackFitter.h"
-#include "CbmStsPoint.h"
-#include "CbmStsTrack.h"
-#include "CbmVertex.h"
-#include "FairTask.h"
-#include "FairTrackParam.h"
-#include "TClonesArray.h"
-#include "TH1D.h"
-#include "TH2D.h"
-
-class CbmStsFitPerformanceTask : public FairTask {
-
- public:
- /** Standard constructor */
- CbmStsFitPerformanceTask(const char* name = "CbmStsFitPerformanceTask", Int_t iVerbose = 1);
-
-
- /** Destructor */
- ~CbmStsFitPerformanceTask();
-
-
- /** Initialization of the task */
- InitStatus Init();
-
- /** ReInitialization of the task */
- InitStatus ReInit();
-
-
- /** Execute task */
- void Exec(Option_t* option);
-
-
- /** Finish task */
- void Finish();
-
- /** This function fill state vectors t[], mc[] and covariance
- ** matrix c[] from the given FairTrackParam object and
- ** related CbmStsPoint object.
- ** @param in is set to 1 if in values of position and momentum
- ** are considered.
- */
-
- void FillMCStateVectors(CbmStsPoint* point, Double_t mc[], Bool_t out = 0);
- void FillMCStateVectors(CbmMvdPoint* point, Double_t mc[], Bool_t out = 0);
-
- /** This function fills track pulls and residuals at certain z-position */
- void FillTrackHisto(const Double_t mc[6], CbmStsTrack* track, TH1D* hist[10]);
-
- /** This function fills vertex pulls and residuals */
- void FillVertexHisto(TVector3& mc, CbmVertex* V, TH1D* hist[8]);
-
- /** Returns 1 if track has >=8 measurements and stMaxID-stMinID>=4 */
- Bool_t IsLong(CbmStsTrack* track);
-
- void DoTrackAnalysis(const bool ok = 1) { fTrackAnalysis = ok; }
- void DoVertexAnalysis(const bool ok = 1) { fVertexAnalysis = ok; }
- void DoD0Analysis(const bool ok = 1) { fD0Analysis = ok; }
-
- Double_t GetCharge(CbmMCTrack* mcTrack);
-
- protected:
- void CreateTrackHisto(TH1D* hist[10], const char* name, const char* title);
- void CreateVertexHisto(TH1D* hist[9], const char* name, const char* title);
- void CreateD0Histo(TH1D* hist[14], const char* name, const char* title);
-
- Int_t fEvent;
- Bool_t fVertexAnalysis, fD0Analysis, fTrackAnalysis;
-
- TClonesArray* fMCTrackArray; ///< MCTracks
- TClonesArray* fStsPointArray; ///< StsPoints
- TClonesArray* fMvdPointArray; ///< StsPoints
- TClonesArray* fRecStsTrackArray; ///< Reconstructed StsTracks
- TClonesArray* fStsHitArray; ///< Sts hits
- TClonesArray* fMvdHitArray; ///< Sts hits
- CbmVertex* fPrimaryVertex; ///< Primary vertex
- TClonesArray* fSTSTrackMatch; ///< Related MC tracks
-
- TH1D* fhChi2; // x=chi2; y=entries for all
- TH1D* fhProb; // x=Prob function; y=entries for all
- TH1D* fhDP;
- TH2D* fhDP2;
- TH1D* fhDsP;
- TH2D* fhDsP2;
-
- TH1D *fhZMCf, *fhZMCl; // z first/last of MC track
- TH1D *fhZRecof, *fhZRecol; // z first/last of Reco track
-
- TH2D *fhRes_vs_Mom_f, *fhRes_vs_Mom_l; // resolution vs momentum
- TH2D* fhExtraTracks2ndMVD; // extra tracks not detected in the second mvd chamber
-
- TH1D* fhFrst[10];
- TH1D* fhMid[10];
- TH1D* fhLast[10];
- TH1D* fhImp[10];
- TH1D* fhImpPi[10];
- TH1D* fhVfit[10];
- TH1D* fhVtx[9];
- TH1D* fhV[13][9];
- TH2D* fhPq;
- TH1D* fhD0[4][14];
-
- TH1D* fhHitDensity[10];
- TH1D* fhTrackDensity[8];
- TH1D* fhTrackDensity0L;
-
- TDirectory* histodir;
- CbmStsKFTrackFitter fFitter;
-
- ClassDef(CbmStsFitPerformanceTask, 1);
-
- private:
- CbmStsFitPerformanceTask(const CbmStsFitPerformanceTask&);
- void operator=(const CbmStsFitPerformanceTask&);
-};
-
-#endif
diff --git a/reco/KF/Interface/CbmStsKFSecondaryVertexFinder.cxx b/reco/KF/Interface/CbmStsKFSecondaryVertexFinder.cxx
deleted file mode 100644
index e19e61a97c2a91cdb0511b341478224ad4ef8f61..0000000000000000000000000000000000000000
--- a/reco/KF/Interface/CbmStsKFSecondaryVertexFinder.cxx
+++ /dev/null
@@ -1,109 +0,0 @@
-/* Copyright (C) 2006-2016 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Sergey Gorbunov, Ivan Kisel, Denis Bertini [committer] */
-
-/** Implementation of the CbmKFSecondaryVertexFinder class
- *
- * @author S.Gorbunov, I.Kisel
- * @version 1.0
- * @since 06.02.06
- *
- */
-#include "CbmStsKFSecondaryVertexFinder.h"
-
-#include "CbmKFMath.h"
-
-#include <vector>
-
-using std::vector;
-
-ClassImp(CbmStsKFSecondaryVertexFinder)
-
- void CbmStsKFSecondaryVertexFinder::Clear(Option_t* /*opt*/)
-{
- Finder.Clear();
- vStsTracks.clear();
- vKFTracks.clear();
-}
-
-void CbmStsKFSecondaryVertexFinder::AddTrack(CbmStsTrack* Track)
-{
- if (!Track) {
- return;
- }
- vStsTracks.push_back(Track);
- vKFTracks.push_back(CbmKFTrack(*Track));
-}
-
-void CbmStsKFSecondaryVertexFinder::SetApproximation(CbmVertex* Guess)
-{
- if (!Guess) {
- Finder.SetApproximation();
- }
- else {
- VGuess.SetVertex(*Guess);
- Finder.SetApproximation(&VGuess);
- }
-}
-
-void CbmStsKFSecondaryVertexFinder::SetMassConstraint(Double_t MotherMass) { Finder.SetMassConstraint(MotherMass); }
-
-void CbmStsKFSecondaryVertexFinder::SetTopoConstraint(CbmVertex* Parent)
-{
- if (!Parent) {
- Finder.SetTopoConstraint();
- }
- else {
- VParent.SetVertex(*Parent);
- Finder.SetTopoConstraint(&VParent);
- }
-}
-
-void CbmStsKFSecondaryVertexFinder::Fit()
-{
- Finder.ClearTracks();
- for (vector<CbmKFTrack>::iterator i = vKFTracks.begin(); i != vKFTracks.end(); ++i) {
- Finder.AddTrack(&*i);
- }
- Finder.Fit();
-}
-
-void CbmStsKFSecondaryVertexFinder::GetVertex(CbmVertex& vtx) { Finder.GetVertex(vtx); }
-/*
-void CbmStsKFSecondaryVertexFinder::GetFittedTrack( Int_t itrack, CbmStsTrack *Track ){
- if(!Track) return;
- *Track = *vStsTracks[itrack];
- double T[6], C[15];
- Finder.GetTrack(itrack, T, C );
- CbmKFMath::CopyTC2TrackParam( Track->GetParamFirst(), T, C );
-}
-
-void CbmStsKFSecondaryVertexFinder::GetFittedTrack( Int_t itrack, FairTrackParam *Param ){
- if(!Param) return;
- double T[6], C[15];
- Finder.GetTrack(itrack, T, C );
- CbmKFMath::CopyTC2TrackParam( Param, T, C );
-}
-*/
-void CbmStsKFSecondaryVertexFinder::GetMotherTrack(CbmStsTrack* MotherTrack)
-{
- if (!MotherTrack) {
- return;
- }
- double T[6], C[15];
- Finder.GetMotherTrack(T, C);
- FairTrackParam parFirst(*MotherTrack->GetParamFirst()), parLast(*MotherTrack->GetParamLast());
- CbmKFMath::CopyTC2TrackParam(&parFirst, T, C); // MotherTrack->GetParamFirst(), T, C );
- CbmKFMath::CopyTC2TrackParam(&parLast, T, C); //MotherTrack->GetParamLast(), T, C );
- MotherTrack->SetParamFirst(&parFirst);
- MotherTrack->SetParamLast(&parLast);
- MotherTrack->SetPidHypo(211);
- MotherTrack->SetChiSq(0);
- MotherTrack->SetNDF(1);
-}
-
-void CbmStsKFSecondaryVertexFinder::GetMass(Double_t* M, Double_t* Error_) { Finder.GetMass(M, Error_); }
-
-CbmStsTrack* CbmStsKFSecondaryVertexFinder::GetTrack(Int_t itrack) { return vStsTracks[itrack]; }
-
-Int_t CbmStsKFSecondaryVertexFinder::GetNTracks() { return vStsTracks.size(); }
diff --git a/reco/KF/Interface/CbmStsKFSecondaryVertexFinder.h b/reco/KF/Interface/CbmStsKFSecondaryVertexFinder.h
deleted file mode 100644
index 8edea696a26cabd48d7b5a34ab51fa87e1e65f03..0000000000000000000000000000000000000000
--- a/reco/KF/Interface/CbmStsKFSecondaryVertexFinder.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/* Copyright (C) 2006-2015 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Sergey Gorbunov, Ivan Kisel, Denis Bertini [committer] */
-
-/** The CbmStsKFSecondaryVertexFinder class
- *
- * @author S.Gorbunov, I.Kisel
- * @version 1.0
- * @since 06.02.06
- *
- * Class to find secondary vertex with the Kalman Filter method
- *
- */
-#ifndef CBMSTSKFSECONDARYVERTEXFINDER_H
-#define CBMSTSKFSECONDARYVERTEXFINDER_H
-
-#include "CbmKFSecondaryVertexFinder.h"
-#include "CbmKFTrack.h"
-#include "CbmKFVertex.h"
-#include "CbmStsTrack.h"
-
-#include <vector>
-
-class CbmStsKFSecondaryVertexFinder : public TObject {
-
- std::vector<CbmStsTrack*> vStsTracks;
- std::vector<CbmKFTrack> vKFTracks;
- CbmKFVertex VParent, VGuess;
- CbmKFSecondaryVertexFinder Finder;
-
- public:
- CbmStsKFSecondaryVertexFinder() : vStsTracks(), vKFTracks(), VParent(), VGuess(), Finder() { Clear(); };
- ~CbmStsKFSecondaryVertexFinder(){};
-
- virtual void Clear(Option_t* opt = "");
- void AddTrack(CbmStsTrack* Track);
- void SetApproximation(CbmVertex* Guess = nullptr);
- void SetMassConstraint(Double_t MotherMass = -1);
- void SetTopoConstraint(CbmVertex* Parent = nullptr);
- void Fit();
- void GetVertex(CbmVertex& vtx);
- //void GetFittedTrack( Int_t itrack, CbmStsTrack *Track );
- //void GetFittedTrack( Int_t itrack, FairTrackParam *Param );
- void GetMotherTrack(CbmStsTrack* MotherTrack);
- void GetMass(Double_t* M, Double_t* Error);
- CbmStsTrack* GetTrack(Int_t itrack);
- Int_t GetNTracks();
-
- ClassDef(CbmStsKFSecondaryVertexFinder, 1);
-};
-#endif /* !CBMSTSKFSECONDARYVERTEXFINDER_H */
diff --git a/reco/KF/KF.cmake b/reco/KF/KF.cmake
index 314bff3e0874fa89e54f7af8b77c1ae5a03b01d5..6f17ea7e68a2b1b4af2c1b8179c0084f7b46f204 100644
--- a/reco/KF/KF.cmake
+++ b/reco/KF/KF.cmake
@@ -6,7 +6,6 @@ set(INCLUDE_DIRECTORIES
${CMAKE_CURRENT_SOURCE_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/Interface
${CMAKE_CURRENT_SOURCE_DIR}/ParticleFitter
- ${CMAKE_CURRENT_SOURCE_DIR}/obsolete
)
set(SRCS
@@ -17,38 +16,24 @@ set(SRCS
CbmKFMath.cxx
CbmKFPixelMeasurement.cxx
CbmKFPrimaryVertexFinder.cxx
- CbmKFSecondaryVertexFinder.cxx
CbmKFTrackInterface.cxx
CbmKFUMeasurement.cxx
CbmKFVertexInterface.cxx
CbmKfTrackFitter.cxx
CbmKfFitTracksTask.cxx
- #Interface/CbmEcalTrackExtrapolationKF.cxx
Interface/CbmKFStsHit.cxx
Interface/CbmKFTrack.cxx
- Interface/CbmKFTrdHit.cxx
- Interface/CbmKFTofHit.cxx
+ Interface/CbmKFVertex.cxx
Interface/CbmPVFinderKF.cxx
Interface/CbmPVFinderKFGlobal.cxx
- Interface/CbmStsFitPerformanceTask.cxx
Interface/CbmStsKFTrackFitter.cxx
- Interface/CbmStsKFSecondaryVertexFinder.cxx
- Interface/CbmGlobalTrackFitterKF.cxx
# CbmKFParticleInterface.cxx
#CbmKFParticleFinder.cxx
#CbmKFParticleFinderPID.cxx
#CbmKFParticleFinderQa.cxx
#CbmKFParticleInterface.cxx
ParticleFitter/CbmL1PFFitter.cxx
- ParticleFitter/CbmL1PFMCParticle.cxx
- obsolete/CbmL1TrackMerger.cxx
- obsolete/CbmL1TofMerger.cxx
- obsolete/CbmL1TrdTracklet.cxx
- obsolete/CbmL1TrdTracklet4.cxx
- # obsolete/CbmL1TrdTrackFinderSts.cxx
- # obsolete/CbmL1CATrdTrackFinderSA.cxx
-
)
diff --git a/reco/KF/KFLinkDef.h b/reco/KF/KFLinkDef.h
index 4bb0668b28f3421f3b136b118ba4100a5d27c08e..9e60f8c556cc964ea28328f0984dac7599555f11 100644
--- a/reco/KF/KFLinkDef.h
+++ b/reco/KF/KFLinkDef.h
@@ -9,14 +9,11 @@
#pragma link off all functions;
#pragma link C++ class CbmKF + ;
-#pragma link C++ class CbmKFSecondaryVertexFinder + ;
#pragma link C++ class CbmKFPrimaryVertexFinder + ;
#pragma link C++ class CbmKFMath + ;
#pragma link C++ class CbmKFFieldMath + ;
#pragma link C++ class CbmKFHit + ;
#pragma link C++ class CbmKFStsHit + ;
-#pragma link C++ class CbmKFTrdHit + ;
-#pragma link C++ class CbmKFTofHit + ;
#pragma link C++ class CbmKFUMeasurement + ;
#pragma link C++ class CbmKFPixelMeasurement + ;
#pragma link C++ class CbmKFTrackInterface + ;
@@ -29,20 +26,10 @@
#pragma link C++ class CbmKFWall + ;
#pragma link C++ class CbmKFCone + ;
#pragma link C++ class CbmStsKFTrackFitter + ;
-#pragma link C++ class CbmStsKFSecondaryVertexFinder + ;
#pragma link C++ class CbmPVFinderKF + ;
#pragma link C++ class CbmPVFinderKFGlobal + ;
-#pragma link C++ class CbmStsFitPerformanceTask + ;
-//#pragma link C++ class CbmEcalTrackExtrapolationKF+;
-#pragma link C++ class CbmGlobalTrackFitterKF + ;
-#pragma link C++ class CbmL1TrackMerger + ;
-#pragma link C++ class CbmL1TofMerger + ;
-#pragma link C++ class CbmL1TrdTracklet + ;
-#pragma link C++ class CbmL1TrdTracklet4 + ;
#pragma link C++ class CbmKfTrackFitter + ;
#pragma link C++ class CbmKfFitTracksTask + ;
-//#pragma link C++ class CbmL1TrdTrackFinderSts+;
-//#pragma link C++ class CbmL1CATrdTrackFinderSA+;
//#pragma link C++ class CbmTrackingDetectorInterfaceInit + ;
//KFQA
diff --git a/reco/KF/ParticleFitter/CbmL1PFMCParticle.cxx b/reco/KF/ParticleFitter/CbmL1PFMCParticle.cxx
deleted file mode 100644
index ea379965c9e6ca5803acb87a39ebef668a802618..0000000000000000000000000000000000000000
--- a/reco/KF/ParticleFitter/CbmL1PFMCParticle.cxx
+++ /dev/null
@@ -1,22 +0,0 @@
-/* Copyright (C) 2011 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Maksym Zyzak [committer] */
-
-/*
- *=====================================================
- *
- * CBM Level 1 Reconstruction
- *
- * Authors: M.Zyzak
- *
- * e-mail :
- *
- *=====================================================
- *
- * Finds Particles: Lambdas, K0
- *
- */
-
-#include "CbmL1PFMCParticle.h"
-
-#include "CbmL1MCTrack.h"
diff --git a/reco/KF/ParticleFitter/CbmL1PFMCParticle.h b/reco/KF/ParticleFitter/CbmL1PFMCParticle.h
deleted file mode 100644
index a67586210356b9410adcf441492c2dcb226f3194..0000000000000000000000000000000000000000
--- a/reco/KF/ParticleFitter/CbmL1PFMCParticle.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/* Copyright (C) 2011-2017 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Maksym Zyzak [committer] */
-
-/*
- *=====================================================
- *
- * CBM Level 1 Reconstruction
- *
- * Authors: M.Zyzak
- *
- * e-mail :
- *
- *=====================================================
- *
- * Finds Particles: Lambdas, K0
- *
- */
-
-#ifndef _CbmL1PFMCParticle_h_
-#define _CbmL1PFMCParticle_h_
-
-#include "TObject.h"
-
-#include <vector>
-using std::vector;
-
-class CbmL1MCTrack;
-
-struct McVector {
- vector<CbmL1MCTrack*> mcTracks;
-};
-
-struct McTrackFind {
- CbmL1MCTrack* mcTrack;
- int vNumber;
-};
-
-
-#endif
diff --git a/reco/KF/obsolete/CbmL1CATrdTrackFinderSA.cxx b/reco/KF/obsolete/CbmL1CATrdTrackFinderSA.cxx
deleted file mode 100644
index e23fb2fb58cdbbd9c5ef473146e2833bcbc21f0a..0000000000000000000000000000000000000000
--- a/reco/KF/obsolete/CbmL1CATrdTrackFinderSA.cxx
+++ /dev/null
@@ -1,3153 +0,0 @@
-/* Copyright (C) 2006-2021 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Sergey Gorbunov, Denis Bertini [committer] */
-
-// -----------------------------------------------------------------------
-// ----- CbmL1CATrdTrackFinderSA -----
-// ----- Created 2/12/2006 by A. Bubak & M. Krauze -----
-// -----------------------------------------------------------------------
-
-#include "CbmL1CATrdTrackFinderSA.h"
-
-#include "CbmGeoTrdPar.h"
-#include "CbmKF.h"
-#include "CbmKFTrack.h"
-#include "CbmKFTrdHit.h"
-#include "CbmL1.h"
-#include "CbmL1TrdTracklet.h"
-#include "CbmL1TrdTracklet4.h"
-#include "CbmMCTrack.h"
-#include "CbmStsTrack.h"
-#include "CbmTrdHit.h"
-#include "CbmTrdPoint.h"
-#include "CbmTrdTrack.h"
-#include "CbmTrdTrackFitterKF.h"
-#include "CbmVertex.h"
-#include "FairBaseParSet.h"
-#include "FairDetector.h"
-#include "FairGeoNode.h"
-#include "FairMCPoint.h"
-#include "FairRootManager.h"
-#include "FairRunAna.h"
-#include "FairRuntimeDb.h"
-#include "L1Def.h"
-#include "TClonesArray.h"
-#include "TH1F.h"
-#include "TH2F.h"
-#include "TLinearFitter.h"
-
-#include <cmath>
-#include <iostream>
-#include <list>
-#include <map>
-#include <vector>
-
-using std::cout;
-using std::endl;
-using std::fabs;
-using std::map;
-using std::pair;
-using std::set;
-using std::vector;
-
-//#include "L1CATrdDraw.h"
-
-ClassImp(CbmL1CATrdTrackFinderSA);
-
-
-CbmL1CATrdTrackFinderSA* CbmL1CATrdTrackFinderSA::fInstance = 0;
-
-// ----------------------- Default constructor ---------------------------
-CbmL1CATrdTrackFinderSA::CbmL1CATrdTrackFinderSA()
- : geoLayer()
- , fNTrdHits(0)
- , fNoTrdStations(0)
- , fNoTrdPerStation(0)
- , planeHits()
- , fivTrdHitArr()
- , fArrayTrdHit(new TClonesArray("CbmTrdHit"))
- , fArrayTrdTrack(new TClonesArray("CbmTrdTrack"))
- , TrdPar(0)
- , fEvents(0)
- , fNofEvents(0)
- , fMCTrackArray(0)
- , fMCPointArray(0)
- , trdTrackFitterKF(new CbmTrdTrackFitterKF(1, 11))
- , fVerbose(1)
- ,
-
- fvTempArray()
- , fvFoundTracks()
- , tempTrack()
- ,
-
- iStation1()
- , iStation2()
- , fImapSt1()
- , fImapSt2()
- , itTrackletsLeft()
- , itTrackletsRight()
- ,
-
- iHitMap1(0)
- , iHitMap2(0)
- , iHitMapY1(0)
- , iHitMapY2(0)
- , fTrd13_Z(0)
- , fTrd14_Z(0)
- , fTrd21_Z(0)
- , fTrd24_Z(0)
- , fTrd31_Z(0)
- , fKfTrack(0)
- , createSegments()
- , findNeighbour()
- , createSPs()
- , createSPs_SL()
- , sortSPs()
- , doFind()
- , sortHits()
- , tagTracks()
- , createTracks()
- , selectTracks()
- , delTime()
- , secondLoopTime()
- , refittingKF()
- , thirdLoopTime()
- , totCreateSegments(0)
- , totFindNeighbour(0)
- , totCreateSPs(0)
- , totCreateSPs_SL(0)
- , totSortSPs(0)
- , totDoFind(0)
- , totSortHits(0)
- , totTagTracks(0)
- , totCreateTracks(0)
- , totDelTime(0)
- , totSecondLoopTime(0)
- , totThirdLoopTime(0)
- , totSelectTracks(0)
- , totRefittingKF(0)
- , fh_chi2hit(0)
- , fh_chi2hit_plane(0)
- , fDistLongX(0)
- , fDistLongY(0)
- , fDistShortX(0)
- , fDistShortY(0)
- , fDistLongBX(0)
- , fDistLongBY(0)
- , fDistShortBX(0)
- , fDistShortBY(0)
- , fDistY12(0)
- , fMomDistLongPrimaryX(0)
- , fMomDistLongPrimaryY(0)
- , fMomDistLongExtraX(0)
- , fMomDistLongExtraY(0)
- , fMomDistExtrapolPrimaryX(0)
- , fMomDistExtrapolPrimaryY(0)
- , fMomDistExtrapolExtraX(0)
- , fMomDistExtrapolExtraY(0)
- , fMomDistShortPrimaryX(0)
- , fMomDistShortPrimaryY(0)
- , fMomDistShortExtraX(0)
- , fMomDistShortExtraY(0)
- , fDistY(0)
- , fDistX(0)
- , fPlane1Ydens(0)
- , fPlane5Ydens(0)
- , fPlane9Ydens(0)
- , fSPlength(0)
- , fSPlengthMC(0)
- , fYat0(0)
- , fYat0MC(0)
- , fNoEvTime(0)
- , fh_SP_xDiff_MC(0)
- , fh_SP_yDiff_MC(0)
- , fh_SP_xDiff_nMC(0)
- , fh_SP_yDiff_nMC(0)
- , fUsedHitsPerPlane(0)
- , fUnUsedHitsPerPlane(0)
- , fRUsedHits()
- , fRUnUsedHits()
- , fTotHits()
-{
- if (!fInstance) fInstance = this;
-}
-// -----------------------------------------------------------------------
-
-// --------------------------- Destructor --------------------------------
-CbmL1CATrdTrackFinderSA::~CbmL1CATrdTrackFinderSA()
-{
- delete fArrayTrdHit;
- delete fArrayTrdTrack;
- delete trdTrackFitterKF;
- // delete fKfTrack;
- if (fInstance == this) fInstance = 0;
-}
-// -----------------------------------------------------------------------
-
-
-// ------------------------- Initialisation ------------------------------
-void CbmL1CATrdTrackFinderSA::Init()
-{
- // Create histogramms
- CreateHistogramms();
- // Activate data branches
- DataBranches();
-
- FairRootManager* ioman = FairRootManager::Instance();
- if (!ioman) {
- cout << "-E- CbmL1CATrdTrackFinderSA::Init: "
- << "RootManager not instantised!" << endl;
- return;
- }
-
- // Get MCTrack array
- fMCTrackArray = L1_DYNAMIC_CAST<TClonesArray*>(ioman->GetObject("MCTrack"));
- if (!fMCTrackArray) {
- cout << "-E- CbmL1CATrdTrackFinderSA::Init: No MCTrack array!" << endl;
- return;
- }
-
- // Get MCPoint array
- fMCPointArray = L1_DYNAMIC_CAST<TClonesArray*>(ioman->GetObject("TrdPoint"));
- if (!fMCPointArray) {
- cout << "-E- CbmL1CATrdTrackFinderSA::Init: No MCPoint array!" << endl;
- return;
- }
-
- // Determine the TRD layout
- TrdLayout();
-
- // Init KF Track fitter
- trdTrackFitterKF->Init();
-}
-// -----------------------------------------------------------------------
-
-
-// -------------------- Algorithm implementation -------------------------
-Int_t CbmL1CATrdTrackFinderSA::DoFind(TClonesArray* hitArray, TClonesArray* trackArray)
-{
-
-#ifdef DRAW
- InitL1Draw();
-#endif
-
- fArrayTrdHit = hitArray;
- fArrayTrdTrack = trackArray;
-
- fNofEvents++;
-
- doFind.Start();
-
- // Initialize control counters
- // Int_t nNoTrdPoint = 0;
- Int_t nNoTrdHit = 0;
- Int_t trdPlaneID = 0;
- Int_t ptIndex = 0;
- Int_t noHitsPerTracklet = 4;
-
- // Create pointers to TRD hit and TrdPoint
- CbmTrdHit* pHit = NULL;
- CbmTrdPoint* pMCpt = NULL;
- // CbmMCTrack* pMCtr = NULL;
-
- //--- Function: CreateSpacePoint --------------------------------------
- Double_t // b
- sigmaA_FL = 2, //3 3 3 2.5 2.5
- sigmaB_FL = 2, //3 3 3 2.5 2.5
- sigmaA_SL = 3, //4 4 4 3 3
- sigmaB_SL = 3, //4 4 4 3 3
- sigmaA_TL = 4, //4 4 4 4 4
- sigmaB_TL = 4; //4 4 4 4 4
- //--- Function: CreateSegments; Data from MC, look inside function ----
- Double_t dY_FL = 0.3, //0.5 0.5 0.5 0.4 0.4
- dX_FL = 0.3, //0.5 0.5 0.5 0.4 0.4
- dY_SL = 0.5, //0.7 0.6 0.8 0.6 0.6
- dX_SL = 0.5, //0.8 0.8 0.8 0.6 0.6
- dY_TL = 0.7, //0.7 0.6 0.8 0.7 0.8
- dX_TL = 0.7; //0.8 0.8 0.8 0.7 0.8
-
- //--- Function: FindNeighbour ------------------------------------------
- //distance from Y-propagated point, around which we look for neighbours
- Double_t distPropLongY_FL = 2.5, //3 3 3 3 2
- distPropLongX_FL = 2.5, //3 3 3 3 2
- distPropLongY_SL = 3, //4 4 4 3 3
- distPropLongX_SL = 3, //8 6 8 3 3
- distPropLongY_TL = 4, //4 4 4 3 4
- distPropLongX_TL = 4; //8 6 8 3 4
-
- //----------------------------------------------------------------------
- Bool_t competition = true;
- Bool_t removeUsedHits = true;
- Bool_t secondLoop = true;
- Bool_t thirdLoop = true;
- Int_t segment = 0; //0 = long tracks, 1 = segments only
- //Int_t nrLoop = 1;
-
- //---- Simulate detector inefficiency -----------------------------------
- Int_t accept = 100;
- set<Int_t> globalSetRejectedHits;
- globalSetRejectedHits.clear();
- //----------------------------------------------------------------------
-
-
- sortHits.Start();
- //--- hit sorting procedure ------------------------------------------------
- Int_t nTrdHit = hitArray->GetEntriesFast();
- for (Int_t iHit = 0; iHit < nTrdHit; iHit++) {
- // Loop over hits. Get corresponding MCPoint and MCTrack index
- pHit = L1_DYNAMIC_CAST<CbmTrdHit*>(hitArray->At(iHit));
-
- if (!Rejection(accept)) {
- // Simulate detector inefficiency
- globalSetRejectedHits.insert(iHit);
- continue;
- }
- if (!pHit) {
- cout << "-E- CbmL1CATrdTrackFinderSA::DoFind: Empty slot "
- << "in HitArray at position " << iHit << endl;
- nNoTrdHit++;
- continue;
- }
-
- ptIndex = pHit->GetRefId();
- //if (ptIndex < 0) continue; // fake or background hit
- pMCpt = L1_DYNAMIC_CAST<CbmTrdPoint*>(fMCPointArray->At(ptIndex));
- //if (!pMCpt) {
- // nNoTrdPoint++;
- // continue;
- //}
- // pMCtr = L1_DYNAMIC_CAST<CbmMCTrack*>(fMCTrackArray->At(pMCpt->GetTrackID()));
- //if ( ! pMCtr ) continue;
-
- trdPlaneID = pHit->GetPlaneId();
- Int_t trdPlaneIDN = trdPlaneID - 1;
-
- planeHits.mcTrackID = pMCpt->GetTrackID();
- planeHits.hitIndex = iHit;
- planeHits.X = pHit->GetX();
- planeHits.Y = pHit->GetY();
- planeHits.Z = pHit->GetZ();
- planeHits.DX = pHit->GetDx();
- planeHits.DY = pHit->GetDy();
- planeHits.planeID = trdPlaneID;
- fvTrdHitArr[trdPlaneIDN].push_back(planeHits);
-
- // cout << "geoLayer: " <<geoLayer.Y[trdPlaneID] <<", "<< geoLayer.Z[trdPlaneID] << endl;
- //ptIndex = pHit->GetRefIndex();
- //pMCpt = (CbmTrdPoint*) (fMCPointArray->At(ptIndex));
-
- //planeHits.hitIndex = ptIndex;
- //planeHits.X = pMCpt->GetX();
- //planeHits.Y = pMCpt->GetY();
- //planeHits.Z = pMCpt->GetZ();
- //planeHits.DX = 0;
- //planeHits.DY = 0;;
- //fvTrdPointArr[trdPlaneIDN].push_back(planeHits);
- }
-
- for (Int_t i = 0; i < 12; i++) {
- sort(fvTrdHitArr[i].begin(), fvTrdHitArr[i].end(), CompareY);
- }
-
- /*
- //-----------------------------------------------------------
- vector <LayerWithHits>::iterator ivT;
- LayerWithHits pl;
- for(ivT = fvTrdHitArr[0].begin();
- ivT != fvTrdHitArr[0].end();
- ivT++){
- pl = (*ivT);
- cout <<"(X:Y) "<<pl.X<<"\t"<< pl.Y << endl;
- fPlane1Ydens->Fill(pl.Y);
- }
-
- for(ivT = fvTrdHitArr[5].begin();
- ivT != fvTrdHitArr[5].end();
- ivT++){
- pl = (*ivT);
- // cout << pl.Y << endl;
- fPlane5Ydens->Fill(pl.Y);
- }
- for(ivT = fvTrdHitArr[9].begin();
- ivT != fvTrdHitArr[9].end();
- ivT++){
- pl = (*ivT);
- // cout << pl.Y << endl;
- fPlane9Ydens->Fill(pl.Y);
- }
- //-----------------------------------------------------------
- */
- sortHits.Stop();
-
- if (fVerbose > 2) {
- cout << "-I- CbmL1CATrdTrackFinderSA::DoFind " << endl;
- for (Int_t i = 0; i < 12; i++) {
- cout << " Size of vector " << i << ": " << fvTrdHitArr[i].size() << endl;
- }
- }
-
- //create vectors that will hold the tracklet (4-hit) objects
- vector<CbmL1TrdTracklet4*> clTracklets[3];
- vector<CbmL1TrdTracklet4*> clTrackletsNew[3];
-
- //create vectors that will hold the mini-tracklet (2-hit) objects - Space Points
- vector<CbmL1TrdTracklet*> clSpacePoints[6];
-
- if (noHitsPerTracklet == 4) { //noHitsPerTracklet == 4
- //------ creation of mini tracklet 1-2 -------------------------------------
- cout << endl
- << "-I- CbmL1CATrdTrackFinderSA::DoFind " << endl
- << "--------------------------------------------------" << endl
- << " ### Start creation of Space Points" << endl
- << "--------------------------------------------------" << endl;
-
- createSPs.Start();
- for (Int_t i = 0, j = 0; i < 6; i++, j = j + 2) {
- CreateSpacePoints(fvTrdHitArr[j], fvTrdHitArr[j + 1], clSpacePoints[i], sigmaA_FL, sigmaB_FL);
- }
- createSPs.Stop();
-
- //------- Sorting spacepoints -------------------------------------------------
- sortSPs.Start();
- for (Int_t i = 0; i < 6; i++) {
- sort(clSpacePoints[i].begin(), clSpacePoints[i].end(), CbmL1TrdTracklet::Compare1);
- }
- sortSPs.Stop();
-
- // --------------- Creation tracklet from 4 space points ----------------
- cout << endl
- << "-I- CbmL1CATrdTrackFinderSA::DoFind " << endl
- << "--------------------------------------------------" << endl
- << " ### Start creation tracklets" << endl
- << "--------------------------------------------------" << endl;
- createSegments.Start();
- //joining SP together to create 4-hit tracklets
- for (Int_t i = 0, j = 0; i < 3; i++, j = j + 2) {
- CreateSegments(clSpacePoints[j], clSpacePoints[j + 1], clTracklets[i], dX_FL, dY_FL);
- }
- createSegments.Stop();
-
- //--- TESTING -------------------------------
- /* How many segments have 4 hits belonging to the same track (has the same trackID)*/
- /*
- vector<CbmL1TrdTracklet4*>::iterator itclTrackletsRight;
- vector<CbmL1TrdTracklet4*>::iterator iTrackletT;
- Int_t iSumSegment = 0;
- CbmTrdHit *trdHit;
- CbmTrdPoint* trdPoint;
-
- for(int i = 0; i < 3; i++){
- Double_t clSegmentSize = clTracklets[i].size();
- cout <<"Tracklet size: "<< clSegmentSize << endl;
- iSumSegment = 0;
-
- for(iTrackletT = clTracklets[i].begin();
- iTrackletT != clTracklets[i].end();
- iTrackletT++){
-
- Int_t k = 0;
- Int_t Ind0 = (*iTrackletT)->GetInd(0);
- trdHit = L1_DYNAMIC_CAST<CbmTrdHit*>( hitArray->At(Ind0);
- trdPoint = (CbmTrdPoint*) fMCPointArray->At(trdHit->GetRefIndex());
- Double_t trackID1 = trdPoint->GetTrackID();
-
- for(int iw = 1; iw < 4; iw++){
- Int_t Ind1 = (*iTrackletT)->GetInd(iw);
- trdHit = L1_DYNAMIC_CAST<CbmTrdHit*>( hitArray->At(Ind1);
- trdPoint = (CbmTrdPoint*) fMCPointArray->At(trdHit->GetRefIndex());
- Double_t trackID2 = trdPoint->GetTrackID();
-
- if(trackID1 == trackID2) k++;
- }
- if(k == 3){
- iSumSegment++;
- }
- }
-
- Double_t sumSegmentWith4 = (iSumSegment*100)/clSegmentSize;
- //printf("(size %f, %i, %f)\n", clSegmentSize, iSumSegment, sumSegmentWith4);
- }
- //---------------------------------------------
- */
-
- //---------- BEGIN: Find friend ------------------------------------------------
- findNeighbour.Start();
-
- cout << "--- Finding neighbour 14-58" << endl;
- FindNeighbour(clTracklets[0], clTracklets[1], distPropLongX_FL, distPropLongY_FL);
-
- cout << "--- Finding neighbour 58-912" << endl;
- FindNeighbour(clTracklets[1], clTracklets[2], distPropLongX_FL, distPropLongY_FL);
-
- findNeighbour.Stop();
-
- } //end of noHitsPerTracklet == 4
-
- //###################################################################################################
-
-
- cout << endl
- << "-I- CbmL1CATrdTrackFinderSA::DoFind " << endl
- << "--------------------------------------------------" << endl
- << " ### (FL) in Event No. " << fNofEvents << " ###" << endl
- << "--------------------------------------------------" << endl;
-
- if (fVerbose > 2) {
- cout << "size of segment vector 14 = " << clTracklets[0].size() << endl
- << "size of segment vector 58 = " << clTracklets[1].size() << endl
- << "size of segment vector 912 = " << clTracklets[2].size() << endl;
- }
-
- if (fVerbose > 1)
- cout << "-I- CbmL1CATrdTrackFinderSA::DoFind " << endl
- << "Tracklet finding phase completed." << endl
- << "Now constructing tracks from tracklets..." << endl;
-
-
- tagTracks.Start();
-
- if (noHitsPerTracklet == 4) { //noHitsPerTracklet == 4
- //BEGIN: Tagging procedure ------------------------------------------------------
- cout << endl
- << "-I- CbmL1CATrdTrackFinderSA::DoFind " << endl
- << "--------------------------------------------------" << endl
- << " ### Starting tagging procedure" << endl
- << "--------------------------------------------------" << endl;
-
- TagSegments(clTracklets[1], clTracklets[2], 1);
- cout << "--- Tagging 58-921 done." << endl;
-
- TagSegments(clTracklets[0], clTracklets[1], 0);
- cout << "--- Tagging 14-58 done." << endl;
- } //end of noHitsPerTracklet == 4
-
- tagTracks.Stop();
- //-------------------------------------------------------------------------
-
-
- //--------------------------------------------------------------------------------------
- // Counting number of segments which have a value of 4, 3, 2, ... etc.
- CbmL1TrdTracklet4* clSegRight; //segment nearer to the target
-
- map<Int_t, Int_t> segValues14;
- map<Int_t, Int_t> segValues58;
- map<Int_t, Int_t> segValues912;
- Int_t segValue;
-
- vector<CbmL1TrdTracklet4*>::iterator itclTrackletsRight;
- //for tracklets in the 1st station
- for (itclTrackletsRight = clTracklets[0].begin(); itclTrackletsRight != clTracklets[0].end(); itclTrackletsRight++) {
-
- clSegRight = *itclTrackletsRight;
- segValue = clSegRight->GetVal();
- segValues14[segValue]++;
- if (segValue == 3) clTrackletsNew[0].push_back(clSegRight);
- }
-
- //for tracklets in the 2nd station
- for (itclTrackletsRight = clTracklets[1].begin(); itclTrackletsRight != clTracklets[1].end(); itclTrackletsRight++) {
-
- clSegRight = *itclTrackletsRight;
- segValue = clSegRight->GetVal();
- segValues58[segValue]++;
- if (segValue == 2) clTrackletsNew[1].push_back(clSegRight);
- }
-
- //for tracklets in the 3rd station
- for (itclTrackletsRight = clTracklets[2].begin(); itclTrackletsRight != clTracklets[2].end(); itclTrackletsRight++) {
-
- clSegRight = *itclTrackletsRight;
- segValue = clSegRight->GetVal();
- segValues912[segValue]++;
- if (segValue == 1) clTrackletsNew[2].push_back(clSegRight);
- }
-
- //--- For test only ----------------------------------------------------
- if (fVerbose > 0) {
- map<Int_t, Int_t>::iterator mIt;
-
- cout << "--- Map no. 14 has: " << endl;
- for (mIt = segValues14.begin(); mIt != segValues14.end(); mIt++) {
- cout << mIt->first << " segment has a count of " << mIt->second << endl;
- }
-
- cout << "--- Map no. 58 has: " << endl;
- for (mIt = segValues58.begin(); mIt != segValues58.end(); mIt++) {
- cout << mIt->first << " segment has a count of " << mIt->second << endl;
- }
-
- cout << "--- Map no. 912 has: " << endl;
- for (mIt = segValues912.begin(); mIt != segValues912.end(); mIt++) {
- cout << mIt->first << " segment has a count of " << mIt->second << endl;
- }
-
- cout << endl;
- }
- //-------------------------------------------------------------------------
-
- //vector<CbmTrdTrack*> vTrdTrackCand;
- //vector<CbmTrdTrack*> vTempTrdTrackCand;
- //vector<CbmTrdTrack*>::iterator ivTempTrdTrackCand;
- //vector<CbmTrdTrack*> trackCand1;
-
- cout << "--------------------------------------------------" << endl
- << " ### Starting creating the tracks " << endl
- << "--------------------------------------------------" << endl;
-
- createTracks.Start();
-
- set<Int_t> globalSetUsedHits;
- globalSetUsedHits.clear();
-
- if (segment == 0) { //segment == 0 -> we create long tracks
-
- if (fVerbose > 2) {
- cout << "Outer area: " << endl
- << "--- size of fArrayTrdTrack = " << fArrayTrdTrack->GetEntriesFast() << endl
- << "--- size of globalSetUsedHits = " << globalSetUsedHits.size() << endl;
- }
-
- //create long tracks from 3 sorts of tracklets - station 1,2,3
- CreateTracks(clTracklets[0], clTracklets[1], clTracklets[2], globalSetUsedHits, removeUsedHits, competition, 1);
-
- createTracks.Stop();
-
- //clearing and removing objects that are not needed anymore
- for (Int_t i = 0; i < 3; i++) {
- DeleteTracklets(clTracklets[i]);
- clTracklets[i].clear();
- }
- //----------------------------------------------------
-
- for (Int_t i = 0; i < 6; i++) {
- DeleteTracklets(clSpacePoints[i]);
- clSpacePoints[i].clear();
- }
-
- //--- [Second Loop] ------------------------------------------------------
- secondLoopTime.Start();
-
- cout << endl
- << "-I- CbmL1CATrdTrackFinderSA::DoFind (Second loop)" << endl
- << "--------------------------------------------------" << endl
- << " ### (SL) in Event No. " << fNofEvents << " ###" << endl
- << "--------------------------------------------------" << endl;
-
- if (secondLoop) {
-
- for (Int_t i = 0; i < 12; i++) {
- fvTrdHitArr[i].clear();
- }
-
- set<Int_t>::iterator iglobalSetUsedHits;
- set<Int_t>::iterator iglobalSetRejectedHits;
-
- for (Int_t iHit = 0; iHit < nTrdHit; iHit++) {
- pHit = L1_DYNAMIC_CAST<CbmTrdHit*>(hitArray->At(iHit));
-
- // if(!Rejection(accept)) continue;
-
- if (!pHit) {
- cout << "-E- CbmL1CATrdTrackFinderSA::DoFind: Empty slot "
- << "in HitArray at position " << iHit << endl;
- nNoTrdHit++;
- continue;
- }
-
- //---- Simulate detector inefficiency -----------------------------------
- iglobalSetRejectedHits = globalSetRejectedHits.find(iHit);
- if (iglobalSetRejectedHits != globalSetRejectedHits.end()) continue;
- //----------------------------------------------------------------------
-
- iglobalSetUsedHits = globalSetUsedHits.find(iHit);
- if (iglobalSetUsedHits != globalSetUsedHits.end()) continue;
-
- trdPlaneID = pHit->GetPlaneId();
- Int_t trdPlaneIDN = trdPlaneID - 1;
-
- planeHits.mcTrackID = pMCpt->GetTrackID();
- planeHits.hitIndex = iHit;
- planeHits.X = pHit->GetX();
- planeHits.Y = pHit->GetY();
- planeHits.Z = pHit->GetZ();
- planeHits.DX = pHit->GetDx();
- planeHits.DY = pHit->GetDy();
- fvTrdHitArr[trdPlaneIDN].push_back(planeHits);
- }
-
- for (Int_t i = 0; i < 12; i++) {
- sort(fvTrdHitArr[i].begin(), fvTrdHitArr[i].end(), CompareY);
- }
-
- //for(Int_t i = 0; i < 12; i++){
- // cout <<" Size of vector "<< i <<": "<< fvTrdHitArr[i].size() << endl;
- //}
- //--------------------------------------------------------------------------------------
-
- createSPs_SL.Start();
-
- //performing second step - make all previous tasks but with less restrictive conditions
- cout << "[Second Loop]::Creating space points" << endl;
-
- for (Int_t i = 0, j = 0; i < 6; i++, j = j + 2) {
- CreateSpacePoints(fvTrdHitArr[j], fvTrdHitArr[j + 1], clSpacePoints[i], sigmaA_SL, sigmaB_SL);
- }
- createSPs_SL.Stop();
-
- for (Int_t i = 0; i < 6; i++) {
- sort(clSpacePoints[i].begin(), clSpacePoints[i].end(), CbmL1TrdTracklet::Compare1);
- }
-
- cout << "[Second Loop]::Creating tracklets" << endl;
- for (Int_t i = 0, j = 0; i < 3; i++, j = j + 2) {
- CreateSegments(clSpacePoints[j], clSpacePoints[j + 1], clTracklets[i], dX_SL, dY_SL);
- }
-
- if (fVerbose > 2) {
- cout << "--- size of segment vector 14 = " << clTracklets[0].size() << endl
- << "--- size of segment vector 58 = " << clTracklets[1].size() << endl
- << "--- size of segment vector 912 = " << clTracklets[2].size() << endl;
- }
-
- cout << "[Second Loop]::Finding friends 14-58" << endl;
- FindNeighbour(clTracklets[0], clTracklets[1], distPropLongX_SL, distPropLongY_SL);
-
- cout << "[Second Loop]::Finding friends 58-912" << endl;
- FindNeighbour(clTracklets[1], clTracklets[2], distPropLongX_SL, distPropLongY_SL);
-
- cout << "[Second Loop]::Tagging segments 58-912" << endl;
- TagSegments(clTracklets[1], clTracklets[2], 1);
-
- //--------------------------------------------------------------------------------------------
- cout << "[Second Loop]::Tagging segments 14-58" << endl;
- TagSegments(clTracklets[0], clTracklets[1], 0);
-
- //--------------------------------------------------------------------------------------------
- cout << "[Second Loop]::Creating tracks" << endl;
- CreateTracks(clTracklets[0], clTracklets[1], clTracklets[2], globalSetUsedHits, removeUsedHits, competition, 2);
- //competition -> selects the best track candidate from each branch
- }
-
- for (Int_t i = 0; i < 3; i++) {
- DeleteTracklets(clTracklets[i]);
- clTracklets[i].clear();
- }
- for (Int_t i = 0; i < 6; i++) {
- DeleteTracklets(clSpacePoints[i]);
- clSpacePoints[i].clear();
- }
-
- secondLoopTime.Stop();
-
- thirdLoopTime.Start();
-
- cout << endl
- << "-I- CbmL1CATrdTrackFinderSA::DoFind (Third loop)" << endl
- << "--------------------------------------------------" << endl
- << " ### (TL) in Event No. " << fNofEvents << " ###" << endl
- << "--------------------------------------------------" << endl;
-
- if (thirdLoop) {
-
- for (Int_t i = 0; i < 12; i++) {
- fvTrdHitArr[i].clear();
- }
-
- set<Int_t>::iterator iglobalSetUsedHits;
- set<Int_t>::iterator iglobalSetRejectedHits;
-
- for (Int_t iHit = 0; iHit < nTrdHit; iHit++) {
- pHit = L1_DYNAMIC_CAST<CbmTrdHit*>(hitArray->At(iHit));
-
- // if(!Rejection(accept)) continue;
-
- if (!pHit) {
- cout << "-E- CbmL1CATrdTrackFinderSA::DoFind: Empty slot "
- << "in HitArray at position " << iHit << endl;
- nNoTrdHit++;
- continue;
- }
-
- //---- Simulate detector inefficiency -----------------------------------
- iglobalSetRejectedHits = globalSetRejectedHits.find(iHit);
- if (iglobalSetRejectedHits != globalSetRejectedHits.end()) continue;
- //----------------------------------------------------------------------
-
- iglobalSetUsedHits = globalSetUsedHits.find(iHit);
- if (iglobalSetUsedHits != globalSetUsedHits.end()) continue;
-
- trdPlaneID = pHit->GetPlaneId();
- Int_t trdPlaneIDN = trdPlaneID - 1;
-
- planeHits.mcTrackID = pMCpt->GetTrackID();
- planeHits.hitIndex = iHit;
- planeHits.X = pHit->GetX();
- planeHits.Y = pHit->GetY();
- planeHits.Z = pHit->GetZ();
- planeHits.DX = pHit->GetDx();
- planeHits.DY = pHit->GetDy();
- fvTrdHitArr[trdPlaneIDN].push_back(planeHits);
- }
-
- for (Int_t i = 0; i < 12; i++) {
- sort(fvTrdHitArr[i].begin(), fvTrdHitArr[i].end(), CompareY);
- }
-
- for (Int_t i = 0, j = 0; i < 6; i++, j = j + 2) {
- CreateSpacePoints(fvTrdHitArr[j], fvTrdHitArr[j + 1], clSpacePoints[i], sigmaA_TL, sigmaB_TL);
- }
-
- for (Int_t i = 0; i < 6; i++) {
- sort(clSpacePoints[i].begin(), clSpacePoints[i].end(), CbmL1TrdTracklet::Compare1);
- }
-
- for (Int_t i = 0, j = 0; i < 3; i++, j = j + 2) {
- CreateSegments(clSpacePoints[j], clSpacePoints[j + 1], clTracklets[i], dX_TL, dY_TL);
- }
-
- FindNeighbour(clTracklets[0], clTracklets[1], distPropLongX_TL, distPropLongY_TL);
- FindNeighbour(clTracklets[1], clTracklets[2], distPropLongX_TL, distPropLongY_TL);
- TagSegments(clTracklets[1], clTracklets[2], 1);
-
- TagSegments(clTracklets[0], clTracklets[1], 0);
-
- CreateTracks(clTracklets[0], clTracklets[1], clTracklets[2], globalSetUsedHits, removeUsedHits, competition, 3);
- }
-
- thirdLoopTime.Stop();
-
- } //end segment == 0
-
-
- if (segment == 1) { //segment == 1 -> we create only 4-hit, 1-segment tracks!
- CreateAndManageSegments(clTracklets[0], clTracklets[1], clTracklets[2]);
- }
-
-
- //------ Used and Unused hists in the TRD's planes ------------------------
- //------ Histogramming
- set<Int_t>::iterator iglSetUsedHits;
- nTrdHit = hitArray->GetEntriesFast();
-
- for (Int_t iHit = 0; iHit < nTrdHit; iHit++) {
- pHit = L1_DYNAMIC_CAST<CbmTrdHit*>(hitArray->At(iHit));
-
- trdPlaneID = pHit->GetPlaneId();
- fTotHits[trdPlaneID]++;
-
- iglSetUsedHits = globalSetUsedHits.find(iHit);
- if (iglSetUsedHits != globalSetUsedHits.end()) {
- fRUsedHits[trdPlaneID]++;
- //fUsedHitsPerPlane->Fill(trdPlaneID-1);
- }
- else {
- fRUnUsedHits[trdPlaneID]++;
- //fUnUsedHitsPerPlane->Fill(trdPlaneID-1);
- }
- }
- //---------------------------------------------------------------------------
-
-
- cout << endl
- << "-I- CbmL1CATrdTrackFinderSA::DoFind " << endl
- << "--------------------------------------------------" << endl
- << " ### Summary" << endl
- << "--------------------------------------------------" << endl
- << "--- Number of found tracks: " << fArrayTrdTrack->GetEntriesFast() << endl
- << endl;
-
- delTime.Start();
-
- cout << "\n-I- CbmL1CATrdTrackFinderSA::DoFind " << endl
- << "--------------------------------------------------" << endl
- << " ### Delete:Clear" << endl
- << "--------------------------------------------------" << endl;
-
- for (Int_t i = 0; i < 12; i++) {
- fvTrdHitArr[i].clear();
- }
-
- //----------------------------------------------------
- for (Int_t i = 0; i < 3; i++) {
- DeleteTracklets(clTracklets[i]);
- clTracklets[i].clear();
- }
-
- //----------------------------------------------------
- for (Int_t i = 0; i < 6; i++) {
- DeleteTracklets(clSpacePoints[i]);
- clSpacePoints[i].clear();
- }
- //----------------------------------------------------
-
- //segValues14.clear();
- //segValues58.clear();
- //segValues912.clear();
-
- delTime.Stop();
- doFind.Stop();
-
-
- //-------------------------------------------------------
-#ifdef DRAW
-
- fNTrdHits = hitArray->GetEntriesFast();
-
- for (Int_t iHit = 0; iHit < fNTrdHits; iHit++) {
- pHit = L1_DYNAMIC_CAST<CbmTrdHit*>( hitArray->At(iHit);
-
- ptIndex = pHit->GetRefIndex();
- pMCpt = (CbmTrdPoint*) (fMCPointArray->At(ptIndex));
-// pMCtr = (CbmMCTrack*) fMCTrackArray->At(pMCpt->GetTrackID());
-
- trdPlaneID = pHit->GetPlaneID();
- Int_t trdPlaneIDN = trdPlaneID-1;
-
- planeHits.mcTrackID = pMCpt->GetTrackID();
- planeHits.hitIndex = iHit;
- planeHits.X = pHit->GetX();
- planeHits.Y = pHit->GetY();
- planeHits.Z = pHit->GetZ();
- planeHits.DX = pHit->GetDx();
- planeHits.DY = pHit->GetDy();
- planeHits.planeID = trdPlaneID;
- fvTrdHitArr[trdPlaneIDN].push_back(planeHits);
- }
-
- Draw2();
- DrawAsk();
-
- for (Int_t i = 0; i < 12; i++) {
- fvTrdHitArr[i].clear();
- }
-
-#endif
-
-
- //-------------------------------------------------------
-
-
- //-----------------------------------------------------------------
- Double_t rtime;
- Double_t ctime;
- Double_t qtime = Double_t(fNofEvents);
-
- cout << endl
- << "\n-I- CbmL1CATrdTrackFinderSA::DoFind " << endl
- << "--------------------------------------------------" << endl
- << " ### Time" << endl
- << "--------------------------------------------------" << endl;
- cout << " Do find: ";
-
- rtime = doFind.RealTime();
- ctime = doFind.CpuTime();
- totDoFind += ctime;
- printf("RealTime=%4.2f s, CpuTime=%4.2f s, TotCpu=%4.2f s, %4.2f/event\n", rtime, ctime, totDoFind,
- totDoFind / qtime);
-
- cout << " Sort Hits: ";
- rtime = sortHits.RealTime();
- ctime = sortHits.CpuTime();
- totSortHits += ctime;
- printf("RealTime=%4.2f s, CpuTime=%4.2f s, TotCpu=%4.2f s, %4.2f/event\n", rtime, ctime, totSortHits,
- totSortHits / qtime);
-
- cout << " Create SPs: ";
- rtime = createSPs.RealTime();
- ctime = createSPs.CpuTime();
- totCreateSPs += ctime;
- printf("RealTime=%4.2f s, CpuTime=%4.2f s, TotCpu=%4.2f s, %4.2f/event\n", rtime, ctime, totCreateSPs,
- totCreateSPs / qtime);
-
- cout << " Sort SPs: ";
- rtime = sortSPs.RealTime();
- ctime = sortSPs.CpuTime();
- totSortSPs += ctime;
- printf("RealTime=%4.2f s, CpuTime=%4.2f s, TotCpu=%4.2f s, %4.2f/event\n", rtime, ctime, totSortSPs,
- totSortSPs / qtime);
-
- cout << " Create segments: ";
- rtime = createSegments.RealTime();
- ctime = createSegments.CpuTime();
- totCreateSegments += ctime;
- printf("RealTime=%4.2f s, CpuTime=%4.2f s, TotCpu=%4.2f s, %4.2f/event\n", rtime, ctime, totCreateSegments,
- totCreateSegments / qtime);
-
- cout << " Find friend: ";
- rtime = findNeighbour.RealTime();
- ctime = findNeighbour.CpuTime();
- totFindNeighbour += ctime;
- printf("RealTime=%4.2f s, CpuTime=%4.2f s, TotCpu=%4.2f s, %4.2f/event\n", rtime, ctime, totFindNeighbour,
- totFindNeighbour / qtime);
-
- cout << " Tag Tracklets: ";
- rtime = tagTracks.RealTime();
- ctime = tagTracks.CpuTime();
- totTagTracks += ctime;
- printf("RealTime=%4.2f s, CpuTime=%4.2f s, TotCpu=%4.2f s, %4.2f/event\n", rtime, ctime, totTagTracks,
- totTagTracks / qtime);
-
- cout << " Create Tracks: ";
- rtime = createTracks.RealTime();
- ctime = createTracks.CpuTime();
- totCreateTracks += ctime;
- printf("RealTime=%4.2f s, CpuTime=%4.2f s, TotCpu=%4.2f s, %4.2f/event\n", rtime, ctime, totCreateTracks,
- totCreateTracks / qtime);
-
- cout << "Refitting Tracks: ";
- rtime = refittingKF.RealTime();
- ctime = refittingKF.CpuTime();
- totRefittingKF += ctime;
- printf("RealTime=%4.2f s, CpuTime=%4.2f s, TotCpu=%4.2f s, %4.2f/event\n", rtime, ctime, totRefittingKF,
- totRefittingKF / qtime);
-
- cout << " Second Loop: ";
- rtime = secondLoopTime.RealTime();
- ctime = secondLoopTime.CpuTime();
- totSecondLoopTime += ctime;
- printf("RealTime=%4.2f s, CpuTime=%4.2f s, TotCpu=%4.2f s, %4.2f/event\n", rtime, ctime, totSecondLoopTime,
- totSecondLoopTime / qtime);
-
- cout << " Third Loop: ";
- rtime = thirdLoopTime.RealTime();
- ctime = thirdLoopTime.CpuTime();
- totThirdLoopTime += ctime;
- printf("RealTime=%4.2f s, CpuTime=%4.2f s, TotCpu=%4.2f s, %4.2f/event\n", rtime, ctime, totThirdLoopTime,
- totThirdLoopTime / qtime);
-
- cout << "Deleting Objects: ";
- rtime = delTime.RealTime();
- ctime = delTime.CpuTime();
- totDelTime += ctime;
- printf("RealTime=%4.2f s, CpuTime=%4.2f s, TotCpu=%4.2f s, %4.2f/event\n", rtime, ctime, totDelTime,
- totDelTime / qtime);
-
- cout << "[Second Loop]" << endl;
- cout << " Create SPs: ";
- rtime = createSPs_SL.RealTime();
- ctime = createSPs_SL.CpuTime();
- totCreateSPs_SL += ctime;
- printf("RealTime=%4.2f s, CpuTime=%4.2f s, TotCpu=%4.2f s, %4.2f/event\n", rtime, ctime, totCreateSPs_SL,
- totCreateSPs_SL / qtime);
-
-
- cout << endl
- << "-I- CbmL1CATrdTrackFinderSA::DoFind " << endl
- << "--------------------------------------------------" << endl
- << " ### END: Track constructing phase completed" << endl
- << "--------------------------------------------------" << endl;
-
- fNoEvTime->Fill(fArrayTrdTrack->GetEntriesFast(), doFind.RealTime());
-
- return 1;
-}
-// -----------------------------------------------------------------------
-
-void CbmL1CATrdTrackFinderSA::DeleteTracklets(vector<CbmL1TrdTracklet4*> vect)
-{
-
- vector<CbmL1TrdTracklet4*>::iterator it;
- for (it = vect.begin(); it != vect.end(); it++) {
- delete (*it);
- }
-}
-
-// -----------------------------------------------------------------------
-
-void CbmL1CATrdTrackFinderSA::DeleteTracklets(vector<CbmL1TrdTracklet*> vect)
-{
- vector<CbmL1TrdTracklet*>::iterator it;
- for (it = vect.begin(); it != vect.end(); it++) {
- delete (*it);
- }
-}
-
-
-// ---------------------- Create histogramms -----------------------------
-void CbmL1CATrdTrackFinderSA::CreateHistogramms()
-{
-
- fUsedHitsPerPlane = new TH1F("h_UsedHitsPerPlane", "h_UsedHitsPerPlane", 13, 0, 13);
- fUnUsedHitsPerPlane = new TH1F("h_UnUsedHitsPerPlane", "h_UnUsedHitsPerPlane", 13, 0, 13);
-
-
- // Normalized distance to hit
- fh_chi2hit = new TH1F("h_chi2hit", "Normalized distance to hit", 500, 0., 50.);
- fh_chi2hit_plane =
- new TH2F("h_chi2hit_plane", "Normalized distance to hit vs. plane number", 500, 0., 50., 12, 0., 12.);
-
- fDistLongX = new TH1F("DistLongX", "DistLongX", 100, -200, 200);
- fDistLongY = new TH1F("DistLongY", "DistLongY", 100, -200, 200);
- fDistShortX = new TH1F("DistShortX", "DistShortX", 100, -10, 10);
- fDistShortY = new TH1F("DistShortY", "DistShortY", 100, -10, 10);
-
- fDistLongBX = new TH1F("DistLongBX", "DistLongBX", 100, -200, 200);
- fDistLongBY = new TH1F("DistLongBY", "DistLongBY", 100, -200, 200);
- fDistShortBX = new TH1F("DistShortBX", "DistShortBX", 100, -200, 200);
- fDistShortBY = new TH1F("DistShortBY", "DistShortBY", 100, -200, 200);
-
- fDistY12 = new TH1F("DistY12", "DistY12", 100, -1, 1);
-
- fMomDistLongPrimaryX = new TH2F("MomDistLongPrimaryX", "MomDistLongPrimaryX", 100, 0, 10, 100, -30, 30);
- fMomDistLongPrimaryY = new TH2F("MomDistLongPrimaryY", "MomDistLongPrimaryY", 100, 0, 10, 100, -30, 30);
- fMomDistExtrapolPrimaryX = new TH2F("MomDistExtrapolPrimaryX", "MomDistExtrapolPrimaryX", 100, 0, 10, 200, -20, 20);
- fMomDistExtrapolPrimaryY = new TH2F("MomDistExtrapolPrimaryY", "MomDistExtrapolPrimaryY", 100, 0, 10, 200, -20, 20);
-
- fMomDistLongExtraX = new TH2F("MomDistLongExtraX", "MomDistLongExtraX", 100, 0, 10, 100, -30, 30);
- fMomDistLongExtraY = new TH2F("MomDistLongExtraY", "MomDistLongExtraY", 100, 0, 10, 100, -30, 30);
- fMomDistExtrapolExtraX = new TH2F("MomDistExtrapolExtraX", "MomDistExtrapolExtraX", 100, 0, 10, 200, -20, 20);
- fMomDistExtrapolExtraY = new TH2F("MomDistExtrapolExtraY", "MomDistExtrapolExtraY", 100, 0, 10, 200, -20, 20);
-
- fMomDistShortPrimaryX = new TH2F("MomDistShortPrimaryX", "MomDistShortPrimaryX", 100, 0, 10, 100, -5, 5);
- fMomDistShortPrimaryY = new TH2F("MomDistShortPrimaryY", "MomDistShortPrimaryY", 100, 0, 10, 100, -5, 5);
- fMomDistShortExtraX = new TH2F("MomDistShortExtraX", "MomDistShortExtraX", 100, 0, 10, 100, -5, 5);
- fMomDistShortExtraY = new TH2F("MomDistShortExtraY", "MomDistShortExtraY", 100, 0, 10, 100, -5, 5);
-
- fDistY = new TH1F("DistY", "DistY", 1000, -10, 10);
- fDistX = new TH1F("DistX", "DistX", 1000, -10, 10);
-
- fPlane1Ydens = new TH1F("Plane1Ydens", "Plane1Ydens", 1000, -1000, 1000);
- fPlane5Ydens = new TH1F("Plane5Ydens", "Plane5Ydens", 1000, -1000, 1000);
- fPlane9Ydens = new TH1F("Plane9Ydens", "Plane9Ydens", 1000, -1000, 1000);
-
- fSPlengthMC = new TH1F("SPlengthMC", "SPlengthMC", 200, 0, 20);
- fSPlength = new TH1F("SPlength", "SPlength", 200, 0, 20);
-
- fYat0 = new TH1F("Yat0", "Yat0", 500, -500, 500);
- fYat0MC = new TH1F("Yat0MC", "Yat0MC", 500, -500, 500);
-
- fNoEvTime = new TH2F("NoEvTime", "NoEvTime", 1000, 0, 1000, 1000, 0, 5);
-
- fh_SP_xDiff_MC = new TH1F("fh_SP_xDiff_MC", "fh_SP_xDiff_MC", 400, -20, 20);
- fh_SP_yDiff_MC = new TH1F("fh_SP_yDiff_MC", "fh_SP_yDiff_MC", 400, -20, 20);
-
- fh_SP_xDiff_nMC = new TH1F("fh_SP_xDiff_nMC", "fh_SP_xDiff_nMC", 400, -20, 20);
- fh_SP_yDiff_nMC = new TH1F("fh_SP_yDiff_nMC", "fh_SP_yDiff_nMC", 400, -20, 20);
-}
-// -----------------------------------------------------------------------
-
-
-// -------------------- Activates data branches --------------------------
-void CbmL1CATrdTrackFinderSA::DataBranches()
-{
-
- // Get pointer to the ROOT manager
- FairRootManager* rootMgr = FairRootManager::Instance();
- if (NULL == rootMgr) {
- cout << "-E- CbmL1CATrdTrackFinderSA::DataBranches : "
- << "ROOT manager is not instantiated" << endl;
- return;
- }
-
- fArrayTrdHit = L1_DYNAMIC_CAST<TClonesArray*>(rootMgr->GetObject("TrdHit"));
- if (!fArrayTrdHit) {
- cout << "-E- CbmL1CATrdTrackFinderSA::Init: No TrdHit array!" << endl;
- return;
- }
-}
-// -----------------------------------------------------------------------
-
-
-// ------------------- Determines the TRD layout -------------------------
-void CbmL1CATrdTrackFinderSA::TrdLayout()
-{
-
- // Get the pointer to the singleton FairRunAna object
- FairRunAna* ana = FairRunAna::Instance();
- if (NULL == ana) {
- cout << "-E- CbmL1CATrdTrackFinderSA::TrdLayout :"
- << " no FairRunAna object!" << endl;
- return;
- }
- // Get the pointer to run-time data base
- FairRuntimeDb* rtdb = ana->GetRuntimeDb();
- if (NULL == rtdb) {
- cout << "-E- CbmL1CATrdTrackFinderSA::TrdLayout :"
- << " no runtime database!" << endl;
- return;
- }
- // Get the pointer to container of base parameters
- FairBaseParSet* baseParSet = L1_DYNAMIC_CAST<FairBaseParSet*>(rtdb->getContainer("FairBaseParSet"));
- if (NULL == baseParSet) {
- cout << "-E- CbmL1CATrdTrackFinderSA::TrdLayout :"
- << " no container of base parameters!" << endl;
- return;
- }
-
- TrdPar = L1_DYNAMIC_CAST<CbmGeoTrdPar*>(rtdb->findContainer("CbmGeoTrdPar"));
- TObjArray* Nodes = TrdPar->GetGeoSensitiveNodes();
- for (Int_t i = 0; i < Nodes->GetEntriesFast(); i++) {
- FairGeoNode* node = dynamic_cast<FairGeoNode*>(Nodes->At(i));
- //FairGeoNode *node = (FairGeoNode*) Nodes->At(i);
- if (!node) continue;
-
- TString name = node->getName();
- //TString Sname = node->getShapePointer()->GetName();
- FairGeoVector nodeV = node->getLabTransform()->getTranslation(); //in cm
-
- // FairGeoBasicShape *gShapePointer = (FairGeoBasicShape *)node->getShapePointer();
- //gShapePointer->printParam();
-
- // node->print();
-
- //Int_t id = node->getMCid();
- //cout <<"name: "<< name <<"\tid: "<< id << endl;
- cout << " name: " << name << "\t(z): " << nodeV.Z() << endl;
-
- // if(name.Contains("trd13")) fTrd13_Z = nodeV.Z();
- // if(name.Contains("trd14")) fTrd14_Z = nodeV.Z();
- // if(name.Contains("trd21")) fTrd21_Z = nodeV.Z();
- // if(name.Contains("trd24")) fTrd24_Z = nodeV.Z();
- // if(name.Contains("trd31")) fTrd31_Z = nodeV.Z();
-
- if (name == "trd1gas#3") fTrd13_Z = Int_t(nodeV.Z());
- if (name == "trd1gas#4") fTrd14_Z = Int_t(nodeV.Z());
- if (name == "trd2gas#1") fTrd21_Z = Int_t(nodeV.Z());
- if (name == "trd2gas#4") fTrd24_Z = Int_t(nodeV.Z());
- if (name == "trd3gas#1") fTrd31_Z = Int_t(nodeV.Z());
-
- // if(name == "trd13") fTrd13_Z = nodeV.Z();
- // if(name == "trd14") fTrd14_Z = nodeV.Z();
- // if(name == "trd21") fTrd21_Z = nodeV.Z();
- // if(name == "trd24") fTrd24_Z = nodeV.Z();
- // if(name == "trd31") fTrd31_Z = nodeV.Z();
-
- if (name == "trd1gas#1") geoLayer.Z[0] = nodeV.Z();
- if (name == "trd1gas#2") geoLayer.Z[1] = nodeV.Z();
- if (name == "trd1gas#3") geoLayer.Z[2] = nodeV.Z();
- if (name == "trd1gas#4") geoLayer.Z[3] = nodeV.Z();
- if (name == "trd2gas#1") geoLayer.Z[4] = nodeV.Z();
- if (name == "trd2gas#2") geoLayer.Z[5] = nodeV.Z();
- if (name == "trd2gas#3") geoLayer.Z[6] = nodeV.Z();
- if (name == "trd2gas#4") geoLayer.Z[7] = nodeV.Z();
- if (name == "trd3gas#1") geoLayer.Z[8] = nodeV.Z();
- if (name == "trd3gas#2") geoLayer.Z[9] = nodeV.Z();
- if (name == "trd3gas#3") geoLayer.Z[10] = nodeV.Z();
- if (name == "trd3gas#4") geoLayer.Z[11] = nodeV.Z();
- }
-
-#ifdef DRAW
- for (int i = 0; i < 4; i++) {
- geoLayer.Y[i] = 273.1;
- }
- for (int i = 4; i < 8; i++) {
- geoLayer.Y[i] = 396.0;
- }
- for (int i = 8; i < 12; i++) {
- geoLayer.Y[i] = 518.9;
- }
-
- Int_t scaleZ = 300;
- Int_t scaleZA = 0;
- for (int i = 0; i < 12; i++) {
- if (i == 4) scaleZA = 1000;
- if (i == 8) scaleZA *= 2;
-
- geoLayer.scale[i] += ((i + 1) * scaleZ) + scaleZA;
- geoLayer.Z[i] += geoLayer.scale[i];
- }
-#endif
-
- /*
- TrdPar = (CbmGeoTrdPar*) (rtdb->findContainer("CbmGeoTrdPar"));
- //TObjArray *Nodes = TrdPar->GetGeoSensitiveNodes();
- Nodes = TrdPar->GetGeoSensitiveNodes();
- for( Int_t i=0;i<Nodes->GetEntriesFast(); i++) {
- FairGeoNode *node = dynamic_cast<FairGeoNode*> (Nodes->At(i));
- if ( !node ) continue;
-
- TString name = node->getName();
- FairGeoVector nodeV = node->getLabTransform()->getTranslation(); //in cm
-
- Int_t uid = i+1;
- cout <<"name, uid, Z: "<< name <<", "<< uid <<", "<< nodeV.Z() << endl;
-
- if(uid == 3) fTrd13_Z = nodeV.Z();
- if(uid == 4) fTrd14_Z = nodeV.Z();
- if(uid == 5) fTrd21_Z = nodeV.Z();
- if(uid == 8) fTrd24_Z = nodeV.Z();
- if(uid == 9) fTrd31_Z = nodeV.Z();
- }
- */
-
- // Get the pointer to detector list
- TObjArray* detList = baseParSet->GetDetList();
- if (NULL == detList) {
- cout << "-E- CbmL1CATrdTrackFinderSA::TrdLayout :"
- << " no detector list!" << endl;
- return;
- }
- // Find TRD detector
- FairDetector* trd = L1_DYNAMIC_CAST<FairDetector*>(detList->FindObject("TRD"));
- if (NULL == trd) {
- cout << "-E- CbmL1CATrdTrackFinderSA::TrdLayout :"
- << " no TRD detector!" << endl;
- return;
- }
- // Determine the geometry version
- TString name = trd->GetGeometryFileName();
- if (name.Contains("9")) {
- cout << "-I- CbmL1CATrdTrackFinderSA::TrdLayout :"
- << " TRD geometry : 3x3." << endl;
- fNoTrdStations = 3;
- fNoTrdPerStation = 3;
- }
- else if (name.Contains("12")) {
- cout << "-I- CbmL1CATrdTrackFinderSA::TrdLayout :"
- << " TRD geometry : 3x4." << endl;
- fNoTrdStations = 3;
- fNoTrdPerStation = 4;
- }
- else if (name.Contains("6x2")) {
- cout << "-I- CbmL1CATrdTrackFinderSA::TrdLayout :"
- << " TRD geometry : 6x2." << endl;
- fNoTrdStations = 6;
- fNoTrdPerStation = 2;
- }
- fNoTrdStations = 3;
- fNoTrdPerStation = 4;
-}
-// -----------------------------------------------------------------------
-
-
-// ------------------------- Write histogramms ---------------------------
-void CbmL1CATrdTrackFinderSA::WriteHistogramms()
-{
-
- fh_chi2hit->Write();
- fh_chi2hit_plane->Write();
-
- fDistLongBX->Write();
- fDistLongBY->Write();
- fDistShortBX->Write();
- fDistShortBY->Write();
-
- fDistY12->Write();
-
- //----------------------------------------------------------
- fMomDistLongPrimaryX->Write();
- fMomDistLongPrimaryY->Write();
- fMomDistLongExtraX->Write();
- fMomDistLongExtraY->Write();
-
- fMomDistExtrapolPrimaryX->Write();
- fMomDistExtrapolPrimaryY->Write();
- fMomDistExtrapolExtraX->Write();
- fMomDistExtrapolExtraY->Write();
-
- fMomDistShortPrimaryX->Write();
- fMomDistShortPrimaryY->Write();
- fMomDistShortExtraX->Write();
- fMomDistShortExtraY->Write();
-
- fDistLongX->Write();
- fDistLongY->Write();
- fDistShortX->Write();
- fDistShortY->Write();
-
- fDistY->Write();
- fDistX->Write();
-
- fPlane1Ydens->Write();
- fPlane5Ydens->Write();
- fPlane9Ydens->Write();
-
- fSPlength->Write();
- fSPlengthMC->Write();
-
- fYat0->Write();
- fYat0MC->Write();
-
- fNoEvTime->Write();
-
- fh_SP_xDiff_MC->Write();
- fh_SP_yDiff_MC->Write();
-
- fh_SP_xDiff_nMC->Write();
- fh_SP_yDiff_nMC->Write();
-
-
- //---------------------------------------------------------------------
- map<Int_t, Int_t>::iterator iUsedHits;
- map<Int_t, Int_t>::iterator iUnUsedHits;
- map<Int_t, Int_t>::iterator iTotHits;
- Double_t nContent;
-
- for (iUsedHits = fRUsedHits.begin(); iUsedHits != fRUsedHits.end(); iUsedHits++) {
-
- iTotHits = fTotHits.find(iUsedHits->first);
- nContent = (iUsedHits->second * 100) / iTotHits->second;
- // cout << iUsedHits->first <<", "
- // << iUsedHits->second <<", "
- // << iTotHits->second <<", "
- // << nContent << endl;
- fUsedHitsPerPlane->SetBinContent((iUsedHits->first), nContent);
- }
- for (iUnUsedHits = fRUnUsedHits.begin(); iUnUsedHits != fRUnUsedHits.end(); iUnUsedHits++) {
-
- iTotHits = fTotHits.find(iUnUsedHits->first);
- nContent = (iUnUsedHits->second * 100) / iTotHits->second;
- fUnUsedHitsPerPlane->SetBinContent((iUnUsedHits->first), nContent);
- }
- fUsedHitsPerPlane->Write();
- fUnUsedHitsPerPlane->Write();
- //---------------------------------------------------------------------
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-Double_t CbmL1CATrdTrackFinderSA::FitLinear(CbmTrdTrack* tr, Int_t /*var*/ = 1)
-{
- //fit using a least square method
-
-
- // cout << ">>> Trying to fit a track..." << endl;
- Int_t noHits = tr->GetNofHits();
- // cout << "No Hits in the track : " << noHits << endl;
- Int_t iHit;
- CbmTrdHit* hit;
-
- Double_t C1[12];
- Double_t C2[12];
- Double_t Z[12];
-
- Double_t n = 12;
-
- for (int i = 0; i < 12; i++) {
- C1[i] = 0;
- C2[i] = 0;
- Z[i] = 0;
- }
-
- // Int_t ind = 0;
-
- for (int i = 0; i < noHits; i++) {
-
- iHit = tr->GetHitIndex(i);
- hit = L1_DYNAMIC_CAST<CbmTrdHit*>(fArrayTrdHit->At(iHit));
-
- C1[i] = hit->GetX();
- C2[i] = hit->GetY();
- Z[i] = hit->GetZ();
- }
-
- Double_t sumXZ = 0, sumYZ = 0, sumX = 0, sumY = 0, sumZx = 0, sumZy = 0, sumX2 = 0, sumY2 = 0, sumZx2 = 0, sumZy2 = 0;
-
- for (int i = 0; i < 12; i += 2) {
- // cout << "C1[" << i << "]=" << C1[i] << endl;
- // cout << "C2[" << i << "]=" << C2[i] << endl;
-
- // if(!(i % 2))
- {
- sumXZ += C1[i] * Z[i];
-
- sumX += C1[i];
- sumX2 += C1[i] * C1[i];
-
- sumZx += Z[i];
- sumZx2 += Z[i] * Z[i];
- }
- }
-
- for (int i = 1; i < 12; i += 2) {
- // cout << "C1[" << i << "]=" << C1[i] << endl;
- // cout << "C2[" << i << "]=" << C2[i] << endl;
-
- // if(!((1i % 2))
- {
- sumYZ += C2[i] * Z[i];
-
- sumY += C2[i];
- sumY2 += C2[i] * C2[i];
-
- sumZy += Z[i];
- sumZy2 += Z[i] * Z[i];
- }
- }
-
-
- cout << "";
- // Double_t a = (n*sumXZ - sumX*sumZ)/(n*sumX2 - sumX*sumX);
- // Double_t b = (sumZ - a*sumX)/n;
- Double_t r1 = (n * sumXZ - sumX * sumZx) / sqrt((n * sumX2 - sumX * sumX) * (n * sumZx2 - sumZx * sumZx));
- // Double_t Sa = sqrt((n*(sumY2 -a*sumXZ-b*sumY))/((n-2)*(n*sumX2-sumX*sumX)));
- // Double_t Sb = Sa*sqrt(sumX2/n);
-
-
- Double_t r2 = (n * sumYZ - sumY * sumZy) / sqrt((n * sumY2 - sumY * sumY) * (n * sumZy2 - sumZy * sumZy));
-
-
- // cout << "Linear coefficients: a= "
- // << a << ", Sa= " << Sa << ", b= " << b << ", Sb= " << Sb << endl
- // << ", r=" << r << ", chi2=" << tr->GetChi2() << endl;
-
-
- return sqrt(r1 * r1 + r2 * r2);
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-Double_t CbmL1CATrdTrackFinderSA::DistTwoTrackletsY(Int_t iIndexFirst, Int_t iIndexSecond, Double_t zed)
-{
- //returns an extrapolated coordinate
- CbmTrdHit *pHitFirst, *pHitSecond;
- Double_t dist;
-
- Double_t Y1 = 0;
- Double_t Z1 = 0;
-
- // Get hits from first and second plane in station
- if (iIndexFirst != -1) {
- pHitFirst = L1_DYNAMIC_CAST<CbmTrdHit*>(fArrayTrdHit->At(iIndexFirst));
- Y1 = pHitFirst->GetY();
- Z1 = pHitFirst->GetZ();
- }
-
- pHitSecond = L1_DYNAMIC_CAST<CbmTrdHit*>(fArrayTrdHit->At(iIndexSecond));
-
- // Get position Y & Z of hits
-
- Double_t Y4 = pHitSecond->GetY();
- Double_t Z4 = pHitSecond->GetZ();
-
- Double_t a = (Y4 - Y1) / (Z4 - Z1);
- Double_t b = Y1 - a * Z1;
- Double_t Y = a * zed + b; // - Y1;
- dist = Y;
- // cout << "From the coords (y1,z1) = ("
- // << Y1 << ", " << Z1 << endl
- // << "From the coords (y2,z2) = ("
- // << Y4 << ", " << Z4 << endl
- // << " we get the value = "
- // << dist
- // << endl;
- return dist;
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-
-Double_t CbmL1CATrdTrackFinderSA::DistTwoTrackletsX(Int_t iIndexFirst, Int_t iIndexSecond, Double_t zed)
-{
- CbmTrdHit *pHitFirst, *pHitSecond;
- Double_t dist;
-
- Double_t X1 = 0;
- Double_t Z1 = 0;
-
- // Get hits from first and second plane in station
- if (iIndexFirst != -1) {
- pHitFirst = L1_DYNAMIC_CAST<CbmTrdHit*>(fArrayTrdHit->At(iIndexFirst));
- X1 = pHitFirst->GetX();
- Z1 = pHitFirst->GetZ();
- }
-
- pHitSecond = L1_DYNAMIC_CAST<CbmTrdHit*>(fArrayTrdHit->At(iIndexSecond));
-
-
- Double_t X4 = pHitSecond->GetX();
- Double_t Z4 = pHitSecond->GetZ();
-
- Double_t a = (X4 - X1) / (Z4 - Z1);
- Double_t b = X1 - a * Z1;
- // Double_t X = (dz)/(dx)*(zed - Z1);
- Double_t X = a * zed + b;
- // = dy/dz * (zed + Z1) - X1;
- dist = X;
- // cout << "From the coords (x1,z1) = ("
- // << X1 << ", " << Z1 << endl
- // << "From the coords (x4,z4) = ("
- // << X4 << ", " << Z4 << endl
- // << "and at zed = " << zed << endl
- // << " we get the value = "
- // << dist
- // << endl;
- return dist;
-}
-// -----------------------------------------------------------------------
-
-// -----------------------------------------------------------------------
-void CbmL1CATrdTrackFinderSA::FindNeighbour(vector<CbmL1TrdTracklet4*>& v1, vector<CbmL1TrdTracklet4*>& v2, Double_t dY,
- Double_t dX)
-{
-
- vector<CbmL1TrdTracklet4*>::iterator iv1;
- CbmL1TrdTracklet4* tr1;
-
- Double_t extY = 0,
- extX = 0, //two extrapolated coords from the first tracklet
- mesY = 0, mesX = 0, //two measured coords from the second tracklet
- aminY, amaxY, aminX, amaxX;
- Int_t indexA, indexB;
- Int_t Left = 0, Right, Mid = 0;
-
- Int_t il = 0;
- for (iv1 = v1.begin(); iv1 != v1.end(); iv1++) {
- il++;
- tr1 = *iv1;
- extY = tr1->GetExt(0);
- extX = tr1->GetExt(1);
- indexA = tr1->GetIndex();
- amaxY = extY + dY;
- aminY = extY - dY;
- amaxX = extX + dX;
- aminX = extX - dX;
-
- Left = 0;
- Right = v2.size();
- Mid = 0;
-
- // ----------- looking by bisection ------------------
- while (Left < Right) {
- Mid = (Left + Right) / 2;
- mesY = v2[Mid]->GetCoord(0);
-
- if (amaxY < mesY) {
- Left = Mid + 1;
- }
- else {
- Right = Mid - 1;
- }
-
- /*
- cout << il << ": Size: "<< v1.size()
- <<" mesY: "<< v2[Mid]->GetCoord(0)
- <<" extY: "<< extY
- <<" Mid: "<< Mid
- << endl;
- */
- }
- //----------------------------------------------------
-
- Int_t size = v2.size();
- for (Int_t i = Mid; i < size; i++) {
- mesY = v2[i]->GetCoord(0);
- mesX = v2[i]->GetCoord(1);
- //cout <<"(mesX,MesY) "<< mesX <<"\t"<< mesY << endl;
- indexB = v2[i]->GetIndex();
- //cout <<"indexB "<< indexB << endl;
-
- if (mesY > amaxY) continue;
- if (mesY < aminY) break;
-
- // cout <<"----------- Setting vAccost [Right|Left]"<< endl;
-
- // cout << aminX <<", "<< mesX <<", "<< amaxX << endl;
-
- if (aminX < mesX && mesX < amaxX) {
- tr1->vAccostRight.push_back(indexB);
- v2[i]->vAccostLeft.push_back(indexA);
- // cout << aminX <<", "<< mesX <<", "<< amaxX << endl;
- }
- }
- }
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-Bool_t CbmL1CATrdTrackFinderSA::OverlapsHitsXY(Int_t posA, Int_t posB)
-{
- Bool_t overlap = false;
-
- CbmTrdHit *pHitA, *pHitB;
-
- Double_t hitPosA_X, hitPosA_Y, hitPosB_X, hitPosB_Y,
- dMul1 = 3, //sigma multiplier for calculating the range of overlapping hits
- dMul2 = 3; //sigma multiplier for calculating the range of overlapping hits
-
- Double_t hitPosA_DX, hitPosA_DY, hitPosB_DX, hitPosB_DY;
-
- pHitA = L1_DYNAMIC_CAST<CbmTrdHit*>(fArrayTrdHit->At(posA));
- hitPosA_X = pHitA->GetX();
- hitPosA_Y = pHitA->GetY();
- hitPosA_DX = pHitA->GetDx();
- hitPosA_DY = pHitA->GetDy();
-
- pHitB = L1_DYNAMIC_CAST<CbmTrdHit*>(fArrayTrdHit->At(posB));
- hitPosB_X = pHitB->GetX();
- hitPosB_Y = pHitB->GetY();
- hitPosB_DX = pHitB->GetDx();
- hitPosB_DY = pHitB->GetDy();
-
- // cout
- // << "Overlap function...\n"
- // << "X1=" << hitPosA_X << ", dX1=" << hitPosA_DX << ", Y1=" << hitPosA_Y << ", dY1=" << hitPosA_DY
- // << "X2=" << hitPosB_X << ", dX2=" << hitPosB_DX << ", Y2=" << hitPosB_Y << ", dY2=" << hitPosB_DY
- // << endl;
-
-
- if (((hitPosA_X + dMul1 * hitPosA_DX) >= (hitPosB_X - dMul2 * hitPosB_DX))
- && ((hitPosA_X - dMul1 * hitPosA_DX) <= (hitPosB_X + dMul2 * hitPosB_DX))
- && ((hitPosA_Y + dMul2 * hitPosA_DY) >= (hitPosB_Y - dMul1 * hitPosB_DY))
- && ((hitPosA_Y - dMul2 * hitPosA_DY) <= (hitPosB_Y + dMul1 * hitPosB_DY))) {
- overlap = true;
- }
-
- // CbmTrdPoint *pt1 = (CbmTrdPoint*)fMCPointArray->At(posA);
- // CbmTrdPoint *pt2 = (CbmTrdPoint*)fMCPointArray->At(posB);
-
- // if(overlap && (pt1->GetTrackID() == pt2->GetTrackID())) return true;
- // else return false;
-
- return overlap;
-}
-
-
-// -----------------------------------------------------------------------
-void CbmL1CATrdTrackFinderSA::TagSegments(vector<CbmL1TrdTracklet4*>& clTrackletsA,
- vector<CbmL1TrdTracklet4*>& clTrackletsB, Int_t /*noCombSegments*/)
-{
- //asigning numbers to each segment, 4- highest, 0 - lowest
-
- // cout << "TagSegments: engaging... " << endl;
-
- // vector<CbmL1TrdTracklet4*>::iterator itclTrackletsLeft;
- vector<CbmL1TrdTracklet4*>::iterator itclTrackletsRight;
-
- CbmL1TrdTracklet4* clSegRight;
-
- vector<Int_t> vLeft;
- vector<Int_t> vRight;
-
- vector<Int_t>::iterator ivLeft;
- // vector <Int_t>::iterator ivRight;
-
- Int_t valLeft = 0, valRight = 0;
-
- // CbmL1TrdTracklet4* clSegLeft; //segment farther from the target
- // CbmL1TrdTracklet4* clSegRight; //segment nearer to the target
-
-
- // cout << "Engaging Right loop " << endl;
- for (itclTrackletsRight = clTrackletsB.begin(); itclTrackletsRight != clTrackletsB.end(); itclTrackletsRight++) {
-
- clSegRight = *itclTrackletsRight;
- //cout << "---> X of tracklet = " << clSegRight->GetCoord(0) << endl;
- vLeft = clSegRight->vAccostLeft;
- //cout << "Size of Right vector = " << clSegRight->vAccostRight.size() << endl;
- //cout << "Size of Left vector = " << clSegRight->vAccostLeft.size() << endl;
- // iHitRightA = clSegRight->GetInd(0);
- // iHitRightB = clSegRight->GetInd(1);
-
- // cout << "Tracklets 912: iHitRight: " << iHitRight << "\t" << endl;
- if (vLeft.size() > 0) {
- // cout << "Processing Comrade vector of size " << vLeft.size() << endl;
- valRight = clSegRight->GetVal();
- if (valRight == 0) {
- clSegRight->SetVal(1);
- valRight++;
- }
- for (ivLeft = vLeft.begin(); ivLeft != vLeft.end(); ivLeft++) {
- valLeft = (clTrackletsA[*ivLeft])->GetVal();
- if (valLeft <= valRight) clTrackletsA[*ivLeft]->SetVal(valRight + 1);
- }
- }
-
- // if(noCombSegments == 1){
- // if((*itclTrackletsRight)->GetVal() != 2) clTrackletsB.erase(itclTrackletsRight);
- //}
-
- //cout << "clSegRight = " << clSegRight->GetVal() << endl;
- //if(isAlone == true) clSegRight->SetIsAlone(true);
- }
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-void CbmL1CATrdTrackFinderSA::CreateTracks(vector<CbmL1TrdTracklet4*> clTracklets14,
- vector<CbmL1TrdTracklet4*> clTracklets58,
- vector<CbmL1TrdTracklet4*> clTracklets912, set<Int_t>& globalSetUsedHits,
- Bool_t removeUsedHits, Bool_t competition, Int_t /*nrLoop*/)
-{
- //create long tracks from previously selected segments
-
- if (fVerbose > 2) {
- cout << "Inner area: " << endl
- << "--- size of fArrayTrdTrack = " << fArrayTrdTrack->GetEntriesFast() << endl
- << "--- size of globalSetUsedHits = " << globalSetUsedHits.size() << endl;
- }
-
- CbmL1TrdTracklet4 *clTrdSeg1, *clTrdSeg2;
-
- vector<CbmL1TrdTracklet4*>::iterator itclSeg3;
-
- Bool_t isEmpty = true;
-
- Int_t licz = 0, counter = 0;
-
- CbmTrdTrack* tr1 = NULL;
- // CbmTrdTrack* tr2 = NULL;
- // CbmTrdHit* hit1 = NULL;
- //CbmTrdHit* hit2 = NULL;
-
- vector<CbmTrdTrack*> vTempTrdTrackCand;
- vector<CbmTrdTrack*>::iterator ivTempTrdTrackCand;
-
- set<Int_t>::iterator iglobalSetUsedHits;
-
- vector<CbmTrdTrack*>::iterator ivTrdTrackCand;
-
- Int_t iFakeTrack = 0;
- Int_t iHit = 0;
- Bool_t bTrueTrack = true;
-
- FairTrackParam* trParam;
- trParam = new FairTrackParam();
- trParam->SetQp(0.);
-
- CbmVertex vtx;
- TVector3 vzero(0, 0, 0);
- vtx.Position(vzero);
-
- Int_t iSecondLoop = 1;
- Int_t trMax = 1; //number of tracks from one tree accepted as tracks candidates
- Int_t noHitsAccepted =
- 0; //number of used hits above which the tracks is recognized as fake; 0 = all tracks are fake.
-
- vector<TempTrackStruct> auxTrack;
- auxTrack.clear();
-
- Int_t trdInd;
- vector<TempTrackStruct>::iterator ikol;
-
- cout << "--- Engaging main loop..." << endl;
-
- if (fVerbose > 2) cout << "--- No of outer iterations to go: " << clTracklets14.size() << endl;
- // Int_t vSize = Int_t(clTracklets14.size());
- //for(int i = 0; i < vSize; i++) {
- // if( (clTracklets14[i])->GetVal() == 3) licz++;
- // }
- // cout << "* No of 3 in vector: " << licz << endl;
-
- Int_t trackArrayInd = fArrayTrdTrack->GetEntriesFast();
- Int_t trlsNo[] = {0, 0, 0};
-
- for (itclSeg3 = clTracklets14.begin(); itclSeg3 != clTracklets14.end();
- itclSeg3++) { //loop over tracklets with value of 3
- if ((*itclSeg3)->GetVal() != 3) {
- trlsNo[0]++;
- continue;
- }
- for (int i = 0; i < 12; i++)
- tempTrack.M[i] = 0;
-
- tempTrack.M[0] = (*itclSeg3)->GetInd(0);
- tempTrack.M[1] = (*itclSeg3)->GetInd(1);
- tempTrack.M[2] = (*itclSeg3)->GetInd(2);
- tempTrack.M[3] = (*itclSeg3)->GetInd(3);
-
- Int_t iInd2 = 0;
- Int_t size2 = Int_t((*itclSeg3)->vAccostRight.size());
- for (Int_t iSeg2 = 0; iSeg2 < size2; iSeg2++) { //loop over clTracklets with value of 2
- iInd2 = (*itclSeg3)->vAccostRight[iSeg2];
- clTrdSeg2 = clTracklets58[iInd2];
- if (clTrdSeg2->GetVal() != 2) continue;
-
- tempTrack.M[4] = clTrdSeg2->GetInd(0);
- tempTrack.M[5] = clTrdSeg2->GetInd(1);
- tempTrack.M[6] = clTrdSeg2->GetInd(2);
- tempTrack.M[7] = clTrdSeg2->GetInd(3);
-
- Int_t iInd1 = 0;
- Int_t size1 = Int_t(clTrdSeg2->vAccostRight.size());
- for (Int_t iSeg1 = 0; iSeg1 < size1; iSeg1++) { //loop over clTracklets with value of 1
- iInd1 = clTrdSeg2->vAccostRight[iSeg1];
- clTrdSeg1 = clTracklets912[iInd1];
- if (clTrdSeg1->GetVal() != 1) continue;
-
- tempTrack.M[8] = clTrdSeg1->GetInd(0);
- tempTrack.M[9] = clTrdSeg1->GetInd(1);
- tempTrack.M[10] = clTrdSeg1->GetInd(2);
- tempTrack.M[11] = clTrdSeg1->GetInd(3);
-
- counter++;
- isEmpty = false;
-
- /*
- //-------------------------------------
- tr2 = new CbmTrdTrack();
- tr2->SetParamFirst(*trParam);
- tr2->SetParamLast(*trParam);
-
- for(Int_t we = 0; we < 12; we++) {
- hit1 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(tempTrack.M[we]);
- tr2->AddHit(tempTrack.M[we], hit1);
- }
- tr2->SortHits();
- FitKF(tr2);
- // trdTrackFitterKF->DoFit(tr2);
- tempTrack.Chi2 = tr2->GetChi2();
- delete tr2;
- //------------------------------------- */
-
- //tempTrack.Chi2 = FitTLinearFitter(tempTrack.M);
- //tempTrack.Chi2 = FitLinear(tempTrack.M, 1);
- //tempTrack.Chi2 = FitLSM(tempTrack.M);
- tempTrack.Chi2 = Fit(tempTrack.M);
-
- auxTrack.push_back(tempTrack);
-
- //if((counter%1000) == 0) {
- //printf("\rTracks: %i",counter);
- //fflush(stdout);
- //}
- } //end::loop 1
- } //end::loop 2
-
- //if(iSecondLoop%2 == 0)
- {
- iSecondLoop = 0;
- sort(auxTrack.begin(), auxTrack.end(), CompareChi2);
- //if(nrLoop == 1) trMax = 1000;
- //if(nrLoop == 2) trMax = 1000;
- // if(nrLoop == 1) cout <<"auxTrack.size(): "<< auxTrack.size() << endl;
- Int_t li = 0;
- //CbmTrdTrack *T3;
- //Double_t chiMax = 1000;
-
- for (ikol = auxTrack.begin(); ikol != auxTrack.end(); ikol++) {
- if (li >= trMax) break;
-
- tr1 = new CbmTrdTrack();
-
- for (Int_t we = 0; we < 12; we++) {
- trdInd = (*ikol).M[we];
- // hit1 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(trdInd) );
-
- tr1->AddHit(trdInd, kTRDHIT);
- }
- // tr1->SortHits();
- //tr1->SetChi2((*ikol).Chi2);
- //cout << tempTrack.Chi2 << endl;
-
- /*// Set reliable Q/p value. Based on MC values ----------------
- CbmTrdPoint *pMCpt;
- CbmMCTrack *mcTr;
- Int_t ptIndex;
- Double_t mom;
- trdInd = tr1->GetTrdHitIndex(0);
- hit1 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(trdInd);
- ptIndex = hit1->GetRefIndex();
- pMCpt = (CbmTrdPoint*) (fMCPointArray->At(ptIndex));
-
- mcTr = (CbmMCTrack*)fMCTrackArray->At(pMCpt->GetTrackID());
- mom = mcTr->GetMomentum().Mag();
- Int_t pdgCode = mcTr->GetPdgCode();
- Int_t charge = PdgToCharge(pdgCode);
- trParam->SetQp(charge/mom);
- //trParam->SetQp(1.);
- //cout <<"(pdg, Qp) "<< pdgCode <<", "<< charge/mom << endl;
- //-------------------------------------------------------------
- */
-
- tr1->SetParamFirst(trParam);
- tr1->SetParamLast(trParam);
-
- //FitKF(tr1);
- // if(tr1->GetChi2() < chiMax){
- // T3 = tr1;
- // chiMax = tr1->GetChi2();
- //}
- //if((*ikol).Chi2 < 3)
- vTempTrdTrackCand.push_back(tr1);
- li++;
- }
- //vTempTrdTrackCand.push_back(T3);
- auxTrack.clear();
- // cout << "------------------"<< endl;
- }
- //cout << iSecondLoop << endl;
- iSecondLoop++;
- } //loop over 3s
-
- //cout << clTracklets14.size() <<"\t"
- // << trlsNo[0] << endl;
-
- // if(nrLoop == 2) competition = false;
- if (competition) {
- refittingKF.Start();
- cout << "\n--- Refiting by KF..." << endl;
- /* Refit using KF fitter */
- //Int_t iKlops = 0;
- //cout << "vTempTrdTrackCand.size(): " << vTempTrdTrackCand.size() << endl;
- for (ivTempTrdTrackCand = vTempTrdTrackCand.begin(); ivTempTrdTrackCand != vTempTrdTrackCand.end();
- ivTempTrdTrackCand++) {
-
- //FitKF(*ivTempTrdTrackCand);
- //trdTrackFitterKF->DoFit(*ivTempTrdTrackCand, &vtx);
- trdTrackFitterKF->DoFit(*ivTempTrdTrackCand);
- // Double_t mX = (*ivTempTrdTrackCand)->GetParamLast()->GetX();
- // Double_t mY = (*ivTempTrdTrackCand)->GetParamLast()->GetY();
- // Double_t mXY = sqrt(mX*mX+mY*mY);
- // Double_t mChi2 = (*ivTempTrdTrackCand)->GetChi2();
- // (*ivTempTrdTrackCand)->SetChi2(mChi2*mX2);
- //cout <<"Chi2: "<< (*ivTempTrdTrackCand)->GetChi2() << endl;
- //iKlops++;
- //cout << iKlops <<": GetNofTrdHits(): " << (*ivTempTrdTrackCand)->GetNofTrdHits() << endl;
- }
- refittingKF.Stop();
-
- sort(vTempTrdTrackCand.begin(), vTempTrdTrackCand.end(), CompareChi2TrdTrack);
- }
-
- CbmTrdTrack* trCand;
- Int_t firstHitSunk = 0;
- for (ivTrdTrackCand = vTempTrdTrackCand.begin(); ivTrdTrackCand != vTempTrdTrackCand.end();
- ivTrdTrackCand++) { //Loop over track candidates; mark used hits
- trCand = (*ivTrdTrackCand);
- //cout << "Track no " << trackInd++
- // << " has " << (*ivTrdTrackCand)->GetNofTrdHits()
- // << " hits and chi2= " << (*ivTrdTrackCand)->GetChi2() << endl;
-
- // if(nrLoop == 2) removeUsedHits = false;
-
- if (removeUsedHits) { //RemoveHits
- Int_t noHitsA = trCand->GetNofHits();
-
- bTrueTrack = true;
- firstHitSunk = 0;
-
- for (int i = 0; i < noHitsA; i++) {
- iHit = trCand->GetHitIndex(i);
- iglobalSetUsedHits = globalSetUsedHits.find(iHit);
-
- if (iglobalSetUsedHits != globalSetUsedHits.end()) {
- if (firstHitSunk == noHitsAccepted) {
- bTrueTrack = false;
- iFakeTrack++;
- break;
- }
- firstHitSunk++;
- }
- }
-
- // Int_t k = 0;
- // for(int i = 0; i < noHitsA; i++) {
- // if(i != 11) k = SA[i]+SA[i+1];
- // // if(i != 10) k = SA[i]+SA[i+1]+SA[i+2];
- // if(k == noHitsAccepted){
- // bTrueTrack = false;
- // iFakeTrack++;
- // break;
- // }
- // }
-
- //if(firstHitSunk != 0) cout << firstHitSunk << endl;
- if (bTrueTrack) {
- new ((*fArrayTrdTrack)[trackArrayInd]) CbmTrdTrack(*trCand);
- trackArrayInd++;
- for (int i = 0; i < noHitsA; i++) {
- iHit = trCand->GetHitIndex(i);
- globalSetUsedHits.insert(iHit);
- }
- delete trCand;
- }
- }
- else { // end of RemoveHits
- new ((*fArrayTrdTrack)[trackArrayInd]) CbmTrdTrack(*trCand);
- trackArrayInd++;
- delete trCand;
- }
- }
-
- cout << "\n--- Finding tracks finished" << endl;
- cout << ":::Track candidates: " << vTempTrdTrackCand.size() << endl
- << ":::Fake tracks: " << iFakeTrack << endl
- << ":::fArrayTrdTrack: " << fArrayTrdTrack->GetEntriesFast() << endl;
-
- vTempTrdTrackCand.clear();
- // delete trParam;
-
- if (!isEmpty) {
- licz++;
- isEmpty = true;
- }
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-void CbmL1CATrdTrackFinderSA::CreateSegments(vector<CbmL1TrdTracklet*> clSpacePointsAB,
- vector<CbmL1TrdTracklet*> clSpacePointsCD,
- vector<CbmL1TrdTracklet4*>& clTrackletsAD, Double_t dX, Double_t dY)
-{
- //--- method to create 4-hit tracklets from Space Points (smaller 2-hit tracklets) ---
- vector<CbmL1TrdTracklet*>::iterator iSpacePtA;
- vector<CbmL1TrdTracklet*>::iterator iSpacePtB;
- vector<CbmL1TrdTracklet*>::iterator iSpacePtStart;
-
- Int_t iIndex = 0, //index
- indSpacePtA, //index of 1st miniTracklet
- indSpacePtB, //index of 2nd miniTracklet
- indSpacePtC, //index of 3rd miniTracklet
- indSpacePtD, //index of 4th miniTracklet
- noXSurv = 0, //number of tracklets that survived the X distance cut
- noYSurv = 0, //number of tracklets that survived the Y distance cut
- noXYSurv = 0, //number of tracklets that survived both X & Y distance cuts
- noAllPairs = 0, iSegAcc14 = 0;
-
- CbmL1TrdTracklet4* clTr;
-
- CbmL1TrdTracklet *trLeft, *trRight;
-
- iSpacePtStart = clSpacePointsCD.begin();
-
- //---------- BEGIN: Creation tracklet 12-34 ---------------------------------
- for (iSpacePtA = clSpacePointsAB.begin(); iSpacePtA != clSpacePointsAB.end(); iSpacePtA++) {
- trLeft = *iSpacePtA;
- indSpacePtA = trLeft->GetIndLeft();
- indSpacePtB = trLeft->GetIndRight();
-
- // cout << "GetCoord1: " << trLeft->GetCoord1() << endl;
- //cout << "--------------------" << clSpacePointsCD.size() << endl;
-
-
- //--- extrapolate --------------------------------------------
- Double_t y1 = trLeft->GetCoord(0), x1 = trLeft->GetCoord(1), y1z = trLeft->GetCoord(2), x1z = trLeft->GetCoord(3),
- x2 = 0, y2 = 0, distBetweenLayer = x1z - y1z, y2z = y1z + distBetweenLayer * 2,
- x2z = x1z + distBetweenLayer * 2;
-
- y2 = (y1 / y1z) * y2z;
- x2 = (x1 / x1z) * x2z;
- //--- end: extrapolate --------------------------------------
-
- Bool_t bFirst = true;
-
- //for(y = 0; y < trsize; y++){//y
- //trRight = clSpacePointsCD[y];
- //cout << trRight->GetCoord(0) << endl;
- // Bool_t bFirst = true;
- for (iSpacePtB = iSpacePtStart; iSpacePtB != clSpacePointsCD.end(); iSpacePtB++) {
- trRight = *iSpacePtB;
-
- indSpacePtC = trRight->GetIndLeft();
- indSpacePtD = trRight->GetIndRight();
- noAllPairs++;
-
- Double_t yB = trRight->GetCoord(0), xB = trRight->GetCoord(1), yBz = trRight->GetCoord(2),
- xBz = trRight->GetCoord(3);
-
- /*
- //--- for estimation dx and dy ----------------------------
- trdHit1 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(indSpacePtA);
- Int_t refInd1 = trdHit1->GetRefIndex();
- trdHit1 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(indSpacePtB);
- Int_t refInd2 = trdHit1->GetRefIndex();
-
- trdHit1 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(indSpacePtC);
- Int_t refInd3 = trdHit1->GetRefIndex();
- trdHit1 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(indSpacePtD);
- Int_t refInd4 = trdHit1->GetRefIndex();
-
- CbmTrdPoint
- *pPointAy,
- *pPointBx,
- *pPointCy,
- *pPointDx;
-
- pPointAy = (CbmTrdPoint*) fMCPointArray->At(refInd1);
- pPointBx = (CbmTrdPoint*) fMCPointArray->At(refInd2);
- pPointCy = (CbmTrdPoint*) fMCPointArray->At(refInd3);
- pPointDx = (CbmTrdPoint*) fMCPointArray->At(refInd4);
-
- Int_t trIDAy = pPointAy->GetTrackID();
- Int_t trIDBx = pPointBx->GetTrackID();
- Int_t trIDCy = pPointCy->GetTrackID();
- Int_t trIDDx = pPointDx->GetTrackID();
-
- CbmMCTrack *pMCtrack;
- Int_t noTRDPoints;
-
- Double_t
- x1 = pPointBx->GetX(),
- y1 = pPointAy->GetY(),
- z1y = pPointAy->GetZ(),
- z1x = pPointBx->GetZ(),
- x2 = 0,
- y2 = 0,
- z2y = z1y+distBetweenLayer*2,
- z2x = z1x+distBetweenLayer*2;
-
- y2 = (y1/z1y)*z2y;
- x2 = (x1/z1x)*z2x;
-
- if(trIDAy == trIDCy){
- pMCtrack = (CbmMCTrack*) fMCTrackArray->At(trIDAy);
- noTRDPoints = pMCtrack->GetTrdPoints();
-
- if(noTRDPoints == 12){
- Double_t fPosY = pPointCy->GetY();
- fDistY->Fill(fabs(fPosY-y2));
- }
- }
-
- if(trIDBx == trIDDx){
- pMCtrack = (CbmMCTrack*) fMCTrackArray->At(trIDBx);
- noTRDPoints = pMCtrack->GetTrdPoints();
-
- if(noTRDPoints == 12){
- Double_t fPosX = pPointDx->GetX();
- fDistX->Fill(fabs(fPosX-x2));
- }
- }
- //--- end: for estimation dx and dy -------------------------------
- */
-
- if (trRight->GetCoord(0) > y2 + dY) {
- continue;
- }
- else {
- if (bFirst) {
- bFirst = false;
- iSpacePtStart = iSpacePtB;
- }
- }
- if (trRight->GetCoord(0) < y2 - dY) break;
-
-
- if ((trRight->GetCoord(1) < x2 + dX) && (trRight->GetCoord(1) > x2 - dX)) {
-
- iSegAcc14++; //we have one more tracklet
- //we create a new tracklet object to add it into a vector
- clTr = new CbmL1TrdTracklet4();
-
- clTr->SetCoord(0, y1);
- clTr->SetCoord(1, x1);
- clTr->SetCoord(2, yB);
- clTr->SetCoord(3, xB);
-
- clTr->M[0] = y1z;
- clTr->M[1] = x1z;
- clTr->M[2] = yBz;
- clTr->M[3] = xBz;
-
- //zed is a z-axis value to which we extrapolate
- Double_t zed = 0;
-
- //cout << trdHit1->GetZ() <<" : "<< trRight->GetCoord(3) << endl;
- if (Int_t(trRight->GetCoord(3) + 1) == fTrd14_Z) {
- zed = fTrd21_Z;
- //cout <<"fTrd21_Z: "<< fTrd21_Z << endl;
- }
- //cout << trRight->GetCoord(3) <<"\t"<< fTrd14_Z << endl;
- if (Int_t(trRight->GetCoord(3) + 1) == fTrd24_Z) {
- zed = fTrd31_Z;
- //cout <<"fTrd31_Z: "<< fTrd31_Z << endl;
- }
- //cout << trRight->GetCoord(3) <<"\t"<< fTrd24_Z << endl;
-
- //if(trRight->GetPlanesID(1) == 4) zed = fTrd21_Z;
- //if(trRight->GetPlanesID(1) == 8) zed = fTrd31_Z;
- // if(trRight->GetPlanesID(1) == 4) zed = 970;
- //if(trRight->GetPlanesID(1) == 8) zed = fTrd31_Z;
-
- /* //Extrapolated by CbmTrdTrackFitterKF::Extrapolate insteas fo DistTwoTrackletsY
- //Extrapolate && fo DistTwoTrackletsY give the same results
- CbmTrdTrack *trdTrack = new CbmTrdTrack();
- CbmTrdHit *hit1;
-
- hit1 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(indSpacePtA);
- trdTrack->AddHit(indSpacePtA, hit1);
- hit1 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(indSpacePtB);
- trdTrack->AddHit(indSpacePtB, hit1);
- hit1 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(indSpacePtC);
- trdTrack->AddHit(indSpacePtC, hit1);
- hit1 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(indSpacePtD);
- trdTrack->AddHit(indSpacePtD, hit1);
-
- trdTrack->SortHits();
-
- FairTrackParam *trParam;
- trParam = new FairTrackParam();
- trParam->SetQp(0.);
- trdTrack->SetParamFirst(*trParam);
- trdTrack->SetParamLast(*trParam);
-
- trdTrackFitterKF->DoFit(trdTrack);
-
- //FairTrackParam *e_track = new FairTrackParam();
- trdTrackFitterKF->Extrapolate(trdTrack, zed, trParam);
-
- clTr->SetExt(0, trParam->GetY());
- clTr->SetExt(1, trParam->GetX());
-
- cout <<"(MY, KF) "
- << DistTwoTrackletsY(indSpacePtB, indSpacePtD, zed) <<", "
- << trParam->GetX() << endl;
- */
-
- //set the extrapolated coordinates - Y
- clTr->SetExt(0, DistTwoTrackletsY(indSpacePtA, indSpacePtC, zed));
- //set the extrapolated coordinates - X
- clTr->SetExt(1, DistTwoTrackletsX(indSpacePtB, indSpacePtD, zed + distBetweenLayer));
- //set the indices of all 4 point in tracklet
- clTr->SetInd(0, indSpacePtA);
- clTr->SetInd(1, indSpacePtB);
- clTr->SetInd(2, indSpacePtC);
- clTr->SetInd(3, indSpacePtD);
- //initial value is always 0; it is modified if necessary
- clTr->SetVal(0);
-
- //position of the tracklet in tracklets vector
- clTr->SetIndex(iIndex);
- iIndex++;
-
- //add a tracklet to a vector
- clTrackletsAD.push_back(clTr);
- noXYSurv++;
- }
- }
- }
- if (fVerbose > 2) {
- cout << " ----------- Tracklet 12-34 ------------------" << endl;
- cout << " Number of X survivors: " << noXSurv << endl;
- cout << " Number of Y survivors: " << noYSurv << endl;
- cout << "Number of XY survivors: " << noXYSurv << endl;
- cout << " Number of all pairs: " << noAllPairs << endl;
- }
-}
-// -----------------------------------------------------------------------
-
-void CbmL1CATrdTrackFinderSA::CreateSpacePoints(vector<LayerWithHits> vTrdHitArrayA,
- vector<LayerWithHits> vTrdHitArrayB,
- vector<CbmL1TrdTracklet*>& clSpacePointsAB, Double_t sigmaA,
- Double_t sigmaB)
-{
- //method to create Space Points (SP) from two individual detector hist
-
- vector<LayerWithHits>::iterator itA;
- vector<LayerWithHits>::iterator itB;
- vector<LayerWithHits>::iterator itStart;
-
- Int_t noOverlapsAB = 0,
- // noMCOverlapsAB = 0,
- iInd = 0;
-
- CbmL1TrdTracklet* clSpacePt;
-
- Int_t indA, indB;
-
- Double_t A_X, A_Y, A_Z, A_DX, A_DY;
-
- Double_t B_X, B_Y, B_Z, B_DX, B_DY;
-
- Int_t A_planeID, B_planeID;
-
- Int_t A_mcTrID, B_mcTrID;
-
- // Double_t SPlength;
-
-
- /*
- 68,0%; <= 1sigma
- 95,5%; <= 2sigma
- 99,7%, <= 3sigma
- */
-
- itStart = vTrdHitArrayB.begin();
-
- for (itA = vTrdHitArrayA.begin(); itA != vTrdHitArrayA.end(); itA++) {
-
- indA = (*itA).hitIndex;
- A_X = (*itA).X;
- A_Y = (*itA).Y;
- A_Z = (*itA).Z;
- A_DX = (*itA).DX;
- A_DY = (*itA).DY;
- A_planeID = (*itA).planeID;
- A_mcTrID = (*itA).mcTrackID;
-
- /*//--- extrapolate --------------------------------------------
- Double_t distBetweenLayer = fTrd14_Z-fTrd13_Z;
- cout << "distBetweenLayer: " << distBetweenLayer << endl;
-
- Double_t
- x1 = A_X,
- y1 = A_Y,
- z1y = A_Z,
- z1x = A_Z,
- x2 = 0,
- y2 = 0,
- z2y = z1y+distBetweenLayer, // 12 is a distance beetwen plane in TRD
- z2x = z1x+distBetweenLayer; // 12 is a distance beetwen plane in TRD
-
- y2 = (y1/z1y)*z2y;
- x2 = (x1/z1x)*z2x;
- //--- end: extrapolate --------------------------------------*/
-
- Bool_t bFirst = true;
- for (itB = itStart; itB != vTrdHitArrayB.end(); itB++) {
-
- indB = (*itB).hitIndex;
- B_X = (*itB).X;
- B_Y = (*itB).Y;
- B_Z = (*itB).Z;
- B_DX = (*itB).DX;
- B_DY = (*itB).DY;
- B_planeID = (*itB).planeID;
- B_mcTrID = (*itB).mcTrackID;
-
- if (B_Y + sigmaB * B_DY < A_Y - sigmaA * A_DY) {
- continue;
- }
- else {
- /* Finding the bottom level to begin the second loop.
- The value of bottom level is taken from previous "second loop".*/
- if (bFirst) {
- itStart = itB;
- bFirst = false;
- }
- }
-
- if (B_Y - sigmaB * B_DY > A_Y + sigmaA * A_DY) break;
-
- // cout <<"(A_X, A_DX, sigmaA*A_DX) "<< A_X <<", "<< A_DX <<", "<< sigmaA*A_DX <<", "<< endl;
- // cout <<"(A_Y, A_DY, sigmaA*A_DY) "<< A_Y <<", "<< A_DY <<", "<< sigmaA*A_DY <<", "<< endl;
- // cout <<"(B_X, B_DX, sigmaB*B_DX) "<< B_X <<", "<< B_DX <<", "<< sigmaB*B_DX <<", "<< endl;
- // cout <<"(B_Y, B_DY, sigmaB*B_DY) "<< B_Y <<", "<< B_DY <<", "<< sigmaB*B_DY <<", "<< endl;
- // cout <<"-----------------------------------------"<< endl;
- // if (B_Y < y2 - sigmaB*A_DY) continue;
- // if (B_Y > y2 + sigmaB*A_DY) break;
- // cout <<"[Extrapol, Real, Diff] "
- // << y2 <<", "<< B_Y <<", "<< B_Y-y2 << endl;
-
- if ((B_X - sigmaB * B_DX < A_X + sigmaA * A_DX) && (B_X + sigmaB * B_DX > A_X - sigmaA * A_DX)) {
-
- noOverlapsAB++;
- clSpacePt = new CbmL1TrdTracklet();
-
- clSpacePt->SetIndLeft(indA);
- clSpacePt->SetIndRight(indB);
- clSpacePt->SetVal(0);
- clSpacePt->SetIndex(iInd);
- clSpacePt->SetCoord(0, A_Y);
- clSpacePt->SetCoord(1, B_X);
- clSpacePt->SetCoord(2, A_Z);
- clSpacePt->SetCoord(3, B_Z);
- clSpacePt->SetPlanesID(A_planeID, B_planeID);
-
- // //----------------------------------------
- // TVector3 t1, t2, t3;
- // t1.SetXYZ(A_X, A_Y, A_Z);
- // t2.SetXYZ(B_X, B_Y, B_Z);
- // t3 = t2 - t1;
- // SPlength = t3.Mag();
-
- // Double_t
- // x = 0,
- // y = 0,
- // z = 0,
- // t = 0;
-
- // t = (z - A_Z)/(B_Z - A_Z);
- // x = A_X + t*(B_X-A_X);
- // y = A_Y + t*(B_Y-A_Y);
-
- // //SPlength = sqrt(2*(B_Y-A_Y)*(B_Y-A_Y));
- // if(Station == 1){
- // if(A_mcTrID == B_mcTrID){
- // noMCOverlapsAB++;
- // fSPlengthMC->Fill(SPlength);
- // fYat0MC->Fill(x);
- // }else{
- // fSPlength->Fill(SPlength);
- // fYat0->Fill(x);
- // }
- // }
- iInd++;
-
- clSpacePointsAB.push_back(clSpacePt);
-
- if (A_mcTrID == B_mcTrID) {
- fh_SP_xDiff_MC->Fill(A_X - B_X);
- fh_SP_yDiff_MC->Fill(A_Y - B_Y);
- }
- else {
- fh_SP_xDiff_nMC->Fill(A_X - B_X);
- fh_SP_yDiff_nMC->Fill(A_Y - B_Y);
- }
- }
- }
- }
- iInd = 0;
- if (fVerbose > 1) cout << "--- No Space Points: " << noOverlapsAB << endl;
- // cout <<"--- (No SP, MCSP) "
- // << noOverlapsAB <<", "
- // << noMCOverlapsAB <<endl;
-}
-
-
-// -----------------------------------------------------------------------
-void CbmL1CATrdTrackFinderSA::CreateAndManageSegments(vector<CbmL1TrdTracklet4*> clTracklets14,
- vector<CbmL1TrdTracklet4*> clTracklets58,
- vector<CbmL1TrdTracklet4*> clTracklets912)
-{
- //CreateAndManageSegments with no long track creation, 1 track = 1 segment
-
- vector<CbmL1TrdTracklet4*>::iterator itclSeg;
-
- CbmTrdTrack* tr1 = NULL;
- // CbmTrdHit* hit1 = NULL;
- // CbmTrdHit* hit2 = NULL;
- // CbmTrdHit* hit3 = NULL;
- // CbmTrdHit* hit4 = NULL;
-
- CbmL1TrdTracklet4* clTrdSeg;
-
- Int_t trackArrayInd = 0;
-
- Int_t indTrdHit1, indTrdHit2, indTrdHit3, indTrdHit4;
-
- for (itclSeg = clTracklets14.begin(); itclSeg != clTracklets14.end(); itclSeg++) {
-
- clTrdSeg = *itclSeg;
- tr1 = new CbmTrdTrack();
-
- indTrdHit1 = clTrdSeg->GetInd(0);
- // hit1 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(indTrdHit1) );
- tr1->AddHit(indTrdHit1, kTRDHIT);
-
- indTrdHit2 = clTrdSeg->GetInd(1);
- // hit2 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(indTrdHit2) );
- tr1->AddHit(indTrdHit2, kTRDHIT);
-
- indTrdHit3 = clTrdSeg->GetInd(2);
- // hit3 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(indTrdHit3) );
- tr1->AddHit(indTrdHit3, kTRDHIT);
-
- indTrdHit4 = clTrdSeg->GetInd(3);
- // hit4 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(indTrdHit4) );
- tr1->AddHit(indTrdHit4, kTRDHIT);
-
- // tr1->SortHits();
-
- new ((*fArrayTrdTrack)[trackArrayInd]) CbmTrdTrack(*tr1);
-
- delete tr1;
- trackArrayInd++;
- }
-
- for (itclSeg = clTracklets58.begin(); itclSeg != clTracklets58.end(); itclSeg++) {
-
- clTrdSeg = *itclSeg;
- tr1 = new CbmTrdTrack();
-
- indTrdHit1 = clTrdSeg->GetInd(0);
- // hit1 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(indTrdHit1) );
- tr1->AddHit(indTrdHit1, kTRDHIT);
-
- indTrdHit2 = clTrdSeg->GetInd(1);
- // hit2 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(indTrdHit2) );
- tr1->AddHit(indTrdHit2, kTRDHIT);
-
- indTrdHit3 = clTrdSeg->GetInd(2);
- // hit3 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(indTrdHit3) );
- tr1->AddHit(indTrdHit3, kTRDHIT);
-
- indTrdHit4 = clTrdSeg->GetInd(3);
- // hit4 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(indTrdHit4) );
- tr1->AddHit(indTrdHit4, kTRDHIT);
-
- // tr1->SortHits();
-
- new ((*fArrayTrdTrack)[trackArrayInd]) CbmTrdTrack(*tr1);
-
- delete tr1;
- trackArrayInd++;
- }
-
- for (itclSeg = clTracklets912.begin(); itclSeg != clTracklets912.end(); itclSeg++) {
-
- clTrdSeg = *itclSeg;
- tr1 = new CbmTrdTrack();
-
- indTrdHit1 = clTrdSeg->GetInd(0);
- // hit1 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(indTrdHit1) );
- tr1->AddHit(indTrdHit1, kTRDHIT);
-
- indTrdHit2 = clTrdSeg->GetInd(1);
- // hit2 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(indTrdHit2) );
- tr1->AddHit(indTrdHit2, kTRDHIT);
-
- indTrdHit3 = clTrdSeg->GetInd(2);
- // hit3 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(indTrdHit3) );
- tr1->AddHit(indTrdHit3, kTRDHIT);
-
- indTrdHit4 = clTrdSeg->GetInd(3);
- // hit4 = L1_DYNAMIC_CAST<CbmTrdHit*>( fArrayTrdHit->At(indTrdHit4) );
- tr1->AddHit(indTrdHit4, kTRDHIT);
-
- // tr1->SortHits();
-
- new ((*fArrayTrdTrack)[trackArrayInd]) CbmTrdTrack(*tr1);
-
- delete tr1;
- trackArrayInd++;
- }
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-Double_t CbmL1CATrdTrackFinderSA::Fit(CbmTrdTrack* tr)
-{ //fits a track with a straight line and caluculates each point's deviation
-
- Double_t chi2 = 0;
-
- Int_t iHit;
- CbmTrdHit* pHit[12];
-
- Double_t y1, y2, z1, z2, yA[12], zA[12], yB[12], zB[12];
-
- Double_t dist1 = 0;
- Double_t dist2 = 0;
- // Double_t sum1 = 0;
- // Double_t sum2 = 0;
- Double_t yS1 = 0;
- Double_t yS2 = 0;
-
- Int_t noHits = tr->GetNofHits();
-
- for (int i = 0; i < noHits; i++) {
- iHit = tr->GetHitIndex(i);
-
- pHit[i] = L1_DYNAMIC_CAST<CbmTrdHit*>(fArrayTrdHit->At(iHit));
- }
-
- //first and last X(orY) pointa in the track
- yA[0] = pHit[0]->GetY();
- zA[0] = pHit[0]->GetZ();
- yB[10] = pHit[10]->GetY();
- zB[10] = pHit[10]->GetZ();
-
- //first and last Y(orX) pointa in the track
- yA[1] = pHit[1]->GetX();
- zA[1] = pHit[1]->GetZ();
- yB[11] = pHit[11]->GetX();
- zB[11] = pHit[11]->GetZ();
-
- Int_t t1 = 0;
- Int_t t2 = 1;
-
- for (int i = 0; i < 4; i++) {
-
- //for X(orY) coordinates
- t1 += 2;
- y1 = fabs(pHit[t1]->GetY());
- z1 = pHit[t1]->GetZ();
-
- yS1 = fabs((((yB[10] - yA[0]) * (z1 - zA[0])) / (zB[10] - zA[0])) + yA[0]);
- dist1 = fabs(yS1 - y1);
-
- //for Y(orX) coordinates
- t2 += 2;
- y2 = fabs(pHit[t2]->GetX());
- z2 = pHit[t2]->GetZ();
-
- yS2 = fabs((((yB[11] - yA[1]) * (z2 - zA[1])) / (zB[11] - zA[1])) + yA[1]);
- dist2 = fabs(yS2 - y2);
-
- chi2 += (dist1 + dist2) / 2;
- }
-
- // cout << "chi2: " << chi2 << endl;
-
-
- // for(int i = 0; i < 4; i++){
-
- // //for X(orY) coordinates
- // t1+=2;
- // y1 = fabs(pHit[t1]->Y());
- // z1 = pHit[t1]->Z();
-
- // yS1 = fabs((((yB[10]-yA[0])*(z1-zA[0]))/(zB[10]-zA[0]))+yA[0]);
- // dist1 = fabs(yS1-y1);
- // sum1+=dist1;
-
- // //for Y(orX) coordinates
- // t2+=2;
- // y2 = fabs(pHit[t2]->X());
- // z2 = pHit[t2]->Z();
-
- // yS2 = fabs((((yB[11]-yA[1])*(z2-zA[1]))/(zB[11]-zA[1]))+yA[1]);
- // dist2 = fabs(yS2-y2);
- // sum2+=dist2;
- // }
- // chi2=sum1+sum2;
-
-
- // Calculate length of the track ---------------
- // Double_t
- // length0 = 0,
- // length1 = 0,
- // length2 = 0;
-
- // t1 = 0;
- // t2 = 1;
-
- // Double_t
- // x = 0,
- // y = 0,
- // z = 0;
-
- // for(int i = 0; i < 4; i++){
- // y = fabs(pHit[t1+2]->Y())-fabs(pHit[t1]->Y());
- // z = (pHit[t1+2]->Z())-(pHit[t1]->Z());
- // length1 += sqrt(y*y + z*z);
- // t1+=2;
-
- // x = fabs(pHit[t2+2]->X())-fabs(pHit[t2]->X());
- // z = (pHit[t2+2]->Z())-(pHit[t2]->Z());
- // length2 += sqrt(x*x + z*z);
- // t2+=2;
- // }
-
- // width0 = width1 + width2;
- // // cout << width0 << endl;
-
- return chi2;
- //return length0;
-}
-// -----------------------------------------------------------------------
-
-Double_t CbmL1CATrdTrackFinderSA::Fit(Int_t M[])
-{ //fits a track with a straight line and caluculates each point's deviation
-
- Double_t chi2 = 0;
-
- Int_t iHit;
- CbmTrdHit* pHit[12];
-
- Double_t y1, y2, z1, z2, yA[12], zA[12], yB[12], zB[12];
-
- Double_t dist1 = 0;
- Double_t dist2 = 0;
- Double_t yS1 = 0;
- Double_t yS2 = 0;
-
- Int_t noHits = 12;
-
- for (int i = 0; i < noHits; i++) {
- iHit = M[i];
- pHit[i] = L1_DYNAMIC_CAST<CbmTrdHit*>(fArrayTrdHit->At(iHit));
- }
-
- //first and last X(orY) pointa in the track
- yA[0] = pHit[0]->GetY();
- zA[0] = pHit[0]->GetZ();
- yB[10] = pHit[10]->GetY();
- zB[10] = pHit[10]->GetZ();
-
- //first and last Y(orX) pointa in the track
- yA[1] = pHit[1]->GetX();
- zA[1] = pHit[1]->GetZ();
- yB[11] = pHit[11]->GetX();
- zB[11] = pHit[11]->GetZ();
-
- Int_t t1 = 0;
- Int_t t2 = 1;
-
- for (int i = 0; i < 4; i++) {
-
- //for X(orY) coordinates
- t1 += 2;
- y1 = fabs(pHit[t1]->GetY());
- z1 = pHit[t1]->GetZ();
-
- yS1 = fabs((((yB[10] - yA[0]) * (z1 - zA[0])) / (zB[10] - zA[0])) + yA[0]);
- dist1 = fabs(yS1 - y1);
-
- //for Y(orX) coordinates
- t2 += 2;
- y2 = fabs(pHit[t2]->GetX());
- z2 = pHit[t2]->GetZ();
-
- yS2 = fabs((((yB[11] - yA[1]) * (z2 - zA[1])) / (zB[11] - zA[1])) + yA[1]);
- dist2 = fabs(yS2 - y2);
-
- //chi2 += (dist2+dist1)/2;
- chi2 += sqrt(dist1 * dist1 + dist2 * dist2);
- }
- return chi2;
-}
-// -----------------------------------------------------------------------
-
-// -----------------------------------------------------------------------
-Double_t CbmL1CATrdTrackFinderSA::FitLinear(Int_t M[], Int_t /*var*/ = 1)
-{
- //fit using a least square method
-
-
- Int_t noHits = 12;
-
- Int_t iHit;
- CbmTrdHit* hit;
-
- Double_t C1[12];
- Double_t C2[12];
- Double_t Z[12];
-
- Double_t n = 12;
-
- for (int i = 0; i < 12; i++) {
- C1[i] = 0;
- C2[i] = 0;
- Z[i] = 0;
- }
-
- // Int_t ind = 0;
-
- for (int i = 0; i < noHits; i++) {
-
- iHit = M[i];
- hit = L1_DYNAMIC_CAST<CbmTrdHit*>(fArrayTrdHit->At(iHit));
-
- C1[i] = hit->GetX();
- C2[i] = hit->GetY();
- Z[i] = hit->GetZ();
- }
-
- Double_t sumXZ = 0, sumYZ = 0, sumX = 0, sumY = 0, sumZx = 0, sumZy = 0, sumX2 = 0, sumY2 = 0, sumZx2 = 0, sumZy2 = 0;
-
- for (int i = 0; i < 12; i += 2) {
- // cout << "C1[" << i << "]=" << C1[i] << endl;
- // cout << "C2[" << i << "]=" << C2[i] << endl;
- // if(!(i % 2))
- {
- sumXZ += C1[i] * Z[i];
-
- sumX += C1[i];
- sumX2 += C1[i] * C1[i];
-
- sumZx += Z[i];
- sumZx2 += Z[i] * Z[i];
- }
- }
-
- for (int i = 1; i < 12; i += 2) {
- // cout << "C1[" << i << "]=" << C1[i] << endl;
- // cout << "C2[" << i << "]=" << C2[i] << endl;
- // if(!((1i % 2))
- {
- sumYZ += C2[i] * Z[i];
-
- sumY += C2[i];
- sumY2 += C2[i] * C2[i];
-
- sumZy += Z[i];
- sumZy2 += Z[i] * Z[i];
- }
- }
-
-
- cout << "";
- // Double_t a = (n*sumXZ - sumX*sumZ)/(n*sumX2 - sumX*sumX);
- // Double_t b = (sumZ - a*sumX)/n;
- Double_t r1 = (n * sumXZ - sumX * sumZx) / sqrt((n * sumX2 - sumX * sumX) * (n * sumZx2 - sumZx * sumZx));
- // Double_t Sa = sqrt((n*(sumY2 -a*sumXZ-b*sumY))/((n-2)*(n*sumX2-sumX*sumX)));
- // Double_t Sb = Sa*sqrt(sumX2/n);
-
-
- Double_t r2 = (n * sumYZ - sumY * sumZy) / sqrt((n * sumY2 - sumY * sumY) * (n * sumZy2 - sumZy * sumZy));
-
-
- // cout << "Linear coefficients: a= "
- // << a << ", Sa= " << Sa << ", b= " << b << ", Sb= " << Sb << endl
- // << ", r=" << r << ", chi2=" << tr->GetChi2() << endl;
-
-
- return sqrt(r1 * r1 + r2 * r2);
-}
-
-Double_t CbmL1CATrdTrackFinderSA::FitLSM(Int_t M[])
-{
-
- Double_t chi2 = 0;
- Int_t iHit;
- CbmTrdHit* pHit[12];
-
- Int_t noHits = 12;
- for (int i = 0; i < noHits; i++) {
- iHit = M[i];
- pHit[i] = L1_DYNAMIC_CAST<CbmTrdHit*>(fArrayTrdHit->At(iHit));
- }
-
- Double_t xAv = 0, yAv = 0, zAvx = 0, zAvy = 0, sumXiXav = 0, sumYiYav = 0, sumXiXav_ZiZAv = 0, sumYiYav_ZiZAv = 0,
- sumZiZav_x = 0, sumZiZav_y = 0, bY = 0, bX = 0;
-
- for (int i = 0; i < 12; i += 2) {
- yAv += pHit[i]->GetY();
- zAvy += pHit[i]->GetZ();
- }
- for (int i = 1; i < 12; i += 2) {
- xAv += pHit[i]->GetX();
- zAvx += pHit[i]->GetZ();
- }
-
- for (int i = 0; i < 12; i += 2) {
- Double_t dy = pHit[i]->GetY() - yAv;
- Double_t dz = pHit[i]->GetZ() - zAvy;
- sumYiYav_ZiZAv += dy * dz;
- sumYiYav += dy * dy;
- sumZiZav_y += dz * dz;
- }
- for (int i = 1; i < 12; i += 2) {
- Double_t dx = pHit[i]->GetX() - xAv;
- Double_t dz = pHit[i]->GetZ() - zAvx;
- sumXiXav_ZiZAv += dx * dz;
- sumXiXav += dx * dx;
- sumZiZav_x += dz * dz;
- }
-
- bY = sumYiYav_ZiZAv / sumYiYav;
- bX = sumXiXav_ZiZAv / sumXiXav;
-
- chi2 = sqrt((sumZiZav_y - bY * sumYiYav_ZiZAv) / (4)) + sqrt((sumZiZav_x - bX * sumXiXav_ZiZAv) / (4));
-
- return chi2;
-}
-
-
-Double_t CbmL1CATrdTrackFinderSA::FitKF(CbmTrdTrack* pTrack)
-{
-
- // Declare variables outside the loop
- CbmTrdHit* pHit = NULL;
- CbmKFTrdHit* pKFHit = NULL;
- Int_t hitIndex = 0;
- // Int_t materialIndex = 0;
- Double_t eLoss = 0.;
-
- // Loop over TRD hits of the track
- Int_t nTracks = pTrack->GetNofHits();
- for (Int_t iHit = 0; iHit < nTracks; iHit++) {
- // Get current hit index
- hitIndex = pTrack->GetHitIndex(iHit);
- //Get the pointer to the CbmTrdHit
- pHit = L1_DYNAMIC_CAST<CbmTrdHit*>(fArrayTrdHit->At(hitIndex));
- // Accumulate TR energy loss
- eLoss += pHit->GetELoss();
- // Create CbmKFTrdHit
- pKFHit = new CbmKFTrdHit();
- pKFHit->Create(pHit);
- // materialIndex = pKFHit->MaterialIndex;
- // Add to the KFTrack
- fKfTrack->fHits.push_back(pKFHit);
- } // Loop over TRD hits
-
- fKfTrack->GetRefChi2() = 0.;
- fKfTrack->GetRefNDF() = 0;
- fKfTrack->SetTrackParam(*(const_cast<FairTrackParam*>(pTrack->GetParamLast())));
-
- fKfTrack->Fit();
- // Store parameters at first layer
- fKfTrack->GetTrackParam(*(const_cast<FairTrackParam*>(pTrack->GetParamFirst())));
- // Store parameters at last layer
- fKfTrack->GetTrackParam(*(const_cast<FairTrackParam*>(pTrack->GetParamLast())));
- // Store chi2 of fit
- pTrack->SetChiSq(fKfTrack->GetRefChi2());
- pTrack->SetNDF(fKfTrack->GetRefNDF());
-
- // Store accumulated TR energy loss
- pTrack->SetELoss(eLoss);
-
- // Delete CbmKFTrdHit objects
- vector<CbmKFHit*>::iterator it;
- for (it = fKfTrack->fHits.begin(); it != fKfTrack->fHits.end(); it++) {
- pKFHit = L1_DYNAMIC_CAST<CbmKFTrdHit*>(*it);
- delete pKFHit;
- }
- fKfTrack->fHits.clear();
-
- return 0;
-}
-
-Double_t CbmL1CATrdTrackFinderSA::FitTLinearFitter(Int_t M[])
-{
-
- Double_t chi2 = 0;
- Double_t chi2x = 0;
- Double_t chi2y = 0;
- const Int_t nrPnts = 12;
- Int_t k = 0;
- Int_t w = 0;
- Int_t j = 6;
- Double_t ax[6];
- Double_t ay[6];
- Double_t az1[6];
- // Double_t az2[6];
-
- CbmTrdHit* trdHit;
- for (int i = 0; i < nrPnts; i++) {
- trdHit = L1_DYNAMIC_CAST<CbmTrdHit*>(fArrayTrdHit->At(M[i]));
- k = i + 1;
- if ((k % 2) == 0) {
- ax[w] = trdHit->GetX();
- az1[w] = trdHit->GetZ();
- w++;
- }
- else {
- ay[w] = trdHit->GetY();
- // az2[w] = trdHit->GetZ();
- }
- }
-
- TLinearFitter* lf;
- lf = new TLinearFitter(2);
- lf->SetFormula("hyp2");
- lf->StoreData(0);
-
- TVectorD x;
- x.Use(j, ax);
- TVectorD z1;
- z1.Use(j, az1);
- lf->AssignData(j, 1, ax, az1);
- lf->Eval();
- chi2x = lf->GetChisquare();
-
- delete lf;
- //--------------------------------
- lf = new TLinearFitter(2);
- lf->SetFormula("hyp2");
- lf->StoreData(0);
-
- TVectorD y;
- x.Use(j, ay);
- TVectorD z2;
- z2.Use(j, az1);
- lf->AssignData(j, 1, ay, az1);
- lf->Eval();
- chi2y = lf->GetChisquare();
-
- chi2 = chi2x + chi2y;
-
- return chi2;
-}
-
-Int_t CbmL1CATrdTrackFinderSA::PdgToCharge(Int_t pdgCode)
-{
- Int_t value;
- switch (pdgCode) { //switch
- case 11: //electron
- {
- value = -1;
- break;
- }
- case -11: //positron
- {
- value = +1;
- break;
- }
- case 13: //muon-
- {
- value = -1;
- break;
- }
- case -13: //muon+
- {
- value = +1;
- break;
- }
- case 22: {
- value = 0; //gamma
- break;
- }
- case 211: {
- value = +1; //pi+
- break;
- }
- case -211: {
- value = -1; //pi-
- break;
- }
- case 111: {
- value = 0; //pi0
- break;
- }
- case 213: {
- value = +1; //rho+
- break;
- }
- case -213: {
- value = -1; //rho-
- break;
- }
- case 113: {
- value = 0; //rho0
- break;
- }
- case 221: {
- value = 0; //eta
- break;
- }
- case 323: {
- value = 0; //omega
- break;
- }
- case 333: {
- value = 0; //phi
- break;
- }
- case 321: {
- value = +1; //kaon+
- break;
- }
- case -321: {
- value = -1; //kaon-
- break;
- }
-
- case 443: {
- value = 0; //jpsi
- break;
- }
- case 2112: {
- value = 0; //neutron
- break;
- }
- case 2212: {
- value = +1; //proton
- break;
- }
- case -2212: {
- value = 0; //anti-proton (?!)
- break;
- }
- case 3222: {
- value = +1; //sigma+
- break;
- }
- case 3112: {
- value = -1; //sigma-
- break;
- }
- case 3212: {
- value = 0; //sigma0
- break;
- }
- default: {
- value = -1000;
- break;
- }
- }
- return value;
-}
-
-Bool_t CbmL1CATrdTrackFinderSA::Rejection(Double_t Procent, Int_t num)
-{
-
- Bool_t accept = true;
- Int_t random;
-
- random = (rand() % num);
-
- if (random >= Procent) accept = false;
-
- return accept;
-}
diff --git a/reco/KF/obsolete/CbmL1CATrdTrackFinderSA.h b/reco/KF/obsolete/CbmL1CATrdTrackFinderSA.h
deleted file mode 100644
index 15f0909f1ac59919c9924107f8e9e7817096f007..0000000000000000000000000000000000000000
--- a/reco/KF/obsolete/CbmL1CATrdTrackFinderSA.h
+++ /dev/null
@@ -1,295 +0,0 @@
-/* Copyright (C) 2006-2010 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Arkadiusz Bubak, M. Krauze, Sergey Gorbunov, Denis Bertini [committer] */
-
-// -----------------------------------------------------------------------
-// ----- CbmL1CATrdTrackFinderSA -----
-// ----- Created 2/12/2006 by A. Bubak & M. Krauze -----
-// -----------------------------------------------------------------------
-
-/** CbmL1CATrdTrackFinderSA_Hits
- *@author A.Bubak<abubak@nuph.us.edu.pl> & M.Krauze<meszik@nuph.us.edu.pl>
- ** Algorithm for track finding in TRD, based on Cellular Automathon algorithm
- **/
-
-
-#ifndef CBML1CATRDTRACKFINDERSA_HITS
-#define CBML1CATRDTRACKFINDERSA_HITS
-
-#include "CbmTrdTrack.h"
-#include "CbmTrdTrackFinder.h"
-#include "TStopwatch.h"
-
-#include <map>
-#include <set>
-#include <vector>
-
-class TClonesArray;
-class CbmTrdHit;
-class CbmKF;
-class CbmKFTrack;
-class TH1F;
-class TH2F;
-class CbmGeoTrdPar;
-class CbmTrdTrackFitterKF;
-class CbmL1TrdTracklet;
-class CbmL1TrdTracklet4;
-
-class CbmL1CATrdTrackFinderSA : public CbmTrdTrackFinder {
- private:
- CbmL1CATrdTrackFinderSA(const CbmL1CATrdTrackFinderSA&);
- CbmL1CATrdTrackFinderSA operator=(const CbmL1CATrdTrackFinderSA&);
-
- public:
- /** Default constructor **/
- CbmL1CATrdTrackFinderSA();
-
- /** Destructor **/
- virtual ~CbmL1CATrdTrackFinderSA();
-
-
- static CbmL1CATrdTrackFinderSA* Instance() { return fInstance; }
- static CbmL1CATrdTrackFinderSA* fInstance;
-
- /** Initialisation **/
- void Init();
-
- /** Track finding algorithm **/
- Int_t DoFind(TClonesArray* hitArray, TClonesArray* trackArray);
-
- struct Layer {
- Layer() {}
- Double_t X[12];
- Double_t Y[12];
- Double_t Z[12];
- Double_t scale[12];
- } geoLayer;
-
- Int_t fNTrdHits;
-
- /** TRD layout **/
- Int_t fNoTrdStations;
- Int_t fNoTrdPerStation;
-
- /** Structure contains trd hits divided per given station **/
- struct LayerWithHits {
- LayerWithHits() : hitIndex(0), mcTrackID(0), X(0), Y(0), Z(0), DX(0), DY(0), planeID(0) {}
- Int_t hitIndex;
- Int_t mcTrackID;
- Double_t X;
- Double_t Y;
- Double_t Z;
- Double_t DX;
- Double_t DY;
- Int_t planeID;
- } planeHits;
-
- //--- vector with hits which belong to given trd plane
- std::vector<LayerWithHits> fvTrdHitArr[12];
- std::vector<LayerWithHits> fvTrdPointArr[12];
-
- std::vector<LayerWithHits>::iterator fivTrdHitArr;
-
- /** Data branches **/
- TClonesArray* fArrayTrdHit;
- TClonesArray* fArrayTrdTrack;
-
- private:
- CbmGeoTrdPar* TrdPar;
-
- /** Event counter **/
- Int_t fEvents;
- Int_t fNofEvents;
-
- /** Arrays of MC information **/
- TClonesArray* fMCTrackArray;
- TClonesArray* fMCPointArray;
-
- /** Traxk fitter **/
- CbmTrdTrackFitterKF* trdTrackFitterKF;
-
- /** Verbosity level **/
- Int_t fVerbose;
-
- /** Array of sorted TRD hits **/
- Int_t fNoTrdHits[12];
- Int_t fTrdHitIndex[12][10000];
-
- /** Arrays for TRD tracks **/
- std::vector<CbmTrdTrack*> fvTempArray;
- std::vector<CbmTrdTrack*> fvFoundTracks;
-
- inline static Bool_t CompareY(LayerWithHits A, LayerWithHits B) { return (A.Y < B.Y); };
-
- /** Structure contains temporary values of track candidates **/
- struct TempTrackStruct {
- TempTrackStruct() : Chi2(0){};
- Double_t Chi2;
- Int_t M[12];
- } tempTrack;
-
- inline static Bool_t CompareChi2(TempTrackStruct A, TempTrackStruct B) { return (A.Chi2 < B.Chi2); };
-
-
- // iterators to vectors
- std::vector<Int_t>::iterator iStation1;
- std::vector<Int_t>::iterator iStation2;
-
- std::vector<Int_t>::iterator fImapSt1;
- std::vector<Int_t>::iterator fImapSt2;
-
- std::vector<CbmL1TrdTracklet4*>::iterator itTrackletsLeft;
- std::vector<CbmL1TrdTracklet4*>::iterator itTrackletsRight;
-
- Int_t iHitMap1, iHitMap2;
- Double_t iHitMapY1, iHitMapY2;
-
- /** Z position selected trd layers **/
- Double_t fTrd13_Z, fTrd14_Z, fTrd21_Z, fTrd24_Z, fTrd31_Z;
-
- CbmKFTrack* fKfTrack; // KF track
-
- /** To check time comsumption of procedures **/
- TStopwatch createSegments, findNeighbour, createSPs, createSPs_SL, sortSPs, doFind, sortHits, tagTracks, createTracks,
- selectTracks, delTime, secondLoopTime, refittingKF, thirdLoopTime;
-
- Double_t totCreateSegments, totFindNeighbour, totCreateSPs, totCreateSPs_SL, totSortSPs, totDoFind, totSortHits,
- totTagTracks, totCreateTracks, totDelTime, totSecondLoopTime, totThirdLoopTime, totSelectTracks, totRefittingKF;
-
- void DeleteTracklets(std::vector<CbmL1TrdTracklet4*> vect);
- void DeleteTracklets(std::vector<CbmL1TrdTracklet*> vect);
-
- Double_t DistTwoTrackletsX(Int_t iIndexFirst, Int_t iIndexSecond, Double_t zed);
-
- Double_t DistTwoTrackletsY(Int_t iIndexFirst, Int_t iIndexSecond, Double_t zed);
-
- void CreateSpacePoints(std::vector<LayerWithHits> vTrdHitArrayA, std::vector<LayerWithHits> vTrdHitArrayB,
- std::vector<CbmL1TrdTracklet*>& clSpacePointsAB, Double_t sigmaA, Double_t sigmaB);
-
- void CreateSegments(std::vector<CbmL1TrdTracklet*> clSpacePointsAB, std::vector<CbmL1TrdTracklet*> clSpacePointsCD,
- std::vector<CbmL1TrdTracklet4*>& clTrackletsAD, Double_t dX, Double_t dY);
-
- void TagSegments(std::vector<CbmL1TrdTracklet4*>& clTrackletsA, std::vector<CbmL1TrdTracklet4*>& clTrackletsB,
- Int_t noCombSegments = 0);
-
- void CreateTracks(std::vector<CbmL1TrdTracklet4*> clTracklets14, std::vector<CbmL1TrdTracklet4*> clTracklets58,
- std::vector<CbmL1TrdTracklet4*> clTracklets912, std::set<Int_t>& setUsedHits, Bool_t removeUsedHits,
- Bool_t competition = true, Int_t nrLoop = 0);
-
- void CreateAndManageSegments(std::vector<CbmL1TrdTracklet4*> clTracklets14,
- std::vector<CbmL1TrdTracklet4*> clTracklets58,
- std::vector<CbmL1TrdTracklet4*> clTracklets912);
-
- Bool_t OverlapsHitsXY(Int_t posA, Int_t posB);
-
- void FindNeighbour(std::vector<CbmL1TrdTracklet4*>& v1, std::vector<CbmL1TrdTracklet4*>& v2, Double_t dY,
- Double_t dX);
-
- /** Fitting procedures **/
- Double_t FitLinear(CbmTrdTrack* tr,
- Int_t var); //var = {1,2} => which coordinate to use
- Double_t FitLinear(Int_t M[],
- Int_t var); //var = {1,2} => which coordinate to use
- Double_t Fit(CbmTrdTrack* tr);
- Double_t Fit(Int_t M[]);
- Double_t FitKF(CbmTrdTrack* pTrack);
- Double_t FitTLinearFitter(Int_t M[]);
- Double_t FitLSM(Int_t M[]);
-
-
- /** Rejection procedure **/
- Bool_t Rejection(Double_t Procent, Int_t num = 100);
-
- /** Pdg to charge conversion **/
- Int_t PdgToCharge(Int_t pdgCode);
-
- /** Create histogramms **/
- void CreateHistogramms();
-
- /** Activates data branches **/
- void DataBranches();
-
- /** Determine detector layout **/
- void TrdLayout();
-
- public:
- /** Write histogramms **/
- void WriteHistogramms();
-
- /** Public accessors **/
- inline const Int_t& GetVerbose() const { return fVerbose; };
-
- /** Public modifiers **/
- inline void SetVerbose(const Int_t& verbose) { fVerbose = verbose; };
-
- /** Histogramms **/
- TH1F* fh_chi2hit;
- TH2F* fh_chi2hit_plane;
-
- // Histogramms for the distance cuts
- TH1F* fDistLongX;
- TH1F* fDistLongY;
- TH1F* fDistShortX;
- TH1F* fDistShortY;
-
- TH1F* fDistLongBX;
- TH1F* fDistLongBY;
- TH1F* fDistShortBX;
- TH1F* fDistShortBY;
-
- TH1F* fDistY12;
-
- TH2F* fMomDistLongPrimaryX;
- TH2F* fMomDistLongPrimaryY;
- TH2F* fMomDistLongExtraX;
- TH2F* fMomDistLongExtraY;
-
- TH2F* fMomDistExtrapolPrimaryX;
- TH2F* fMomDistExtrapolPrimaryY;
- TH2F* fMomDistExtrapolExtraX;
- TH2F* fMomDistExtrapolExtraY;
-
- TH2F* fMomDistShortPrimaryX;
- TH2F* fMomDistShortPrimaryY;
- TH2F* fMomDistShortExtraX;
- TH2F* fMomDistShortExtraY;
-
- TH1F* fDistY;
- TH1F* fDistX;
-
- TH1F* fPlane1Ydens;
- TH1F* fPlane5Ydens;
- TH1F* fPlane9Ydens;
-
- TH1F* fSPlength;
- TH1F* fSPlengthMC;
-
- TH1F* fYat0;
- TH1F* fYat0MC;
-
- TH2F* fNoEvTime;
-
- TH1F* fh_SP_xDiff_MC;
- TH1F* fh_SP_yDiff_MC;
-
- TH1F* fh_SP_xDiff_nMC;
- TH1F* fh_SP_yDiff_nMC;
-
- TH1F *fUsedHitsPerPlane, *fUnUsedHitsPerPlane;
-
-
- std::map<Int_t, Int_t> fRUsedHits;
- std::map<Int_t, Int_t> fRUnUsedHits;
- std::map<Int_t, Int_t> fTotHits;
-
- /** Function for sorting **/
- static Bool_t CompareChi2TrdTrack(const CbmTrdTrack* a, const CbmTrdTrack* b)
- {
- return (a->GetChiSq() / static_cast<Double_t>(a->GetNDF()) < b->GetChiSq() / static_cast<Double_t>(b->GetNDF()));
- };
-
- ClassDef(CbmL1CATrdTrackFinderSA, 1);
-};
-
-
-#endif
diff --git a/reco/KF/obsolete/CbmL1TofMerger.cxx b/reco/KF/obsolete/CbmL1TofMerger.cxx
deleted file mode 100644
index 3f6343db2af2dca375dc462d2a4aeb7f44b82f74..0000000000000000000000000000000000000000
--- a/reco/KF/obsolete/CbmL1TofMerger.cxx
+++ /dev/null
@@ -1,259 +0,0 @@
-/* Copyright (C) 2006-2021 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Denis Bertini [committer] */
-
-// ------------------------------------------------------------------
-// ----- CbmL1TofMerger -----
-// ----- Created 24-01-2006 by D.Kresan -----
-// ------------------------------------------------------------------
-#include "CbmL1TofMerger.h"
-
-#include "CbmGlobalTrack.h"
-#include "CbmKFTrack.h"
-#include "CbmTofHit.h"
-#include "CbmTrdTrack.h"
-#include "FairRootManager.h"
-#include "TClonesArray.h"
-#include "TMath.h"
-
-#include <iostream>
-#include <map>
-#include <utility>
-
-using std::cout;
-using std::endl;
-using std::make_pair;
-using std::map;
-using std::pair;
-
-//___________________________________________________________________
-//
-// CbmL1TofMerger
-//
-// Concrete implementation of the global track - TOF hit merging
-// algorithm
-//
-
-
-// ------------------------------------------------------------------
-CbmL1TofMerger::CbmL1TofMerger() : fArrayTrdTrack(nullptr)
-{
- // Default constructor
-}
-// ------------------------------------------------------------------
-
-
-// ------------------------------------------------------------------
-CbmL1TofMerger::CbmL1TofMerger(Int_t) : fArrayTrdTrack(nullptr)
-{
- // Standard constructor
- fVerbose = 1;
-}
-// ------------------------------------------------------------------
-
-
-// ------------------------------------------------------------------
-CbmL1TofMerger::~CbmL1TofMerger()
-{
- // Destructor
-}
-// ------------------------------------------------------------------
-
-
-// ------------------------------------------------------------------
-void CbmL1TofMerger::Init()
-{
- // Initialisation
- FairRootManager* rootMgr = FairRootManager::Instance();
- if (nullptr == rootMgr) {
- cout << "-E- CbmL1TofMerger::Init(): "
- << "ROOT manager is not instantiated!" << endl;
- return;
- }
- fArrayTrdTrack = dynamic_cast<TClonesArray*>(rootMgr->GetObject("TrdTrack"));
- if (nullptr == fArrayTrdTrack) {
- cout << "-W- CbmL1TofMerger::Init: "
- << "no TRD track array" << endl;
- }
-}
-// ------------------------------------------------------------------
-
-
-// ------------------------------------------------------------------
-Int_t CbmL1TofMerger::DoMerge(TClonesArray* glbTracks, TClonesArray* tofHits)
-{
- // Implementation of the merging algorithm
- Int_t nMerged = 0;
-
- // Map from tof hit index to boolean flag
- map<Int_t, Bool_t> mapTofHitUsed;
- mapTofHitUsed.clear();
- // Map from tof hit index to chi2 value
- map<Int_t, Double_t> mapTofHitChi2;
- mapTofHitChi2.clear();
- // Map from tof hit index to track index
- map<Int_t, Int_t> mapTofHitTrack;
- mapTofHitTrack.clear();
- // Map from track index to the boolean flag
- map<Int_t, Bool_t> mapTrack;
- mapTrack.clear();
- for (Int_t iTrack = 0; iTrack < glbTracks->GetEntriesFast(); iTrack++) {
- mapTrack[iTrack] = kTRUE;
- }
- // Map from track-tof index to boolean flag
- map<pair<Int_t, Int_t>, Bool_t> mapForbidden;
- mapForbidden.clear();
-
- // Declare variables outside the loop
- CbmGlobalTrack* track;
- Int_t oldTrackIndex;
- CbmGlobalTrack* track2;
- Int_t trdTrackIndex;
- CbmTrdTrack* trdTrack;
- CbmKFTrack kfTrack;
- CbmTofHit* tofHit;
- Double_t zposTof;
- Double_t chi2;
- Double_t chi2min;
- Int_t indexOfClosest;
-
-
- while (mapTrack.size() > 0) {
-
- // Loop over global tracks
- for (Int_t iTrack = 0; iTrack < glbTracks->GetEntriesFast(); iTrack++) {
-
- // Skip if not in list
- if (mapTrack.find(iTrack) == mapTrack.end()) continue;
-
- // Get pointer to the global track
- track = dynamic_cast<CbmGlobalTrack*>(glbTracks->At(iTrack));
- if (nullptr == track) {
- mapTrack.erase(iTrack);
- continue;
- }
-
- // Skip if has no STS or TRD track
- if (track->GetStsTrackIndex() < 0 || track->GetTrdTrackIndex() < 0) {
- mapTrack.erase(iTrack);
- continue;
- }
-
- // Get TRD track
- trdTrackIndex = track->GetTrdTrackIndex();
- trdTrack = dynamic_cast<CbmTrdTrack*>(fArrayTrdTrack->At(trdTrackIndex));
- if (nullptr == trdTrack) {
- mapTrack.erase(iTrack);
- continue;
- }
-
- // Set track parameters
- kfTrack.SetTrackParam(*(const_cast<FairTrackParam*>(trdTrack->GetParamLast())));
- chi2min = 1e16;
- indexOfClosest = -1;
-
- // Loop over TOF hits
- for (Int_t iTof = 0; iTof < tofHits->GetEntriesFast(); iTof++) {
- // Check if pair is not forbidden
- if (mapForbidden[make_pair(iTrack, iTof)]) continue;
- // Get TOF hit
- tofHit = dynamic_cast<CbmTofHit*>(tofHits->At(iTof));
- if (nullptr == tofHit) continue;
- // Get z position of hit
- zposTof = tofHit->GetZ();
- // Extrapolate to current z-plane
- kfTrack.Extrapolate(zposTof);
- // Check for geometrical overlap
- if (kFALSE == Overlap(kfTrack, tofHit)) continue;
- // Get chi2 to hit
- chi2 = GetChi2ToHit(kfTrack, tofHit);
- // Find smallest chi2
- if (chi2 < chi2min) {
- chi2min = chi2;
- indexOfClosest = iTof;
- }
- } // Loop over TOF hits
-
- // Save index of TOF hit
- if (-1 != indexOfClosest) {
- // Check if already used
- if (mapTofHitUsed[indexOfClosest]) {
- // Check if this track is closer
- if (chi2min < mapTofHitChi2[indexOfClosest]) {
- // Force previous track to be reprocessed
- oldTrackIndex = mapTofHitTrack[indexOfClosest];
- track2 = dynamic_cast<CbmGlobalTrack*>(glbTracks->At(oldTrackIndex));
- track2->SetTofHitIndex(-1);
- mapTrack[oldTrackIndex] = kTRUE;
- nMerged -= 1;
- // Forbid this combination
- mapForbidden[make_pair(oldTrackIndex, indexOfClosest)] = kTRUE;
- // Attach hit to current track
- track->SetTofHitIndex(indexOfClosest);
- mapTofHitChi2[indexOfClosest] = chi2min;
- mapTofHitTrack[indexOfClosest] = iTrack;
- mapTrack.erase(iTrack);
- nMerged += 1;
- }
- else {
- // Forbid this combination
- mapForbidden[make_pair(iTrack, indexOfClosest)] = kTRUE;
- }
- }
- else {
- track->SetTofHitIndex(indexOfClosest);
- mapTofHitUsed[indexOfClosest] = kTRUE;
- mapTofHitChi2[indexOfClosest] = chi2min;
- mapTofHitTrack[indexOfClosest] = iTrack;
- mapTrack.erase(iTrack);
- nMerged += 1;
- }
- }
- else {
- mapTrack.erase(iTrack);
- }
-
- } // Loop over global tracks
- }
-
-
- return nMerged;
-}
-// ------------------------------------------------------------------
-
-
-// ------------------------------------------------------------------
-Bool_t CbmL1TofMerger::Overlap(CbmKFTrack& track, const CbmTofHit* tofHit)
-{
- // Check for geometrical overlap between track extrapolation
- // and TOF hit
- Double_t x1 = track.GetTrack()[0];
- Double_t x2 = tofHit->GetX();
- Double_t dx2 = tofHit->GetDx();
- Bool_t overlap_x = TMath::Abs(x1 - x2) <= (5 + 3 * dx2);
- Double_t y1 = track.GetTrack()[1];
- Double_t y2 = tofHit->GetY();
- Double_t dy2 = tofHit->GetDy();
- Bool_t overlap_y = TMath::Abs(y1 - y2) <= (5 + 3 * dy2);
- return (overlap_x && overlap_y);
-}
-// ------------------------------------------------------------------
-
-
-// ------------------------------------------------------------------
-Double_t CbmL1TofMerger::GetChi2ToHit(CbmKFTrack& track, const CbmTofHit* tofHit)
-{
- // Get chi2 from the track extrapolation to the TOF hit
- Double_t dx = track.GetTrack()[0] - tofHit->GetX();
- Double_t dy = track.GetTrack()[1] - tofHit->GetY();
- /* Double_t c0 = track.GetCovMatrix()[0] + tofHit->GetDx()*tofHit->GetDx();
- Double_t c1 = track.GetCovMatrix()[1];
- Double_t c2 = track.GetCovMatrix()[2] + tofHit->GetDy()*tofHit->GetDy();
- Double_t chi2 = 0.5*(dx*dx*c0-2*dx*dy*c1+dy*dy*c2)/(c0*c2-c1*c1);*/
- Double_t chi2 = TMath::Sqrt(dx * dx + dy * dy);
- return chi2;
-}
-// ------------------------------------------------------------------
-
-
-ClassImp(CbmL1TofMerger);
diff --git a/reco/KF/obsolete/CbmL1TofMerger.h b/reco/KF/obsolete/CbmL1TofMerger.h
deleted file mode 100644
index 306bc09bbb7c20ae9609f543e9be34be60a38081..0000000000000000000000000000000000000000
--- a/reco/KF/obsolete/CbmL1TofMerger.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/* Copyright (C) 2006-2010 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Denis Bertini [committer] */
-
-// ------------------------------------------------------------------
-// ----- CbmL1TofMerger -----
-// ----- Created 24-01-2006 by D.Kresan -----
-// ------------------------------------------------------------------
-#ifndef _CBML1TOFMERGER_
-#define _CBML1TOFMERGER_
-
-#include "CbmTofMerger.h"
-
-class TClonesArray;
-class CbmKFTrack;
-class CbmTofHit;
-class FairTrackParam;
-
-
-class CbmL1TofMerger : public CbmTofMerger {
- private:
- CbmL1TofMerger(const CbmL1TofMerger&); // CHECKME
- CbmL1TofMerger operator=(const CbmL1TofMerger&);
-
- private:
- TClonesArray* fArrayTrdTrack; // Array of TRD tracks
-
- Bool_t Overlap(CbmKFTrack& track, const CbmTofHit* tofHit);
- Double_t GetChi2ToHit(CbmKFTrack& track, const CbmTofHit* tofHit);
-
- public:
- CbmL1TofMerger();
- CbmL1TofMerger(Int_t verbose);
- ~CbmL1TofMerger();
-
- void Init();
- Int_t DoMerge(TClonesArray* glbTracks, TClonesArray* tofHits);
-
- ClassDef(CbmL1TofMerger, 1);
-};
-
-
-#endif
diff --git a/reco/KF/obsolete/CbmL1TrackMerger.cxx b/reco/KF/obsolete/CbmL1TrackMerger.cxx
deleted file mode 100644
index 35b1331f6e06012908b351762cff6516c6565f6b..0000000000000000000000000000000000000000
--- a/reco/KF/obsolete/CbmL1TrackMerger.cxx
+++ /dev/null
@@ -1,474 +0,0 @@
-/* Copyright (C) 2006-2021 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Denis Bertini [committer] */
-
-// ------------------------------------------------------------------
-// ----- CbmL1TrackMerger -----
-// ----- Created 2006-01-24 by D.Kresan -----
-// ------------------------------------------------------------------
-#include "CbmL1TrackMerger.h"
-
-#include "CbmGlobalTrack.h"
-#include "CbmKFTrack.h"
-#include "CbmStsTrack.h"
-#include "CbmTrackMatch.h"
-#include "CbmTrdTrack.h"
-#include "FairRootManager.h"
-#include "TClonesArray.h"
-#include "TH2F.h"
-#include "TMath.h"
-
-#include <iostream>
-#include <map>
-
-using std::cout;
-using std::endl;
-using std::map;
-
-//___________________________________________________________________
-//
-// CbmL1TrackMerger
-//
-// Concrete implementation of the STS-TRD track merging.
-// Two methods are availible:
-// 1) Merging based on the value of CbmTrdTrack::GetStsTrackIndex().
-// Selected by ::SetMethod(1). To be used for STS-based TRD track
-// finder
-// 2) Merging at the first TRD plane. Selected by ::SetMethod(2). To
-// be used for standalone TRD track finder
-//
-
-
-// ------------------------------------------------------------------
-CbmL1TrackMerger::CbmL1TrackMerger()
- : fMethod(1)
- , // Merging method: 1 - based on StsTrackIndex from TRD track
- fArrayStsTrackM(nullptr)
- , // Array of STS track matches
- fArrayTrdTrackM(nullptr)
- , // Array of TRD track matches
- fh_dx_true(nullptr)
- , // Control histogramm
- fh_dx_false(nullptr)
- , // Control histogramm
- fh_dy_true(nullptr)
- , // Control histogramm
- fh_dy_false(nullptr)
- , // Control histogramm
- fh_dtx_true(nullptr)
- , // Control histogramm
- fh_dtx_false(nullptr)
- , // Control histogramm
- fh_dty_true(nullptr)
- , // Control histogramm
- fh_dty_false(nullptr) // Control histogramm
-{
- // Default constructor
- fVerbose = 1;
- CreateHistogramms();
-}
-// ------------------------------------------------------------------
-
-
-// ------------------------------------------------------------------
-CbmL1TrackMerger::CbmL1TrackMerger(Int_t verbose)
- : fMethod(1)
- , // Merging method: 1 - based on StsTrackIndex from TRD track
- fArrayStsTrackM(nullptr)
- , // Array of STS track matches
- fArrayTrdTrackM(nullptr)
- , // Array of TRD track matches
- fh_dx_true(nullptr)
- , // Control histogramm
- fh_dx_false(nullptr)
- , // Control histogramm
- fh_dy_true(nullptr)
- , // Control histogramm
- fh_dy_false(nullptr)
- , // Control histogramm
- fh_dtx_true(nullptr)
- , // Control histogramm
- fh_dtx_false(nullptr)
- , // Control histogramm
- fh_dty_true(nullptr)
- , // Control histogramm
- fh_dty_false(nullptr) // Control histogramm
-{
- // Standard constructor
- fVerbose = verbose;
- CreateHistogramms();
-}
-// ------------------------------------------------------------------
-
-
-// ------------------------------------------------------------------
-CbmL1TrackMerger::~CbmL1TrackMerger()
-{
- // Destructor
-}
-// ------------------------------------------------------------------
-
-
-// ------------------------------------------------------------------
-void CbmL1TrackMerger::Init()
-{
- // Initialisation
- FairRootManager* rootMgr = FairRootManager::Instance();
- if (nullptr == rootMgr) {
- cout << "-E- CbmL1TrackMerger::Init : "
- << "FairRootManager is not instantiated!" << endl;
- return;
- }
- fArrayStsTrackM = dynamic_cast<TClonesArray*>(rootMgr->GetObject("StsTrackMatch"));
- if (nullptr == fArrayStsTrackM) {
- cout << "-W- CbmL1TrackMerger::Init : "
- << "no STS track match array" << endl;
- }
- fArrayTrdTrackM = dynamic_cast<TClonesArray*>(rootMgr->GetObject("TrdTrackMatch"));
- if (nullptr == fArrayTrdTrackM) {
- cout << "-W- CbmL1TrackMerger::Init : "
- << "no TRD track match array" << endl;
- }
-}
-// ------------------------------------------------------------------
-
-
-// ------------------------------------------------------------------
-Int_t CbmL1TrackMerger::DoMerge(TClonesArray* stsTracks, TClonesArray* trdTracks, TClonesArray* glbTracks)
-{
- // Implementation of the merging algorithm
- if (1 == fMethod) {
- return MergeSimple(stsTracks, trdTracks, glbTracks);
- }
- else if (2 == fMethod) {
- return MergeImPlane(stsTracks, trdTracks, glbTracks);
- }
- else {
- cout << "-E- CbmL1TrackMerger::DoMerge : "
- << "unknown method " << fMethod << endl;
- }
- return 0;
-}
-// ------------------------------------------------------------------
-
-
-// ------------------------------------------------------------------
-Int_t CbmL1TrackMerger::MergeSimple(TClonesArray* stsTracks, TClonesArray* trdTracks, TClonesArray* glbTracks)
-{
- // Simple merging algorithm. To be used for STS based TRD track
- // finding
- Int_t nGlb = 0;
-
- CbmTrdTrack* trdTrack = nullptr;
- CbmGlobalTrack* glbTrack = nullptr;
-
- map<Int_t, Int_t> mapStsTrackUsed;
-
- // Loop over TRD tracks, create corresponding global track
- // and attach STS track
- for (Int_t iTrdTrack = 0; iTrdTrack < trdTracks->GetEntriesFast(); iTrdTrack++) {
- // Get pointer to the TRD track
- trdTrack = dynamic_cast<CbmTrdTrack*>(trdTracks->At(iTrdTrack));
- if (nullptr == trdTrack) continue;
- // Create global track
- glbTrack = new ((*glbTracks)[nGlb]) CbmGlobalTrack();
- nGlb += 1;
- // Set STS and TRD track indices
- glbTrack->SetStsTrackIndex(trdTrack->GetPreviousTrackId());
- glbTrack->SetTrdTrackIndex(iTrdTrack);
- // Mark STS track as used
- mapStsTrackUsed[trdTrack->GetPreviousTrackId()] = kTRUE;
- if (fVerbose > 1) {
- cout << "-I- CbmL1TrackMerger::MergeSimple" << endl
- << " global track : " << nGlb - 1
- << " sts track : " << trdTrack->GetPreviousTrackId() << endl
- << " trd track : " << iTrdTrack << endl;
- }
- } // Loop over TRD tracks
-
- // Loop over STS tracks
- for (Int_t iSts = 0; iSts < stsTracks->GetEntriesFast(); iSts++) {
- // Skip, if already used
- if (mapStsTrackUsed[iSts]) continue;
- // Create global track
- glbTrack = new ((*glbTracks)[nGlb]) CbmGlobalTrack();
- nGlb += 1;
- glbTrack->SetStsTrackIndex(iSts);
- if (fVerbose > 1) {
- cout << "-I- CbmL1TrackMerger::MergeSimple" << endl
- << " global track : " << nGlb - 1 << " sts track : " << iSts
- << " trd track : " << -1 << endl;
- }
- }
-
- return nGlb;
-}
-// ------------------------------------------------------------------
-
-
-// ------------------------------------------------------------------
-Int_t CbmL1TrackMerger::MergeImPlane(TClonesArray* stsTracks, TClonesArray* trdTracks, TClonesArray* glbTracks)
-{
- // Real merging algorithm. To be used for standalone
- // TRD track finders
- if (!stsTracks || !trdTracks || !glbTracks) return 0;
- if (!fArrayStsTrackM || !fArrayTrdTrackM) return 0;
-
- CbmStsTrack* stsTrack;
- CbmKFTrack kfTrack;
- CbmTrdTrack* trdTrack;
- CbmGlobalTrack* glbTrack;
- CbmTrackMatch* stsTrackM;
- CbmTrackMatch* trdTrackM;
- Int_t nGlb = 0;
- Int_t nMerged = 0;
- Double_t dx;
- Double_t dy;
- Double_t dtx;
- Double_t dty;
- Double_t theta;
- Double_t chi2XY;
- Double_t dx_cut;
- Double_t dy_cut;
- Double_t dtx_cut;
-
- // Map from the TRD track index to the boolean flag
- map<Int_t, Bool_t> mapTrdTrackUsed;
-
- // Loop over STS tracks
- for (Int_t iStsTrack = 0; iStsTrack < stsTracks->GetEntriesFast(); iStsTrack++) {
- // Get pointer to the STS track and track match
- stsTrack = dynamic_cast<CbmStsTrack*>(stsTracks->At(iStsTrack));
- if (nullptr == stsTrack) continue;
- stsTrackM = dynamic_cast<CbmTrackMatch*>(fArrayStsTrackM->At(iStsTrack));
- if (nullptr == stsTrackM) continue;
-
- // Create global track
- new ((*glbTracks)[nGlb]) CbmGlobalTrack();
- glbTrack = dynamic_cast<CbmGlobalTrack*>(glbTracks->At(nGlb));
- if (nullptr == glbTrack) continue;
- nGlb += 1;
- // Set STS track index
- glbTrack->SetStsTrackIndex(iStsTrack);
- // Merge with TRD
- kfTrack.SetTrackParam(*stsTrack->GetParamLast());
- // Loop over TRD tracks
- Double_t minChi2XY = 1e16;
- Int_t indexOfClosest = -1;
- for (Int_t iTrdTrack = 0; iTrdTrack < trdTracks->GetEntriesFast(); iTrdTrack++) {
- // Skip if already merged
- if (mapTrdTrackUsed[iTrdTrack]) continue;
- // Get pointer to the TRD track and track match
- trdTrack = dynamic_cast<CbmTrdTrack*>(trdTracks->At(iTrdTrack));
- if (nullptr == trdTrack) continue;
- trdTrackM = dynamic_cast<CbmTrackMatch*>(fArrayTrdTrackM->At(iTrdTrack));
- if (nullptr == trdTrackM) continue;
- // Extrapolate STS track to the first plane of TRD track
- kfTrack.Extrapolate(trdTrack->GetParamFirst()->GetZ());
-
- // Fill histogramms
- Double_t tx = kfTrack.GetTrack()[2];
- Double_t ty = kfTrack.GetTrack()[3];
- dx = kfTrack.GetTrack()[0] - trdTrack->GetParamFirst()->GetX();
- dy = kfTrack.GetTrack()[1] - trdTrack->GetParamFirst()->GetY();
- dtx = tx - trdTrack->GetParamFirst()->GetTx();
- dty = ty - trdTrack->GetParamFirst()->GetTy();
- theta = 180. / TMath::Pi() * TMath::ACos(1. / TMath::Sqrt(1 + tx * tx + ty * ty));
- if (stsTrackM->GetMCTrackId() == trdTrackM->GetMCTrackId()) {
- fh_dx_true->Fill(dx, theta);
- }
- else {
- fh_dx_false->Fill(dx, theta);
- }
-
- // Cut on dx
- if (theta < 5) {
- dx_cut = 1;
- }
- else if (theta < 10) {
- dx_cut = 4;
- }
- else if (theta < 15) {
- dx_cut = 4;
- }
- else if (theta < 20) {
- dx_cut = 4;
- }
- else if (theta < 25) {
- dx_cut = 4;
- }
- else if (theta < 30) {
- dx_cut = 4;
- }
- else if (theta < 35) {
- dx_cut = 4;
- }
- else if (theta < 40) {
- dx_cut = 2;
- }
- else {
- dx_cut = 0.;
- }
- if (TMath::Abs(dx) > dx_cut) continue;
- // Fill histogramms
- if (stsTrackM->GetMCTrackId() == trdTrackM->GetMCTrackId()) {
- fh_dy_true->Fill(dy, theta);
- }
- else {
- fh_dy_false->Fill(dy, theta);
- }
-
- // Cut on dy
- if (theta < 5) {
- dy_cut = 1;
- }
- else if (theta < 10) {
- dy_cut = 2;
- }
- else if (theta < 15) {
- dy_cut = 2;
- }
- else if (theta < 20) {
- dy_cut = 3;
- }
- else if (theta < 25) {
- dy_cut = 3;
- }
- else if (theta < 30) {
- dy_cut = 3;
- }
- else if (theta < 35) {
- dy_cut = 3;
- }
- else {
- dy_cut = 0.;
- }
- if (TMath::Abs(dy) > dy_cut) continue;
- // Fill histogramms
- if (stsTrackM->GetMCTrackId() == trdTrackM->GetMCTrackId()) {
- fh_dtx_true->Fill(dtx, theta);
- }
- else {
- fh_dtx_false->Fill(dtx, theta);
- }
-
- // Cut on dtx
- if (theta < 10) {
- dtx_cut = 0.001;
- }
- else if (theta < 15) {
- dtx_cut = 0.002;
- }
- else if (theta < 20) {
- dtx_cut = 0.003;
- }
- else if (theta < 25) {
- dtx_cut = 0.004;
- }
- else if (theta < 30) {
- dtx_cut = 0.005;
- }
- else if (theta < 35) {
- dtx_cut = 0.013;
- }
- else {
- dtx_cut = 0.;
- }
- dtx_cut *= 10;
- if (TMath::Abs(dtx) > dtx_cut) continue;
- // Fill histogramms
- if (stsTrackM->GetMCTrackId() == trdTrackM->GetMCTrackId()) {
- fh_dty_true->Fill(dty, theta);
- }
- else {
- fh_dty_false->Fill(dty, theta);
- }
-
- if (TMath::Abs(dty) > dtx_cut) continue;
-
- // Get chi2
- chi2XY = GetChi2XY(kfTrack, const_cast<FairTrackParam*>(trdTrack->GetParamFirst()));
- // Choose the closest
- if (chi2XY < minChi2XY) {
- minChi2XY = chi2XY;
- indexOfClosest = iTrdTrack;
- }
- }
- if (indexOfClosest < 0) continue;
- // Attach TRD track
- glbTrack->SetTrdTrackIndex(indexOfClosest);
- mapTrdTrackUsed[indexOfClosest] = kTRUE;
- nMerged += 1;
- }
-
- // Loop over free TRD tracks
- for (Int_t iTrdTrack = 0; iTrdTrack < trdTracks->GetEntriesFast(); iTrdTrack++) {
- // Skip if already merged
- if (mapTrdTrackUsed[iTrdTrack]) continue;
- // Create global track
- new ((*glbTracks)[nGlb]) CbmGlobalTrack();
- glbTrack = dynamic_cast<CbmGlobalTrack*>(glbTracks->At(nGlb));
- if (nullptr == glbTrack) continue;
- nGlb += 1;
- // Set TRD track index
- glbTrack->SetTrdTrackIndex(iTrdTrack);
- }
-
- return nMerged;
-}
-// ------------------------------------------------------------------
-
-
-// ------------------------------------------------------------------
-Double_t CbmL1TrackMerger::GetChi2XY(CbmKFTrack& kfTrack, FairTrackParam* trackParam)
-{
- // Get the chi2 from track extrapolation to TRD track parameters
- Double_t dx = kfTrack.GetTrack()[0] - trackParam->GetX();
- Double_t dy = kfTrack.GetTrack()[1] - trackParam->GetY();
- Double_t c0 = kfTrack.GetCovMatrix()[0] + trackParam->GetCovariance(0, 0);
- Double_t c1 = kfTrack.GetCovMatrix()[1] + trackParam->GetCovariance(0, 1);
- Double_t c2 = kfTrack.GetCovMatrix()[2] + trackParam->GetCovariance(1, 1);
- Double_t chi2 = 0.5 * (dx * dx * c0 - 2 * dx * dy * c1 + dy * dy * c2) / (c0 * c2 - c1 * c1);
- // Double_t chi2 = TMath::Sqrt(dx*dx + dy*dy);
- return chi2;
-}
-// ------------------------------------------------------------------
-
-
-// ------------------------------------------------------------------
-void CbmL1TrackMerger::CreateHistogramms()
-{
- // Create control histogramms
- fh_dx_true = new TH2F("h_dx_true", "", 200, -10., 10., 9, 0., 45.);
- fh_dx_false = new TH2F("h_dx_false", "", 200, -10., 10., 9, 0., 45.);
-
- fh_dy_true = new TH2F("h_dy_true", "", 200, -10., 10., 9, 0., 45.);
- fh_dy_false = new TH2F("h_dy_false", "", 200, -10., 10., 9, 0., 45.);
-
- fh_dtx_true = new TH2F("h_dtx_true", "", 200, -0.1, 0.1, 9, 0., 45.);
- fh_dtx_false = new TH2F("h_dtx_false", "", 200, -0.1, 0.1, 9, 0., 45.);
-
- fh_dty_true = new TH2F("h_dty_true", "", 200, -0.1, 0.1, 9, 0., 45.);
- fh_dty_false = new TH2F("h_dty_false", "", 200, -0.1, 0.1, 9, 0., 45.);
-}
-// ------------------------------------------------------------------
-
-
-// ------------------------------------------------------------------
-void CbmL1TrackMerger::WriteHistogramms()
-{
- // Write control histogramms to the file
- fh_dx_true->Write();
- fh_dx_false->Write();
- fh_dy_true->Write();
- fh_dy_false->Write();
-
- fh_dtx_true->Write();
- fh_dtx_false->Write();
- fh_dty_true->Write();
- fh_dty_false->Write();
-}
-// ------------------------------------------------------------------
-
-
-ClassImp(CbmL1TrackMerger);
diff --git a/reco/KF/obsolete/CbmL1TrackMerger.h b/reco/KF/obsolete/CbmL1TrackMerger.h
deleted file mode 100644
index ec42c914da73af9e534c809fe2fd4a874f72a626..0000000000000000000000000000000000000000
--- a/reco/KF/obsolete/CbmL1TrackMerger.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/* Copyright (C) 2006-2010 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Denis Bertini [committer] */
-
-// ------------------------------------------------------------------
-// ----- CbmL1TrackMerger -----
-// ----- Created 2006-01-24 by D.Kresan -----
-// ------------------------------------------------------------------
-#ifndef _CBM_L1_TRACK_MERGER_
-#define _CBM_L1_TRACK_MERGER_
-
-#include "CbmTrackMerger.h"
-
-class TClonesArray;
-class CbmKFTrack;
-class FairTrackParam;
-class TH2F;
-
-
-class CbmL1TrackMerger : public CbmTrackMerger {
- private:
- CbmL1TrackMerger(const CbmL1TrackMerger&); // CHECKME
- CbmL1TrackMerger operator=(const CbmL1TrackMerger&);
-
- private:
- Int_t fMethod; // Merging method: 1 - based on StsTrackIndex from TRD track
- // 2 - merging of tracks at the first
- TClonesArray* fArrayStsTrackM; // Array of STS track matches
- TClonesArray* fArrayTrdTrackM; // Array of TRD track matches
- TH2F* fh_dx_true; // Control histogramm
- TH2F* fh_dx_false; // Control histogramm
- TH2F* fh_dy_true; // Control histogramm
- TH2F* fh_dy_false; // Control histogramm
- TH2F* fh_dtx_true; // Control histogramm
- TH2F* fh_dtx_false; // Control histogramm
- TH2F* fh_dty_true; // Control histogramm
- TH2F* fh_dty_false; // Control histogramm
-
- Double_t GetChi2XY(CbmKFTrack& kfTrack, FairTrackParam* trackParam);
- void CreateHistogramms();
- Int_t MergeSimple(TClonesArray* stsTracks, TClonesArray* trdTracks, TClonesArray* glbTracks);
- Int_t MergeImPlane(TClonesArray* stsTracks, TClonesArray* trdTracks, TClonesArray* glbTracks);
-
- public:
- CbmL1TrackMerger();
- CbmL1TrackMerger(Int_t verbose);
- virtual ~CbmL1TrackMerger();
-
- void Init();
- Int_t DoMerge(TClonesArray* stsTracks, TClonesArray* trdTracks, TClonesArray* glbTracks);
- void WriteHistogramms();
-
- inline Int_t GetVerbose() const { return fVerbose; }
- inline Int_t GetMethod() const { return fMethod; }
-
- inline void SetVerbose(Int_t verbose) { fVerbose = verbose; }
- inline void SetMethod(Int_t method) { fMethod = method; }
-
- ClassDef(CbmL1TrackMerger, 1);
-};
-
-
-#endif
diff --git a/reco/KF/obsolete/CbmL1TrdHit.h b/reco/KF/obsolete/CbmL1TrdHit.h
deleted file mode 100644
index cf980b6ac928198291f5f85040f2c806d1a88b90..0000000000000000000000000000000000000000
--- a/reco/KF/obsolete/CbmL1TrdHit.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/* Copyright (C) 2006 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Ivan Kisel, Sergey Gorbunov, Denis Bertini [committer] */
-
-/*
- *====================================================================
- *
- * CBM Level 1 Reconstruction
- *
- * Authors: I.Kisel, S.Gorbunov
- *
- * e-mail : ikisel@kip.uni-heidelberg.de
- *
- *====================================================================
- *
- * TRD hit description for L1
- *
- *====================================================================
- */
-
-#ifndef _CbmL1TrdHit_h_
-#define _CbmL1TrdHit_h_
-
-struct CbmL1TrdHit //:public CbmL1KFUMeasurement
-{
-
- // hit information
-
- int iStation; // TRD station
-
- // Monte Carlo information
-
- int MC_Point;
-
- static bool compareStation(const CbmL1TrdHit& a, const CbmL1TrdHit& b) { return (a.iStation < b.iStation); }
-};
-
-#endif
diff --git a/reco/KF/obsolete/CbmL1TrdTrackFinderSts.cxx b/reco/KF/obsolete/CbmL1TrdTrackFinderSts.cxx
deleted file mode 100644
index 5ded92782845224b34af76e84d59b664a05d2b39..0000000000000000000000000000000000000000
--- a/reco/KF/obsolete/CbmL1TrdTrackFinderSts.cxx
+++ /dev/null
@@ -1,955 +0,0 @@
-/* Copyright (C) 2006-2021 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Denis Bertini [committer], Sergey Gorbunov */
-
-// -----------------------------------------------------------------------
-// ----- CbmL1TrdTrackFinderSts -----
-// ----- Created 6/12/05 by D. Kresan -----
-// -----------------------------------------------------------------------
-
-#include "CbmL1TrdTrackFinderSts.h"
-
-#include "CbmKFTrack.h"
-#include "CbmKFTrdHit.h"
-#include "CbmStsTrack.h"
-#include "CbmTrackMatch.h"
-#include "CbmTrdHit.h"
-#include "CbmTrdPoint.h"
-#include "CbmTrdTrack.h"
-#include "FairBaseParSet.h"
-#include "FairDetector.h"
-#include "FairRootManager.h"
-#include "FairRunAna.h"
-#include "FairRuntimeDb.h"
-#include "L1Def.h"
-#include "TArc.h"
-#include "TCanvas.h"
-#include "TClonesArray.h"
-#include "TGraph.h"
-#include "TH1F.h"
-#include "TH2F.h"
-#include "TLine.h"
-#include "TMath.h"
-
-#include <iostream>
-#include <map>
-#include <vector>
-
-using std::cout;
-using std::endl;
-using std::map;
-using std::vector;
-
-
-//________________________________________________________________________
-//
-// CbmL1TrdTrackFinderSts
-//
-// Engine for track finding in the TRD. Based on the track extrapolation
-// from the STS and further track following.
-//
-
-
-// -----------------------------------------------------------------------
-CbmL1TrdTrackFinderSts::CbmL1TrdTrackFinderSts()
- : fEvents(0)
- , // Number of events processed
- fVerbose(1)
- , // Verbosity level
- fArrayTrdPoint(NULL)
- , // Array of TRD points
- fArrayTrdHit(0)
- , // Array of TRD hits
- fArrayStsTrack(NULL)
- , // Array of STS tracks
- fArrayStsTrackM(NULL)
- , // Array of STS tracks
- fArrayKFTrdHit(new TClonesArray("CbmKFTrdHit"))
- , // Array of KF TRD hits
- fvTrdTrack()
- , fArrayTrdTrack(NULL)
- , // Output Array of TRD tracks
- fPid(211)
- , // PID assumption
- fNoTrdStations(0)
- , // Number of TRD stations
- fNoTrdPerStation(0)
- , // Number of TRD layers per station
- fmapHitUsed()
- , fh_chi2hit(0)
- , // Control histogramm
- fh_chi2hit_plane(0)
- , // Control histogramm
- fh_resx_plane_true(0)
- , // Control histogramm
- fh_resy_plane_true(0)
- , // Control histogramm
- fh_resx_plane_fake(0)
- , // Control histogramm
- fh_resy_plane_fake(0)
- , // Control histogramm
- fh_resx_mom_true(0)
- , // Control histogramm
- fh_resy_mom_true(0)
- , // Control histogramm
- fh_pullx_plane_true(0)
- , // Control histogramm
- fh_pully_plane_true(0)
- , // Control histogramm
- fh_pullx_plane_fake(0)
- , // Control histogramm
- fh_pully_plane_fake(0)
- , // Control histogramm
- fLostTracks()
-{
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-CbmL1TrdTrackFinderSts::CbmL1TrdTrackFinderSts(Int_t verbose)
- : fEvents(0)
- , // Number of events processed
- fVerbose(verbose)
- , // Verbosity level
- fArrayTrdPoint(NULL)
- , // Array of TRD points
- fArrayTrdHit(0)
- , // Array of TRD hits
- fArrayStsTrack(NULL)
- , // Array of STS tracks
- fArrayStsTrackM(NULL)
- , // Array of STS tracks
- fArrayKFTrdHit(new TClonesArray("CbmKFTrdHit"))
- , // Array of KF TRD hits
- fvTrdTrack()
- , fArrayTrdTrack(NULL)
- , // Output Array of TRD tracks
- fPid(211)
- , // PID assumption
- fNoTrdStations(0)
- , // Number of TRD stations
- fNoTrdPerStation(0)
- , // Number of TRD layers per station
- fmapHitUsed()
- , fh_chi2hit(0)
- , // Control histogramm
- fh_chi2hit_plane(0)
- , // Control histogramm
- fh_resx_plane_true(0)
- , // Control histogramm
- fh_resy_plane_true(0)
- , // Control histogramm
- fh_resx_plane_fake(0)
- , // Control histogramm
- fh_resy_plane_fake(0)
- , // Control histogramm
- fh_resx_mom_true(0)
- , // Control histogramm
- fh_resy_mom_true(0)
- , // Control histogramm
- fh_pullx_plane_true(0)
- , // Control histogramm
- fh_pully_plane_true(0)
- , // Control histogramm
- fh_pullx_plane_fake(0)
- , // Control histogramm
- fh_pully_plane_fake(0)
- , // Control histogramm
- fLostTracks()
-{
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-CbmL1TrdTrackFinderSts::~CbmL1TrdTrackFinderSts()
-{
- // Destructor
- if (fArrayKFTrdHit) fArrayKFTrdHit->Delete();
- delete fArrayKFTrdHit;
- // why delete the trdtrack array? This pointer
- // is passed from CbmTrdFindTracks and is registered with the iomanager...
- // should be not our business to delete the TClonesArray pointer
- if (fArrayTrdTrack) fArrayTrdTrack->Delete();
- // delete fArrayTrdTrack;
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-void CbmL1TrdTrackFinderSts::Init()
-{
- // Initialisation of the algorithm
-
- // Create histogramms
- CreateHistogramms();
- // Activate data branches
- DataBranches();
- // Determine the TRD layout
- TrdLayout();
- // fNoTrdStations = 3;
- // fNoTrdPerStation = 4;
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-Int_t CbmL1TrdTrackFinderSts::DoFind(TClonesArray* hitArray, TClonesArray* trackArray)
-{
- // Implementation of the track finding algorithm
- if (NULL == hitArray) {
- return 0;
- }
- fArrayTrdHit = hitArray;
- fArrayTrdTrack = trackArray;
-
- fmapHitUsed.clear();
- fLostTracks.clear();
-
- // Sort the TRD hits by plane number
- SortTrdHits();
-
- // Main part of algorithm
- // Follow the track in TRD
-
- Process();
-
- Int_t nTrdTracks = fArrayTrdTrack->GetEntriesFast();
-
- // Event output
- if (fVerbose > 0) {
- cout << "---------------------------------------" << endl
- << "-I- CbmL1TrdTrackFinderSts -I-" << endl
- << "-I- Event summary -I-" << endl
- << "-I- STS tracks : " << fArrayStsTrack->GetEntriesFast() << endl
- << "-I- TRD tracks found : " << nTrdTracks << endl
- << "-I- TRD tracks lost : " << fLostTracks.size() << endl
- << "---------------------------------------" << endl
- << endl;
- }
- else {
- cout << "-I- CbmL1TrdTrackFinderSts::DoFind : " << nTrdTracks << " TRD tracks found." << endl;
- }
-
- // Clear array of KF trd hits
- fArrayKFTrdHit->Clear();
-
- // Increment number of events
- fEvents += 1;
-
- // control output
- cout << "-I- CbmL1TrdTrackFinder : " << fEvents << " events processed" << endl;
-
- // Return number of found TRD tracks
- return nTrdTracks;
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-void CbmL1TrdTrackFinderSts::Process()
-{
- // Create TRD tracks from STS tracks, process them throug all stations
- // and move to the output array
-
- /* new TCanvas("c1", "", 10, 10, 800, 800);
- Int_t n;
- Double_t x[10000], y[10000];
- Int_t index;
- CbmTrdPoint *pt;
- TVector3 pos;
- for(Int_t i = 0; i < fNoTrdHits[0]; i++) {
- index = fTrdHitIndex[0][i];
- pt = (CbmTrdPoint*) fArrayTrdPoint->At(index);
- if(NULL == pt) continue;
- pt->Position(pos);
- x[n] = pos.X();
- y[n] = pos.Y();
- n += 1;
- }
- TGraph *gr = new TGraph(n, x, y);
- gr->SetMarkerStyle(24);
- gr->SetMarkerColor(4);
- gr->SetMarkerSize(0.5);
- gr->SetTitle("first layer");
- gr->Draw("AP");
- gr->GetHistogram()->GetXaxis()->SetRangeUser(0., 273.);
- gr->GetHistogram()->GetXaxis()->SetTitle("x (cm)");
- gr->GetHistogram()->GetYaxis()->SetRangeUser(0., 273.);
- gr->GetHistogram()->GetYaxis()->SetTitle("y (cm)");*/
-
-
- Sts2Trd(0., 1e16, 0., 1e16);
-
- ProcessAllStations();
- // RemoveFakes();
- MoveOut();
-
- /*
- Sts2Trd(0., 1.,
- 0., 1e16);
- ProcessAllStations();
-// RemoveFakes();
- MoveOut();*/
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-void CbmL1TrdTrackFinderSts::Sts2Trd(Double_t pmin, Double_t pmax, Double_t chi2min, Double_t chi2max)
-{
- // Create TRD track from each STS track, that fullfill the selection
- // criteria
-
- Int_t nStsTrack = fArrayStsTrack->GetEntriesFast();
- CbmStsTrack* stsTrack = NULL;
- CbmTrdTrack* trdTrack = NULL;
- /* Double_t mom;
- Double_t chi2;*/
- // Loop over STS tracks
- for (Int_t iStsTrack = 0; iStsTrack < nStsTrack; iStsTrack++) {
- // Get pointer to the STS track
- stsTrack = L1_DYNAMIC_CAST<CbmStsTrack*>(fArrayStsTrack->At(iStsTrack));
- if (NULL == stsTrack) continue;
- /*
- // Cut on momentum
- mom = 1./TMath::Abs(stsTrack->GetParamLast()->GetQp());
- if(mom < pmin || mom >= pmax) continue;
- // Cut on chi2
- chi2 = stsTrack->GetChi2() / (Double_t)stsTrack->GetNDF();
- if(chi2 < chi2min || chi2 >= chi2max) continue;
-*/
- // Create TRD track
- trdTrack = new CbmTrdTrack();
- // Copy track parameters at plane of last hit
- trdTrack->SetParamLast(stsTrack->GetParamLast());
- // Copy chi2
- trdTrack->SetChiSq(stsTrack->GetChiSq());
- trdTrack->SetNDF(stsTrack->GetNDF());
- // Set sts track index
- trdTrack->SetPreviousTrackId(iStsTrack);
- // Add it to the array
- fvTrdTrack.push_back(trdTrack);
- // Control output
- if (fVerbose > 1) {
- cout << "TRD track created from STS track " << iStsTrack << endl;
- }
- }
- // sort(fvTrdTrack.begin(), fvTrdTrack.end(), CbmTrdTrack::CompareMomentum);
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-void CbmL1TrdTrackFinderSts::ProcessAllStations()
-{
- // Process all tracks through all stations
-
- // Loop over tracks
- for (Int_t station = 0; station < fNoTrdStations; station++) {
- vector<CbmTrdTrack*>::iterator iter;
- int itr = 0;
- for (iter = fvTrdTrack.begin(); iter != fvTrdTrack.end(); iter++) {
- // Attach hits to track
- ProcessStation(*iter, station);
- // Update track
- UpdateTrack(station, *iter);
- itr++;
- }
- Clear();
- if (fVerbose > 0) {
- cout << "track candidates: " << fvTrdTrack.size() << "." << endl;
- }
- }
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-void CbmL1TrdTrackFinderSts::MoveOut()
-{
- // Move the tracks from temporary array to the output array
- vector<CbmTrdTrack*>::iterator iter;
- CbmTrdTrack* track;
- Int_t nOut = fArrayTrdTrack->GetEntriesFast();
- for (iter = fvTrdTrack.begin(); iter != fvTrdTrack.end(); iter++) {
- track = *iter;
- if (0 == track->GetFlag()) {
- new ((*fArrayTrdTrack)[nOut]) CbmTrdTrack(*track);
- nOut += 1;
- }
- delete track;
- }
- fvTrdTrack.clear();
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-void CbmL1TrdTrackFinderSts::ProcessStation(CbmTrdTrack* pTrack, const Int_t& station)
-{
- // Extrapolate track parameters to the layers of current station,
- // and pick up the closest hits
-
- // Track parameters
-
- CbmKFTrack kfTrack;
- kfTrack.SetTrackParam(*(const_cast<FairTrackParam*>(pTrack->GetParamLast())));
- kfTrack.SetPID(fPid);
- Double_t qp0 = pTrack->GetParamLast()->GetQp();
- Double_t* T = kfTrack.GetTrack();
-
- // Declare variables outside the loop
- Int_t plane = 0;
- Double_t ze = 0.;
- Int_t hitIndex = 0;
- CbmTrdHit* pHit = NULL;
- Double_t chi2hit = 0;
-
- Int_t indexOfClosest;
- Double_t minChi2;
- // CbmTrdHit* closestHit = 0;
- Int_t pointIndex;
- CbmTrdPoint* trdPoint;
- TVector3 pos;
-
- Int_t stsTrackIndex = pTrack->GetPreviousTrackId();
- if (stsTrackIndex < 0) {
- Fatal("ProcessStation", "Invalid track index");
- }
- CbmTrackMatch* stsM = L1_DYNAMIC_CAST<CbmTrackMatch*>(fArrayStsTrackM->At(stsTrackIndex));
- Int_t trackID = stsM->GetMCTrackId();
-
- // Loop over layers in this station
- for (Int_t iLayer = 0; iLayer < fNoTrdPerStation; iLayer++) {
-
- if (pTrack->GetFlag()) {
- return;
- }
- // Plane number
- plane = station * fNoTrdPerStation + iLayer;
- // Skip if no TRD hits
- if (fNoTrdHits[plane] < 1) continue;
- // Get z coordinate of plane
- ze = (L1_DYNAMIC_CAST<CbmTrdHit*>(fArrayTrdHit->At(fTrdHitIndex[plane][0])))->GetZ();
- // Extrapolate to the plane
- kfTrack.Extrapolate(ze, &qp0);
-
- minChi2 = 1e16;
- indexOfClosest = -1;
-
- // Loop over TRD hits in this plane
- for (Int_t iHit = 0; iHit < fNoTrdHits[plane]; iHit++) {
-
- // Get hit index
- hitIndex = fTrdHitIndex[plane][iHit];
- // If the hit is used, skip
- if (fmapHitUsed[hitIndex]) continue;
- // Get pointer to the hit
- pHit = L1_DYNAMIC_CAST<CbmTrdHit*>(fArrayTrdHit->At(hitIndex));
- // Get MC point
- pointIndex = pHit->GetRefId();
- trdPoint = L1_DYNAMIC_CAST<CbmTrdPoint*>(fArrayTrdPoint->At(pointIndex));
- trdPoint->Position(pos);
-
- Double_t c1 = kfTrack.GetCovMatrix()[0];
- Double_t c2 = kfTrack.GetCovMatrix()[2];
- if (finite(c1) && c1 > 1.e-10)
- c1 = (T[0] - pos.X()) / TMath::Sqrt(c1);
- else
- c1 = 100;
- if (finite(c2) && c2 > 1.e-10)
- c2 = (T[1] - pos.Y()) / TMath::Sqrt(c2);
- else
- c2 = 0;
-
- if (trdPoint->GetTrackID() == trackID) {
- fh_resx_plane_true->Fill(T[0] - pos.X(), plane);
- fh_resy_plane_true->Fill(T[1] - pos.Y(), plane);
- fh_pullx_plane_true->Fill(c1, plane);
- fh_pully_plane_true->Fill(c2, plane);
- /* if(0==plane && kfTrack.GetTrack()[0]>0 && kfTrack.GetTrack()[1]>0) {
- TArc *arc = new TArc(kfTrack.GetTrack()[0], kfTrack.GetTrack()[1], TMath::Max(TMath::Sqrt(kfTrack.GetCovMatrix()[0]),
- TMath::Sqrt(kfTrack.GetCovMatrix()[2])));
- arc->SetLineColor(2);
- arc->Draw();
- TLine *line = new TLine(kfTrack.GetTrack()[0], kfTrack.GetTrack()[1], pos.X(), pos.Y());
- line->Draw();
-
- fh_resx_mom_true->Fill(kfTrack.GetTrack()[0]-pos.X(), 1./TMath::Abs(qp0));
- fh_resy_mom_true->Fill(kfTrack.GetTrack()[1]-pos.Y(), 1./TMath::Abs(qp0));
- }*/
- }
- else {
-
- fh_resx_plane_fake->Fill(T[0] - pos.X(), plane);
- fh_resy_plane_fake->Fill(T[1] - pos.Y(), plane);
- fh_pullx_plane_fake->Fill(c1, plane);
- fh_pully_plane_fake->Fill(c2, plane);
- }
- // Check for geometrical overlap
- if (kFALSE == Overlap(kfTrack, pHit)) {
- if (trdPoint->GetTrackID() == trackID) {
- if (fVerbose > 1) {
- cout << "-W- Lost true hit: plane:" << plane << " track: (" << T[0] << ", " << T[1] << ") ("
- << TMath::Sqrt(TMath::Abs(kfTrack.GetCovMatrix()[0])) << ", "
- << TMath::Sqrt(TMath::Abs(kfTrack.GetCovMatrix()[2])) << "), hit: (" << pHit->GetX() << ", "
- << pHit->GetY() << ") (" << pHit->GetDx() << ", " << pHit->GetDy() << "), point: (" << pos.X()
- << ", " << pos.Y() << ")" << endl;
- }
- fLostTracks[trackID] = kTRUE;
- }
-
- continue;
- }
- // Calculate normalised distance to hit
- chi2hit = GetChi2Hit(kfTrack, pHit);
- // Fill histogramms
- fh_chi2hit->Fill(chi2hit);
- fh_chi2hit_plane->Fill(chi2hit, plane);
- // Take the smallest chi2
- if (chi2hit < minChi2) {
- minChi2 = chi2hit;
- indexOfClosest = hitIndex;
- // closestHit = pHit;
- }
- } // Loop over TRD hits
-
- // Add hit to the track
- if (indexOfClosest != -1) {
- pTrack->AddHit(indexOfClosest, kTRDHIT);
- }
- else {
- pTrack->SetFlag(1);
- }
- } // Loop over layers
- // pTrack->SortHits();
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-void CbmL1TrdTrackFinderSts::UpdateTrack(Int_t station, CbmTrdTrack* pTrack)
-{
- // Update track parameters using Kalman Filter
-
- // Get number of hits
- Int_t nHits = pTrack->GetNofHits();
- if (nHits < static_cast<Int_t>((station + 1) * fNoTrdPerStation)) {
- pTrack->SetFlag(1);
- return;
- }
- // Kalman filter track
- CbmKFTrack kfTrack;
- kfTrack.SetTrackParam(*(const_cast<FairTrackParam*>(pTrack->GetParamLast())));
- kfTrack.GetRefChi2() = pTrack->GetChiSq();
- kfTrack.GetRefNDF() = pTrack->GetNDF();
- kfTrack.SetPID(fPid);
- // Loop over hits
- Int_t hitIndex = 0;
- CbmTrdHit* pHit = NULL;
- CbmKFTrdHit* pKFHit = NULL;
- Double_t qp0 = pTrack->GetParamLast()->GetQp();
- for (Int_t iHit = static_cast<Int_t>(station * fNoTrdPerStation); iHit < nHits; iHit++) {
- // Get hit index
- hitIndex = pTrack->GetHitIndex(iHit);
- // Get pointer to the hit
- pHit = L1_DYNAMIC_CAST<CbmTrdHit*>(fArrayTrdHit->At(hitIndex));
- // Extrapolate to this hit
- kfTrack.Extrapolate(pHit->GetZ());
- // Get KF TRD hit
- pKFHit = L1_DYNAMIC_CAST<CbmKFTrdHit*>(fArrayKFTrdHit->At(hitIndex));
- // Add measurement
- pKFHit->Filter(kfTrack, kTRUE, qp0);
- } // Loop over hits
- // Set track parameters
- kfTrack.GetTrackParam(*(const_cast<FairTrackParam*>(pTrack->GetParamLast())));
- pTrack->SetChiSq(kfTrack.GetRefChi2());
- pTrack->SetNDF(kfTrack.GetRefNDF());
- if (station == (fNoTrdStations - 1)) {
- if (pTrack->GetChiSq() / static_cast<Double_t>(pTrack->GetNDF()) > 100) pTrack->SetFlag(1);
- }
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-void CbmL1TrdTrackFinderSts::Clear(const Option_t* a)
-{
- // Delete bad tracks from track array
- CbmTrdTrack* track;
- for (vector<CbmTrdTrack*>::iterator iter = fvTrdTrack.begin(); iter != fvTrdTrack.end(); iter++) {
- track = *iter;
- if (0 != track->GetFlag()) {
- fvTrdTrack.erase(iter);
- iter--;
- delete track;
- }
- }
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-void CbmL1TrdTrackFinderSts::RemoveFakes()
-{
- // Remove ghost tracks from the track candidate array. Among two
- // tracks with common hits, priority has one with smaller chi2.
-
- /** Map from sts track index to boolean flag **/
- map<Int_t, Bool_t> mapStsTrackUsed;
-
- // Sort found tracks by chi2
- sort(fvTrdTrack.begin(), fvTrdTrack.end(), CompareChi2);
-
- Int_t n_false;
-
- // Loop over sorted tracks
- CbmTrdTrack* track;
- Int_t nHits = 0;
- Int_t hitIndex = 0;
- vector<CbmTrdTrack*>::iterator iter;
- for (iter = fvTrdTrack.begin(); iter != fvTrdTrack.end(); iter++) {
- // Pointer to the track
- track = *iter;
- if (track->GetFlag()) {
- // fvTrdTrack.erase(iter);
- // delete track;
- continue;
- }
-
- // Loop over hits of this track, check if they are already
- // attached
- nHits = track->GetNofHits();
- n_false = 0;
- for (Int_t iHit = 0; iHit < nHits; iHit++) {
- // Get hit index
- hitIndex = track->GetHitIndex(iHit);
- // Check flag
- if (fmapHitUsed[hitIndex]) {
- n_false += 1;
- }
- } // Loop over hits
-
- // if((Double_t)n_false/(Double_t)nHits > 0.3) {
- if (n_false > 0) {
- track->SetFlag(1);
- }
-
- if (mapStsTrackUsed[track->GetPreviousTrackId()]) {
- track->SetFlag(1);
- }
-
- // Skip the fake tracks
- if (track->GetFlag()) {
- // fvTrdTrack.erase(iter);
- // delete track;
- continue;
- }
-
- // Mark hits as attached
- for (Int_t iHit = 0; iHit < nHits; iHit++) {
- // Get hit index
- hitIndex = track->GetHitIndex(iHit);
- // Set flag
- fmapHitUsed[hitIndex] = kTRUE;
- } // Loop over hits
-
- mapStsTrackUsed[track->GetPreviousTrackId()] = kTRUE;
- } // Loop over tracks
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-Bool_t CbmL1TrdTrackFinderSts::Overlap(CbmKFTrack& track, CbmTrdHit* pHit)
-{
- // Check for geometrical overlap between track extrapolation and hit
- if (track.GetCovMatrix()[0] > 100) {
- return kFALSE;
- }
- if (track.GetCovMatrix()[2] > 100) {
- return kFALSE;
- }
-
- Bool_t overlap;
- if (pHit->GetDx() < 1e-9 && pHit->GetDy() < 1e-9) {
- /* Double_t x1 = track.GetTrack()[0];
- Double_t dx1 = TMath::Sqrt(track.GetCovMatrix()[0]);
- Double_t x2 = pHit->GetX();
- Bool_t overlap_x = ( ((x1+10*dx1) >= x2) &&
- ((x1-10*dx1) <= x2) );
- Double_t y1 = track.GetTrack()[1];
- Double_t dy1 = TMath::Sqrt(track.GetCovMatrix()[2]);
- Double_t y2 = pHit->GetY();
- Bool_t overlap_y = ( ((y1+10*dy1) >= y2) &&
- ((y1-10*dy1) <= y2) );
- overlap = overlap_x && overlap_y;*/
- Double_t x1 = track.GetTrack()[0];
- Double_t x2 = pHit->GetX();
- Bool_t overlap_x = TMath::Abs(x1 - x2) < 7;
- Double_t y1 = track.GetTrack()[1];
- Double_t y2 = pHit->GetY();
- Bool_t overlap_y = TMath::Abs(y1 - y2) < 7;
- overlap = overlap_x && overlap_y;
- }
- else {
- /* Double_t x1 = track.GetTrack()[0];
- Double_t dx1 = TMath::Sqrt(track.GetCovMatrix()[0]);
- Double_t x2 = pHit->GetX();
- Double_t dx2 = pHit->GetDx() * 1e-4;
- Bool_t overlap_x1 = ((x1+5*dx1) <= (x2+3*dx2)) &&
- ((x1+5*dx1) >= (x2-3*dx2));
- Bool_t overlap_x2 = ((x1-5*dx1) <= (x2+3*dx2)) &&
- ((x1-5*dx1) >= (x2-3*dx2));
- Bool_t overlap_x3 = ((x1+5*dx1) >= (x2+3*dx2)) &&
- ((x1-5*dx1) <= (x2-3*dx2));
- Bool_t overlap_x = overlap_x1 || overlap_x2 || overlap_x3;
- Double_t y1 = track.GetTrack()[1];
- Double_t dy1 = TMath::Sqrt(track.GetCovMatrix()[2]);
- Double_t y2 = pHit->GetY();
- Double_t dy2 = pHit->GetDy() * 1e-4;
- Bool_t overlap_y1 = ((y1+5*dy1) <= (y2+3*dy2)) &&
- ((y1+5*dy1) >= (y2-3*dy2));
- Bool_t overlap_y2 = ((y1-5*dy1) <= (y2+3*dy2)) &&
- ((y1-5*dy1) >= (y2-3*dy2));
- Bool_t overlap_y3 = ((y1+5*dy1) >= (y2+3*dy2)) &&
- ((y1-5*dy1) <= (y2-3*dy2));
- Bool_t overlap_y = overlap_y1 || overlap_y2 || overlap_y3;
- overlap = overlap_x && overlap_y;*/
- Double_t x1 = track.GetTrack()[0];
- Double_t x2 = pHit->GetX();
- Double_t dx2 = pHit->GetDx();
- Bool_t overlap_x = TMath::Abs(x1 - x2) <= (1.117 * 3 + 3 * dx2);
- Double_t y1 = track.GetTrack()[1];
- Double_t y2 = pHit->GetY();
- Double_t dy2 = pHit->GetDy();
- Bool_t overlap_y = TMath::Abs(y1 - y2) <= (1.314 * 3 + 3 * dy2);
- overlap = overlap_x && overlap_y;
- }
- return overlap;
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-Double_t CbmL1TrdTrackFinderSts::GetChi2Hit(CbmKFTrack& track, CbmTrdHit* pHit)
-{
- // Get chi2 from track extrapolation to hit
- Double_t chi2 = 0.;
- if (pHit->GetDx() < 1e-14 && pHit->GetDx() > pHit->GetDy() && pHit->GetDy() < 1e-14) {
- Double_t dx = track.GetTrack()[0] - pHit->GetX();
- Double_t dy = track.GetTrack()[1] - pHit->GetY();
- Double_t c0 = track.GetCovMatrix()[0];
- Double_t c1 = track.GetCovMatrix()[1];
- Double_t c2 = track.GetCovMatrix()[2];
- chi2 = 0.5 * (dx * dx * c0 - 2 * dx * dy * c1 + dy * dy * c2) / (c0 * c2 - c1 * c1);
- }
- else if (pHit->GetDx() < pHit->GetDy()) {
- Double_t dx = track.GetTrack()[0] - pHit->GetX();
- Double_t c0 = track.GetCovMatrix()[0] + pHit->GetDx() * pHit->GetDx();
- chi2 = dx * dx / c0;
- }
- else {
- Double_t dy = track.GetTrack()[1] - pHit->GetY();
- Double_t c2 = track.GetCovMatrix()[2] + pHit->GetDy() * pHit->GetDy();
- chi2 = dy * dy / c2;
- }
- return chi2;
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-void CbmL1TrdTrackFinderSts::CreateHistogramms()
-{
- // Create control histogramms
-
- // Normalized distance to hit
- fh_chi2hit = new TH1F("h_chi2hit", "Normalized distance to hit", 500, 0., 50.);
- fh_chi2hit_plane =
- new TH2F("h_chi2hit_plane", "Normalized distance to hit vs. plane number", 500, 0., 50., 12, 0., 12.);
-
- fh_resx_plane_true = new TH2F("h_resx_plane_true", "", 200, -10., 10., 12, 0., 12.);
- fh_resy_plane_true = new TH2F("h_resy_plane_true", "", 200, -10., 10., 12, 0., 12.);
- fh_resx_plane_fake = new TH2F("h_resx_plane_fake", "", 200, -10., 10., 12, 0., 12.);
- fh_resy_plane_fake = new TH2F("h_resy_plane_fake", "", 200, -10., 10., 12, 0., 12.);
- fh_resx_mom_true = new TH2F("h_resx_mom_true", "", 200, -10., 10., 100, 0., 10.);
- fh_resy_mom_true = new TH2F("h_resy_mom_true", "", 200, -10., 10., 100, 0., 10.);
-
- fh_pullx_plane_true = new TH2F("h_pullx_plane_true", "", 200, -10., 10., 12, 0., 12.);
- fh_pully_plane_true = new TH2F("h_pully_plane_true", "", 200, -10., 10., 12, 0., 12.);
- fh_pullx_plane_fake = new TH2F("h_pullx_plane_fake", "", 200, -10., 10., 12, 0., 12.);
- fh_pully_plane_fake = new TH2F("h_pully_plane_fake", "", 200, -10., 10., 12, 0., 12.);
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-void CbmL1TrdTrackFinderSts::DataBranches()
-{
- // Initialisation
-
- // Get pointer to the ROOT manager
- FairRootManager* rootMgr = FairRootManager::Instance();
- if (NULL == rootMgr) {
- cout << "-E- CbmL1TrdTrackFinderSts::DataBranches : "
- << "ROOT manager is not instantiated" << endl;
- return;
- }
- // Get pointer to the TRD points
- fArrayTrdPoint = L1_DYNAMIC_CAST<TClonesArray*>(rootMgr->GetObject("TrdPoint"));
- if (NULL == fArrayTrdPoint) {
- cout << "-W- CbmL1TrdTrackFinderSts::DataBranches : "
- << "no TRD point array" << endl;
- }
- // Get pointer to the STS track array
- fArrayStsTrack = L1_DYNAMIC_CAST<TClonesArray*>(rootMgr->GetObject("StsTrack"));
- if (NULL == fArrayStsTrack) {
- cout << "-W- CbmL1TrdTrackFinderSts::DataBranches : "
- << "no STS track array" << endl;
- }
- // Get pointer to the STS track match array
- fArrayStsTrackM = L1_DYNAMIC_CAST<TClonesArray*>(rootMgr->GetObject("StsTrackMatch"));
- if (NULL == fArrayStsTrackM) {
- cout << "-W- CbmL1TrdTrackFinderSts::DataBranches : "
- << "no STS track match array" << endl;
- }
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-void CbmL1TrdTrackFinderSts::TrdLayout()
-{
- // Determine the actual TRD layout from the parameter file
-
- // Get the pointer to the singleton FairRunAna object
- FairRunAna* ana = FairRunAna::Instance();
- if (NULL == ana) {
- cout << "-E- CbmL1TrdTrackFinderSts::TrdLayout :"
- << " no FairRunAna object!" << endl;
- return;
- }
- // Get the pointer to run-time data base
- FairRuntimeDb* rtdb = ana->GetRuntimeDb();
- if (NULL == rtdb) {
- cout << "-E- CbmL1TrdTrackFinderSts::TrdLayout :"
- << " no runtime database!" << endl;
- return;
- }
- // Get the pointer to container of base parameters
- FairBaseParSet* baseParSet = L1_DYNAMIC_CAST<FairBaseParSet*>(rtdb->getContainer("FairBaseParSet"));
- if (NULL == baseParSet) {
- cout << "-E- CbmL1TrdTrackFinderSts::TrdLayout :"
- << " no container of base parameters!" << endl;
- return;
- }
- // Get the pointer to detector list
- TObjArray* detList = baseParSet->GetDetList();
- if (NULL == detList) {
- cout << "-E- CbmL1TrdTrackFinderSts::TrdLayout :"
- << " no detector list!" << endl;
- return;
- }
- // Find TRD detector
- FairDetector* trd = L1_DYNAMIC_CAST<FairDetector*>(detList->FindObject("TRD"));
- if (NULL == trd) {
- cout << "-E- CbmL1TrdTrackFinderSts::TrdLayout :"
- << " no TRD detector!" << endl;
- return;
- }
- // Determine the geometry version
- TString name = trd->GetGeometryFileName();
- if (name.Contains("9")) {
- cout << "-I- CbmL1TrdTrackFinderSts::TrdLayout :"
- << " TRD geometry : 3x3." << endl;
- fNoTrdStations = 3;
- fNoTrdPerStation = 3;
- }
- else if (name.Contains("12")) {
- cout << "-I- CbmL1TrdTrackFinderSts::TrdLayout :"
- << " TRD geometry : 3x4." << endl;
- fNoTrdStations = 3;
- fNoTrdPerStation = 4;
- }
- else if (name.Contains("6x2")) {
- cout << "-I- CbmL1TrdTrackFinderSts::TrdLayout :"
- << " TRD geometry : 6x2." << endl;
- fNoTrdStations = 6;
- fNoTrdPerStation = 2;
- }
- else if (name.Contains("standard")) {
- cout << "-I- CbmL1TrdTrackFinderSts::TrdLayout :"
- << " TRD geometry : 3x4 standard." << endl;
- fNoTrdStations = 3;
- fNoTrdPerStation = 4;
- }
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-void CbmL1TrdTrackFinderSts::SortTrdHits()
-{
- // Sort TRD hits by plane number
- for (Int_t i = 0; i < 12; i++) {
- fNoTrdHits[i] = 0;
- }
- // Declare variables outside the loop
- Int_t nTrdHits = fArrayTrdHit->GetEntriesFast();
- CbmTrdHit* hit = NULL;
- CbmKFTrdHit* kfHit = NULL;
- Int_t planeNumber = 0;
- // Loop over TRD hits
- for (Int_t iHit = 0; iHit < nTrdHits; iHit++) {
- // Get pointer to the hit
- hit = L1_DYNAMIC_CAST<CbmTrdHit*>(fArrayTrdHit->At(iHit));
- if (NULL == hit) continue;
- // Create KF TRD hit
- new ((*fArrayKFTrdHit)[iHit]) CbmKFTrdHit();
- kfHit = L1_DYNAMIC_CAST<CbmKFTrdHit*>(fArrayKFTrdHit->At(iHit));
- kfHit->Create(hit);
- // Get plane number
- planeNumber = hit->GetPlaneId() - 1;
- if (planeNumber < 0 || planeNumber > 12) {
- cout << "-W- CbmL1TrdTrackFinderSts::SortTrdHits : "
- << "wrong plane number." << endl;
- continue;
- }
- // Store hit index in the array
- fTrdHitIndex[planeNumber][fNoTrdHits[planeNumber]] = iHit;
- // Increment number of hits in plane
- fNoTrdHits[planeNumber] += 1;
- }
- // Control output
- cout << endl << "-I- CbmL1TrdTrackFinderSts::SortTrdHits : " << endl;
- for (Int_t i = 0; i < (fNoTrdStations * fNoTrdPerStation); i++) {
- cout << "TRD plane no. " << i << " has " << fNoTrdHits[i] << " hits" << endl;
- }
-}
-// -----------------------------------------------------------------------
-
-
-// -----------------------------------------------------------------------
-void CbmL1TrdTrackFinderSts::WriteHistogramms()
-{
- // Write control histogramms to file
- fh_chi2hit->Write();
- fh_chi2hit_plane->Write();
- fh_resx_plane_true->Write();
- fh_resy_plane_true->Write();
- fh_resx_plane_fake->Write();
- fh_resy_plane_fake->Write();
- fh_resx_mom_true->Write();
- fh_resy_mom_true->Write();
- fh_pullx_plane_true->Write();
- fh_pully_plane_true->Write();
- fh_pullx_plane_fake->Write();
- fh_pully_plane_fake->Write();
-}
-// -----------------------------------------------------------------------
-
-
-ClassImp(CbmL1TrdTrackFinderSts);
diff --git a/reco/KF/obsolete/CbmL1TrdTrackFinderSts.h b/reco/KF/obsolete/CbmL1TrdTrackFinderSts.h
deleted file mode 100644
index e49530fb9fb744ba1a5aea738cced9fc78779545..0000000000000000000000000000000000000000
--- a/reco/KF/obsolete/CbmL1TrdTrackFinderSts.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/* Copyright (C) 2006-2010 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Denis Bertini [committer] */
-
-// -----------------------------------------------------------------------
-// ----- CbmL1TrdTrackFinderSts -----
-// ----- Created 6/12/05 by D. Kresan -----
-// -----------------------------------------------------------------------
-
-#ifndef CBM_L1_TRD_TRACK_FINDER_STS
-#define CBM_L1_TRD_TRACK_FINDER_STS
-
-#include "CbmTrdTrack.h"
-#include "CbmTrdTrackFinder.h"
-
-#include <map>
-#include <vector>
-
-class TClonesArray;
-class CbmTrdHit;
-class CbmKFTrack;
-class TH1F;
-class TH2F;
-
-
-class CbmL1TrdTrackFinderSts : public CbmTrdTrackFinder {
- private:
- CbmL1TrdTrackFinderSts(const CbmL1TrdTrackFinderSts&);
- CbmL1TrdTrackFinderSts operator=(const CbmL1TrdTrackFinderSts&);
-
- private:
- Int_t fEvents; // Number of events processed
- Int_t fVerbose; // Verbosity level
- TClonesArray* fArrayTrdPoint; // Array of TRD points
- TClonesArray* fArrayTrdHit; // Array of TRD hits
- TClonesArray* fArrayStsTrack; // Array of STS tracks
- TClonesArray* fArrayStsTrackM; // Array of STS tracks
- TClonesArray* fArrayKFTrdHit; // Array of KF TRD hits
- std::vector<CbmTrdTrack*> fvTrdTrack; // Working array of TRD tracks
- TClonesArray* fArrayTrdTrack; // Output Array of TRD tracks
- Int_t fPid; // PID assumption
- Int_t fNoTrdStations; // Number of TRD stations
- Int_t fNoTrdPerStation; // Number of TRD layers per station
- Int_t fNoTrdHits[12]; // Number of TRD hits per station
- Int_t fTrdHitIndex[12][10000]; // Indices of TRD hits per station
- std::map<Int_t, Bool_t> fmapHitUsed; // Map from hit index to boolean flag
- TH1F* fh_chi2hit; // Control histogramm
- TH2F* fh_chi2hit_plane; // Control histogramm
- TH2F* fh_resx_plane_true; // Control histogramm
- TH2F* fh_resy_plane_true; // Control histogramm
- TH2F* fh_resx_plane_fake; // Control histogramm
- TH2F* fh_resy_plane_fake; // Control histogramm
- TH2F* fh_resx_mom_true; // Control histogramm
- TH2F* fh_resy_mom_true; // Control histogramm
- TH2F* fh_pullx_plane_true; // Control histogramm
- TH2F* fh_pully_plane_true; // Control histogramm
- TH2F* fh_pullx_plane_fake; // Control histogramm
- TH2F* fh_pully_plane_fake; // Control histogramm
- std::map<Int_t, Bool_t> fLostTracks;
-
- void CreateHistogramms();
- void DataBranches();
- void TrdLayout();
- void SortTrdHits();
- void Process();
- void Sts2Trd(Double_t pmin, Double_t pmax, Double_t chi2min, Double_t chi2max);
- void ProcessAllStations();
- void MoveOut();
- void ProcessStation(CbmTrdTrack* pTrack, const Int_t& station);
- void UpdateTrack(Int_t station, CbmTrdTrack* track);
- virtual void Clear(const Option_t* a = 0);
- void RemoveFakes();
- Bool_t Overlap(CbmKFTrack& track, CbmTrdHit* pHit);
- Double_t GetChi2Hit(CbmKFTrack& track, CbmTrdHit* pHit);
-
- public:
- CbmL1TrdTrackFinderSts();
- CbmL1TrdTrackFinderSts(Int_t verbose);
- virtual ~CbmL1TrdTrackFinderSts();
-
- void Init();
- Int_t DoFind(TClonesArray* hitArray, TClonesArray* trackArray);
- void WriteHistogramms();
-
- inline void SetVerbose(Int_t verbose) { fVerbose = verbose; }
-
- static Bool_t CompareChi2(const CbmTrdTrack* a, const CbmTrdTrack* b)
- {
- return (a->GetChiSq() / static_cast<Double_t>(a->GetNDF()) < b->GetChiSq() / static_cast<Double_t>(b->GetNDF()));
- };
-
- ClassDef(CbmL1TrdTrackFinderSts, 1);
-};
-
-
-#endif
diff --git a/reco/KF/obsolete/CbmL1TrdTracklet.cxx b/reco/KF/obsolete/CbmL1TrdTracklet.cxx
deleted file mode 100644
index a66246aae1879e48a84470c4e2dc9aba40e0ddb6..0000000000000000000000000000000000000000
--- a/reco/KF/obsolete/CbmL1TrdTracklet.cxx
+++ /dev/null
@@ -1,20 +0,0 @@
-/* Copyright (C) 2006-2010 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Igor Kulakov, Denis Bertini [committer], Sergey Gorbunov */
-
-#include "CbmL1TrdTracklet.h"
-
-ClassImp(CbmL1TrdTracklet);
-
-// ----------------------- Default constructor ---------------------------
-CbmL1TrdTracklet::CbmL1TrdTracklet()
- : vAccostTracklet()
- , fIndLeft(0)
- , fIndRight(0)
- , fVal(0)
- , fY(0)
- , fIsAlone(0)
- , fIndex(0){};
-
-// ----------------------- Default destructor ---------------------------
-CbmL1TrdTracklet::~CbmL1TrdTracklet(){};
diff --git a/reco/KF/obsolete/CbmL1TrdTracklet.h b/reco/KF/obsolete/CbmL1TrdTracklet.h
deleted file mode 100644
index 5904ad83b4d0db5e256bd653c96191332922db1c..0000000000000000000000000000000000000000
--- a/reco/KF/obsolete/CbmL1TrdTracklet.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/* Copyright (C) 2006-2007 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Denis Bertini [committer], Sergey Gorbunov */
-
-#ifndef CBML1TRDTRACKLET_H
-#define CBML1TRDTRACKLET_H 1
-
-#include "TObject.h"
-
-#include <vector>
-
-class CbmL1TrdTracklet : public TObject {
-
- public:
- /** Default constructor **/
- CbmL1TrdTracklet();
-
- /** Destructor **/
- virtual ~CbmL1TrdTracklet();
-
- inline Int_t GetIndLeft() { return fIndLeft; };
- inline Int_t GetIndRight() { return fIndRight; };
- inline Int_t GetVal() { return fVal; };
- inline Int_t GetIsAlone() { return fIsAlone; };
- inline Int_t GetIndex() { return fIndex; };
- inline Double_t GetCoord(Int_t ind) { return fCoord[ind]; };
- inline Int_t GetPlanesID(Int_t num) { return fID[num]; };
-
- inline void SetIndLeft(Int_t indLeft) { fIndLeft = indLeft; };
- inline void SetIndRight(Int_t indRight) { fIndRight = indRight; };
- inline void SetVal(Int_t segVal) { fVal = segVal; };
- inline void SetIsAlone(Bool_t isAlone) { fIsAlone = isAlone; };
- inline void SetIndex(Int_t index) { fIndex = index; };
- inline void SetCoord(Int_t ind, Double_t val) { fCoord[ind] = val; };
- inline void SetPlanesID(Int_t A_ID, Int_t B_ID)
- {
- fID[0] = A_ID;
- fID[1] = B_ID;
- };
-
-
- std::vector<Int_t> vAccostTracklet;
-
- //compares the first or second two coordinates of two tracklets
- inline static Bool_t Compare1(CbmL1TrdTracklet* tr1, CbmL1TrdTracklet* tr2)
- {
- return (tr1->GetCoord(0) > tr2->GetCoord(0));
- };
-
- inline static Bool_t Compare2(CbmL1TrdTracklet* tr1, CbmL1TrdTracklet* tr2)
- {
- return (tr1->GetCoord(1) > tr2->GetCoord(1));
- };
-
- private:
- Int_t fID[2];
- Int_t fIndLeft;
- Int_t fIndRight;
- Int_t fVal;
- Int_t fY;
- Bool_t fIsAlone;
- Int_t fIndex;
- Double_t fCoord[4];
-
- ClassDef(CbmL1TrdTracklet, 1);
-};
-
-#endif
diff --git a/reco/KF/obsolete/CbmL1TrdTracklet4.cxx b/reco/KF/obsolete/CbmL1TrdTracklet4.cxx
deleted file mode 100644
index aa836b941feb309d52ee43f88f6a601254e158fa..0000000000000000000000000000000000000000
--- a/reco/KF/obsolete/CbmL1TrdTracklet4.cxx
+++ /dev/null
@@ -1,22 +0,0 @@
-/* Copyright (C) 2006-2010 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Igor Kulakov, Denis Bertini [committer] */
-
-#include "CbmL1TrdTracklet4.h"
-
-ClassImp(CbmL1TrdTracklet4);
-
-// ----------------------- Default constructor ---------------------------
-CbmL1TrdTracklet4::CbmL1TrdTracklet4()
- : vAccostTracklet()
- , vAccostLeft()
- , vAccostRight()
- , fVal(0)
- , fY(0)
- , fIsAlone(0)
- , fIndex(0)
- , fExt1(0)
- , fExt2(0){};
-
-// ----------------------- Default destructor ---------------------------
-CbmL1TrdTracklet4::~CbmL1TrdTracklet4(){};
diff --git a/reco/KF/obsolete/CbmL1TrdTracklet4.h b/reco/KF/obsolete/CbmL1TrdTracklet4.h
deleted file mode 100644
index 62f80be0b789b66d3b16324f9b773c83f6bb495a..0000000000000000000000000000000000000000
--- a/reco/KF/obsolete/CbmL1TrdTracklet4.h
+++ /dev/null
@@ -1,106 +0,0 @@
-/* Copyright (C) 2006-2007 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
- SPDX-License-Identifier: GPL-3.0-only
- Authors: Denis Bertini [committer], Sergey Gorbunov */
-
-#ifndef CBML1TRDTRACKLET4_H
-#define CBML1TRDTRACKLET4_H 1
-
-#include "TObject.h"
-
-#include <vector>
-
-class CbmL1TrdTracklet4 : public TObject {
-
- public:
- /** Default constructor **/
- CbmL1TrdTracklet4();
-
- //CbmL1TrdTracklet(Int_t indLeft, Int_t indRight) {fIndLeft=indLeft; fIndRight=indRight;};
-
- /** Destructor **/
- virtual ~CbmL1TrdTracklet4();
-
- //get a given hit hit index
- inline Int_t GetInd(Int_t i) { return fInd[i]; };
-
- //gets the appropriate coordinate values
- inline Double_t GetCoord(Int_t ind) { return fCoord[ind]; };
-
- //value of the tracklet used in tagging
- inline Int_t GetVal() { return fVal; };
-
- //says if this tracklet has any left-side neighbours
- inline Int_t GetIsAlone() { return fIsAlone; };
-
- inline Int_t GetIndex() { return fIndex; };
-
-
- //sets the index of a given hit
- inline void SetInd(Int_t ind, Int_t val) { fInd[ind] = val; };
-
- //sets the appropriate coordinate values
- inline void SetCoord(Int_t ind, Double_t val) { fCoord[ind] = val; };
-
- //set value of the tracklet used in tagging
- inline void SetVal(Int_t segVal) { fVal = segVal; };
-
- //sets flag if this tracklet has any left-side neighbours
- inline void SetIsAlone(Bool_t isAlone) { fIsAlone = isAlone; };
-
- inline void SetIndex(Int_t index) { fIndex = index; };
-
- /** Get extrapolated value of the precise coordinate of the 1st and 2nd layer **/
- inline Double_t GetExt(Int_t ind) { return fExt[ind]; };
-
- /** Set extrapolated value of the precise coordinate of the 1st and 2nd layer **/
- //ind == 0 1st layer
- //ind == 1 2nd layer
- inline void SetExt(Int_t ind, Double_t val) { fExt[ind] = val; };
-
- std::vector<Int_t> vAccostTracklet; //position of next tracklets in vector
- std::vector<Int_t> vAccostLeft; //position of next tracklets in vector
- std::vector<Int_t> vAccostRight; //position of next tracklets in vector
-
- //compares two first (or two second) coordinates of two tracklets
- inline static Bool_t compare1(CbmL1TrdTracklet4* tr1, CbmL1TrdTracklet4* tr2)
- {
- return (tr1->GetCoord(0) < tr2->GetCoord(0));
- };
-
- inline static Bool_t compare2(CbmL1TrdTracklet4* tr1, CbmL1TrdTracklet4* tr2)
- {
- return (tr1->GetCoord(1) < tr2->GetCoord(1));
- };
-
- inline static Bool_t Compare3S(CbmL1TrdTracklet4* tr1, CbmL1TrdTracklet4* tr2)
- {
- return (tr1->GetVal() > tr2->GetVal());
- };
-
- //to store 4 Z value
- Double_t M[4];
-
- private:
- //indexes of the four consistuent hits
- Int_t fInd[4];
-
- //tracklet tag value
- Int_t fVal;
-
-
- Int_t fY;
-
- //says if a tracklet has any left-sede neighbours
- Bool_t fIsAlone;
- Int_t fIndex;
-
- Double_t fExt1; //coordinates extrapolated to the next station (X or Y)
- Double_t fExt2;
- Double_t fExt[2];
-
- Double_t fCoord[4];
-
- ClassDef(CbmL1TrdTracklet4, 1);
-};
-
-#endif