Commit 6bd93cbf authored by Sergey Zharko's avatar Sergey Zharko
Browse files

code format fix

parent 7298fc76
......@@ -86,7 +86,7 @@ using std::ios;
ClassImp(CbmL1)
static L1Algo algo_static _fvecalignment; // TODO: gAlgo
static L1Algo algo_static _fvecalignment; // TODO: gAlgo
//L1AlgoInputData* fData_static _fvecalignment;
......@@ -388,7 +388,7 @@ InitStatus CbmL1::Init()
// TODO: Replace algo initialization in the constructor (S.Zharko)
algo = &algo_static;
/**********************//**
/**************************
** Field initialization **
**************************/
......@@ -397,44 +397,44 @@ InitStatus CbmL1::Init()
};
fpInitManager->SetFieldFunction(fieldGetterFcn);
/***********************//**
/***************************
** Target initialization **
***************************/
auto& target = CbmKF::Instance()->vTargets[0];
fpInitManager->SetTargetPosition(target.x, target.y, target.z);
/*****************************//**
/*********************************
** Target field initialization **
*********************************/
fpInitManager->InitTargetField(2.5);
/**********************************//**
/**************************************
** **
** STATIONS GEOMETRY INITIALIZATION **
** **
**************************************/
/***********************************************//**
/***************************************************
** Active tracking detector subsystems selection **
***************************************************/
fActiveTrackingDetectorIDs.insert(L1DetectorID::kSts);
if (fUseMVD) { fActiveTrackingDetectorIDs.insert(L1DetectorID::kMvd); }
if (fUseMVD) { fActiveTrackingDetectorIDs.insert(L1DetectorID::kMvd); }
if (fUseMUCH) { fActiveTrackingDetectorIDs.insert(L1DetectorID::kMuch); }
if (fUseTRD) { fActiveTrackingDetectorIDs.insert(L1DetectorID::kTrd); }
if (fUseTOF) { fActiveTrackingDetectorIDs.insert(L1DetectorID::kTof); }
if (fUseTRD) { fActiveTrackingDetectorIDs.insert(L1DetectorID::kTrd); }
if (fUseTOF) { fActiveTrackingDetectorIDs.insert(L1DetectorID::kTof); }
fpInitManager->SetActiveDetectorIDs(fActiveTrackingDetectorIDs);
/*****************************************************************//**
/*********************************************************************
** Counting numbers of stations for different detector subsystems **
*********************************************************************/
CbmMuchGeoScheme* fGeoScheme = CbmMuchGeoScheme::Instance();
/*** MuCh ***/
if (fUseMUCH) {
/// Save old global file and folder pointer to avoid messing with FairRoot
......@@ -525,7 +525,7 @@ InitStatus CbmL1::Init()
fpInitManager->SetStationsNumberCrosscheck(L1DetectorID::kMuch, NMuchStations);
fpInitManager->SetStationsNumberCrosscheck(L1DetectorID::kTrd, NTrdStations);
fpInitManager->SetStationsNumberCrosscheck(L1DetectorID::kTof, NTOFStation);
{
if (fSTAPDataMode % 2 == 1) { // 1,3
LOG(warn) << "CbmL1::Init: geo vector was removed, currently data cannot be written to a text-file";
......@@ -548,8 +548,8 @@ InitStatus CbmL1::Init()
//if (ind2 != ind)
// LOG(error) << "-E- CbmL1: Read geometry from file " << fSTAPDataDir + "geo_algo.txt was NOT successful.";
}
/***********************************//**
/***************************************
** Stations geometry initialization **
***************************************/
......@@ -584,7 +584,7 @@ InitStatus CbmL1::Init()
/*** STS stations info ***/
for (int iSt = 0; iSt < NStsStations; ++iSt) { // NOTE: example using smart pointers
auto cbmSts = CbmStsSetup::Instance()->GetStation(iSt);
auto cbmSts = CbmStsSetup::Instance()->GetStation(iSt);
auto stationInfo = L1BaseStationInfo(L1DetectorID::kSts, iSt);
stationInfo.SetStationType(0); // STS
stationInfo.SetTimeInfo(1);
......@@ -625,7 +625,7 @@ InitStatus CbmL1::Init()
stationInfo.SetFieldStatus(0);
stationInfo.SetZ(layer->GetZ());
auto thickness = layer->GetDz();
auto radLength = 0.; // Why 0??? (S.Zharko)
auto radLength = 0.; // Why 0??? (S.Zharko)
stationInfo.SetMaterial(thickness, radLength);
stationInfo.SetXmax(100.);
stationInfo.SetYmax(100.);
......@@ -695,7 +695,7 @@ InitStatus CbmL1::Init()
LOG(info) << "- TOF station " << iSt << " at z = " << stationInfo.GetZdouble();
}
/************************************//**
/****************************************
** **
** TRACKING ITERATIONS INITIALIZATION **
** **
......@@ -860,10 +860,10 @@ InitStatus CbmL1::Init()
//fpInitManager->PushBackCAIteration(trackingIterAllSecJump);
}
/******************//**
/**********************
** Set special cuts **
**********************/
fpInitManager->SetGhostSuppression(fGhostSuppression);
fpInitManager->SetTrackingLevel(fTrackingLevel);
fpInitManager->SetMomentumCutOff(fMomentumCutOff);
......@@ -872,7 +872,7 @@ InitStatus CbmL1::Init()
algo->Init(fUseHitErrors, fTrackingMode, fMissingHits);
/*****************************//**
/*********************************
** Material map initialization **
*********************************/
......@@ -943,7 +943,8 @@ InitStatus CbmL1::Init()
TDirectory* oldDir = gDirectory;
TFile* rlFile = new TFile(fStsMatBudgetFileName);
cout << "STS Material budget file is " << fStsMatBudgetFileName << ".\n";
for (int j = 1, iSta = algo->GetNstationsBeforePipe(); iSta < (algo->GetNstationsBeforePipe() + NStsStations); iSta++, j++) {
for (int j = 1, iSta = algo->GetNstationsBeforePipe(); iSta < (algo->GetNstationsBeforePipe() + NStsStations);
iSta++, j++) {
TString stationNameSts = stationName;
stationNameSts += j;
TProfile2D* hStaRadLen = (TProfile2D*) rlFile->Get(stationNameSts);
......@@ -1696,7 +1697,7 @@ void CbmL1::WriteSTAPAlgoData() // must be called after ReadEvent
// write algo data in file
static int vNEvent = 1;
std::fstream fadata;
TString fadata_name = fSTAPDataDir + "data_algo.txt";
// if ( vNEvent <= maxNEvent ) {
if (1) {
......
......@@ -222,7 +222,7 @@ private:
/// \param MVD Index of the detector subsystem
/// \return flag: false - success, true - some errors occured
bool ReadMCPoint(CbmL1MCPoint* MC, int iPoint, int MVD); // help procedure
/// Converts data from generic FairMCPoint based class to the CbmL1MCPoint
/// \param MC Pointer to a target CbmL1MCPoint object
/// \param iPoint Index of the point into the input MC points CbmMCDataArray object for the particular detector
......@@ -232,10 +232,10 @@ private:
/// \return flag: false - success, true - some errors occured
// TODO: Probably, we should replace input parameter MVD with the template (S.Zharko)
bool ReadMCPoint(CbmL1MCPoint* MC, int iPoint, int file, int event, int MVD);
// static bool compareZ(const int &a, const int &b );
// bool compareZ(const int &a, const int &b );
/// Fills the vMCTracks vector and the dFEI2vMCTracks set
void Fill_vMCTracks();
......
......@@ -16,15 +16,15 @@ struct CbmL1Hit {
CbmL1Hit(int hitId_, int extIndex_, int Det_) : hitId(hitId_), extIndex(extIndex_), Det(Det_) {};
int hitId = 0; ///> index of L1Hit in algo->vStsHits array. Should be equal to index of this in L1->vStsHits
int extIndex = 0; ///> index of hit in the TClonesArray array
int Det = 0; ///> station index
float x = 0.f; ///> measured X coordinate
float y = 0.f; ///> measured Y coordinate
float t = 0.f; ///> measured time
int f = 0; ///> front strip index
int b = 0; ///> back strip index
int ID = 0; ///> TODO: check if this ID is redundant
int hitId = 0; ///> index of L1Hit in algo->vStsHits array. Should be equal to index of this in L1->vStsHits
int extIndex = 0; ///> index of hit in the TClonesArray array
int Det = 0; ///> station index
float x = 0.f; ///> measured X coordinate
float y = 0.f; ///> measured Y coordinate
float t = 0.f; ///> measured time
int f = 0; ///> front strip index
int b = 0; ///> back strip index
int ID = 0; ///> TODO: check if this ID is redundant
L1Vector<int> mcPointIds {"CbmL1Hit::mcPointIds"}; // indices of CbmL1MCPoint in L1->vMCPoints array
};
......
......@@ -1193,7 +1193,7 @@ void CbmL1::TrackFitPerformance()
for (unsigned int iMCPoint = 0; iMCPoint < mc.Points.size(); iMCPoint++) {
const int iMCP = mc.Points[iMCPoint];
CbmL1MCPoint& mcP = vMCPoints[iMCP];
const L1Station& st = algo->GetStations()[mcP.iStation];
const L1Station& st = algo->GetStations()[mcP.iStation];
z[ih] = st.z[0];
if (ih > 0 && (z[ih] - z[ih - 1]) < 0.1) continue;
st.fieldSlice.GetFieldValue(mcP.x, mcP.y, B[ih]);
......@@ -1304,7 +1304,7 @@ void CbmL1::TrackFitPerformance()
for (unsigned int iMCPoint = 0; iMCPoint < mc.Points.size(); iMCPoint++) {
const int iMCP = mc.Points[iMCPoint];
CbmL1MCPoint& mcP = vMCPoints[iMCP];
const L1Station& st = algo->GetStations()[mcP.iStation];
const L1Station& st = algo->GetStations()[mcP.iStation];
z[ih] = st.z[0];
if (ih > 0 && (z[ih] - z[ih - 1]) < 0.1) continue;
st.fieldSlice.GetFieldValue(mcP.x, mcP.y, B[ih]);
......@@ -1375,7 +1375,7 @@ void CbmL1::TrackFitPerformance()
if (ih >= mc.Points.size()) continue; //If nofMCPoints in track < 3
const int iMCP = mc.Points[ih];
CbmL1MCPoint& mcP = vMCPoints[iMCP];
const L1Station& st = algo->GetStations()[mcP.iStation];
const L1Station& st = algo->GetStations()[mcP.iStation];
z[ih] = st.z[0];
st.fieldSlice.GetFieldValue(mcP.x, mcP.y, B[ih]);
};
......@@ -1438,7 +1438,7 @@ void CbmL1::TrackFitPerformance()
int ih = 1;
for (unsigned int iHit = 0; iHit < it->StsHits.size(); iHit++) {
const int iStation = vHitStore[it->StsHits[iHit]].iStation;
const L1Station& st = algo->GetStations()[iStation];
const L1Station& st = algo->GetStations()[iStation];
z[ih] = st.z[0];
st.fieldSlice.GetFieldValue(vHitStore[it->StsHits[iHit]].x, vHitStore[it->StsHits[iHit]].y, B[ih]);
ih++;
......
......@@ -82,13 +82,13 @@ struct TmpHit {
double dx, dy, dxy; ///> hit position errors in Cortesian coordinates
double du, dv; ///> hit position errors in strips coordinates
int iMC; ///> index of MCPoint in the vMCPoints array
double time = 0.; ///> time of the hit
double dt = 1.e10; ///> time error of the hit
int Det;
double time = 0.; ///> time of the hit
double dt = 1.e10; ///> time error of the hit
int Det;
int id;
int track;
/// Provides comparison of two hits.
/// Provides comparison of two hits.
/// If two hits belong to different stations,
/// the smallest hit belongs to the station with the smallest index. Otherwise, the smallest hit
/// has the smallest y coordinate
......@@ -106,7 +106,7 @@ struct TmpHit {
/// \param nTmpHits
/// \param nStripF
/// \param ip
/// \param NStrips
/// \param NStrips
/// \param st reference to the station info object
// TODO: Probably, L1Station& st parameter should be constant. Do we really want to modify a station here? (S.Zharko)
void CreateHitFromPoint(const CbmL1MCPoint& point, int det, int nTmpHits, int nStripF, int ip, int& NStrips,
......@@ -150,7 +150,7 @@ struct TmpHit {
iMC = ip;
}
/// Sets randomized position and time of the hit
/// Sets randomized position and time of the hit
/// The positions are smeared within predefined errors dx, dy, dt; z coordinate
/// of the hit is known precisely
/// \param point constant reference to the input MC-point
......@@ -177,15 +177,15 @@ void CbmL1::ReadEvent(L1AlgoInputData* fData_, float& TsStart, float& TsLength,
fData_->Clear();
// clear arrays for next event
vMCPoints.clear(); /* <CbmL1MCPoint> */
vMCPoints_in_Time_Slice.clear(); /* <int> */
vMCTracks.clear(); /* <CbmL1MCTrack> */
vStsHits.clear(); /* <CbmL1Hit> */
vRTracks.clear(); /* <CbmL1Track> */
vHitMCRef.clear(); /* <int>: indexes of MC-points in vMCPoints (by index of algo->vStsHits) */
vHitStore.clear(); /* <CbmL1HitStore> */
dFEI2vMCPoints.clear(); /* dFEI vs MC-point index: dFEI = index * 10000 + fileID + eventID * 0.0001 */
dFEI2vMCTracks.clear(); /* dFEI vs MC-track index: dFEI = index * 10000 + fileID + eventID * 0.0001 */
vMCPoints.clear(); /* <CbmL1MCPoint> */
vMCPoints_in_Time_Slice.clear(); /* <int> */
vMCTracks.clear(); /* <CbmL1MCTrack> */
vStsHits.clear(); /* <CbmL1Hit> */
vRTracks.clear(); /* <CbmL1Track> */
vHitMCRef.clear(); /* <int>: indexes of MC-points in vMCPoints (by index of algo->vStsHits) */
vHitStore.clear(); /* <CbmL1HitStore> */
dFEI2vMCPoints.clear(); /* dFEI vs MC-point index: dFEI = index * 10000 + fileID + eventID * 0.0001 */
dFEI2vMCTracks.clear(); /* dFEI vs MC-track index: dFEI = index * 10000 + fileID + eventID * 0.0001 */
if (fVerbose >= 10) cout << "ReadEvent: clear is done." << endl;
......@@ -266,7 +266,7 @@ void CbmL1::ReadEvent(L1AlgoInputData* fData_, float& TsStart, float& TsLength,
CbmL1MCPoint MC;
if (!ReadMCPoint(&MC, iMC, iFile, iEvent, 1)) {
MC.iStation = -1;
const L1Station* sta = algo->GetStations().begin();
const L1Station* sta = algo->GetStations().begin();
double bestDist = 1.e20;
for (Int_t iSt = 0; iSt < NMvdStations; iSt++) {
// use z_in since z_out is sometimes very wrong
......@@ -303,7 +303,7 @@ void CbmL1::ReadEvent(L1AlgoInputData* fData_, float& TsStart, float& TsLength,
CbmL1MCPoint MC;
if (!ReadMCPoint(&MC, iMC, iFile, iEvent, 0)) {
MC.iStation = -1;
const L1Station* sta = algo->GetStations().begin() + NMvdStations;
const L1Station* sta = algo->GetStations().begin() + NMvdStations;
double bestDist = 1.e20;
for (Int_t iSt = 0; iSt < NStsStations; iSt++) {
// use z_in since z_out is sometimes very wrong
......@@ -416,7 +416,8 @@ void CbmL1::ReadEvent(L1AlgoInputData* fData_, float& TsStart, float& TsLength,
Int_t IND_Track = trk_it->second;
MC.iStation = -1;
const L1Station* sta = algo->GetStations().begin() + NMvdStations + NStsStations + NMuchStations + NTrdStations;
const L1Station* sta =
algo->GetStations().begin() + NMvdStations + NStsStations + NMuchStations + NTrdStations;
for (Int_t iSt = 0; iSt < NTOFStation; iSt++)
MC.iStation = (MC.z > sta[iSt].z[0] - 15)
? (NMvdStations + NStsStations + NMuchStations + NTrdStations + iSt)
......@@ -443,7 +444,8 @@ void CbmL1::ReadEvent(L1AlgoInputData* fData_, float& TsStart, float& TsLength,
if (!ReadMCPoint(&MC, TofPointToTrack[iTofSta][iMC], iFile, iEvent, 4)) {
MC.iStation = -1;
const L1Station* sta = algo->GetStations().begin() + NMvdStations + NStsStations + NMuchStations + NTrdStations;
const L1Station* sta =
algo->GetStations().begin() + NMvdStations + NStsStations + NMuchStations + NTrdStations;
for (Int_t iSt = 0; iSt < NTOFStation; iSt++)
MC.iStation = (MC.z > sta[iSt].z[0] - 15)
? (NMvdStations + NStsStations + NMuchStations + NTrdStations + iSt)
......@@ -835,7 +837,7 @@ void CbmL1::ReadEvent(L1AlgoInputData* fData_, float& TsStart, float& TsLength,
nTrdHits++;
}
}
//
// Get TRD hits
//
......@@ -1064,7 +1066,8 @@ void CbmL1::ReadEvent(L1AlgoInputData* fData_, float& TsStart, float& TsLength,
Double_t dtrck = dFEI(iFile, iEvent, pt->GetTrackID());
DFEI2I::iterator trk_it = dFEI2vMCPoints.find(dtrck);
if (trk_it != dFEI2vMCPoints.end()) th.iMC = TofPointToTrack[sttof][trk_it->second];
if ((1 == fTofUseMcHit) && (th.iMC > -1)) th.SetHitFromPoint(vMCPoints[th.iMC], algo->GetStations()[th.iStation]);
if ((1 == fTofUseMcHit) && (th.iMC > -1))
th.SetHitFromPoint(vMCPoints[th.iMC], algo->GetStations()[th.iStation]);
}
}
......@@ -1126,7 +1129,7 @@ void CbmL1::ReadEvent(L1AlgoInputData* fData_, float& TsStart, float& TsLength,
vHitStore.reserve(nHits);
vHitMCRef.reserve(nHits);
for (int i = 0; i < nHits; i++) {
TmpHit& th = tmpHits[i];
......@@ -1169,7 +1172,7 @@ void CbmL1::ReadEvent(L1AlgoInputData* fData_, float& TsStart, float& TsLength,
h.z = th.z;
// save hit
// save hit
vStsHits.push_back(CbmL1Hit(fData->vStsHits.size(), th.ExtIndex, th.Det));
vStsHits[vStsHits.size() - 1].x = th.x;
......@@ -1222,7 +1225,7 @@ void CbmL1::ReadEvent(L1AlgoInputData* fData_, float& TsStart, float& TsLength,
void CbmL1::Fill_vMCTracks()
{
vMCTracks.clear();
// Count the total number of tracks in this event and reserve memory
{
Int_t nMCTracks = 0;
......@@ -1244,12 +1247,12 @@ void CbmL1::Fill_vMCTracks()
assert(header);
Int_t nMCTrack = fMCTracks->Size(iFile, iEvent);
if (fVerbose > 2) {
LOG(info) << "MC event: vertex at " << header->GetX() << " " << header->GetY() << " " << header->GetZ()
<< "; Number of tracks = " << nMCTrack;
}
/* Loop over MC tracks */
for (Int_t iMCTrack = 0; iMCTrack < nMCTrack; iMCTrack++) {
CbmMCTrack* MCTrack = L1_DYNAMIC_CAST<CbmMCTrack*>(fMCTracks->Get(iFile, iEvent, iMCTrack));
......
......@@ -76,13 +76,13 @@ void L1Algo::Init(const bool UseHitErrors, const TrackingMode mode, const bool M
fTrackingMode = mode;
fMissingHits = MissingHits;
//int NMvdStations = static_cast<int>(geo[ind++]); // TODO: get rid of NMbdStations (S. Zh.)
int nStationsSts = fInitManager.GetStationsNumber(static_cast<L1DetectorID>(1));
fNstationsBeforePipe = fInitManager.GetStationsNumber(static_cast<L1DetectorID>(0));
//int NStsStations = static_cast<int>(geo[ind++]); // TODO: get rid of NStsStations (S. Zh.)
fNfieldStations = nStationsSts + fNstationsBeforePipe; // TODO: Provide special getter for it (S.Zharko, 12.05.2022)
fNfieldStations = nStationsSts + fNstationsBeforePipe; // TODO: Provide special getter for it (S.Zharko, 12.05.2022)
if (fTrackingMode == kMcbm) { fNfieldStations = -1; }
......@@ -93,7 +93,7 @@ void L1Algo::Init(const bool UseHitErrors, const TrackingMode mode, const bool M
// Print out the bits of the init manager
LOG(info) << "InitManager " << fInitManager.GetInitController().ToString();
// Get real target position
fRealTargetX = fInitManager.GetTargetPosition()[0];
fRealTargetY = fInitManager.GetTargetPosition()[1];
......@@ -103,15 +103,15 @@ void L1Algo::Init(const bool UseHitErrors, const TrackingMode mode, const bool M
fNstations = fInitManager.GetStationsNumber();
// Get field near target
fVtxFieldValue = fInitManager.GetTargetFieldValue();
fVtxFieldValue = fInitManager.GetTargetFieldValue();
fVtxFieldRegion = fInitManager.GetTargetFieldRegion();
// Fill L1Station array
fInitManager.TransferL1StationArray(fStations);
fTrackingLevel = fInitManager.GetTrackingLevel();
fTrackingLevel = fInitManager.GetTrackingLevel();
fGhostSuppression = fInitManager.GetGhostSuppression();
fMomentumCutOff = fInitManager.GetMomentumCutOff();
fMomentumCutOff = fInitManager.GetMomentumCutOff();
LOG(info) << " ***********************";
LOG(info) << " * L1Algo parameters *";
......
......@@ -85,7 +85,6 @@ using L1StationsArray_t = std::array<L1Station, L1Parameters::kMaxNstations>;
///
class L1Algo {
public:
L1Algo(unsigned int nThreads = 1);
L1Algo(const L1Algo&) = delete;
......@@ -105,7 +104,7 @@ public:
/// \return particle mass squared
float GetDefaultParticleMass2() const { return fDefaultMass * fDefaultMass; }
float fDefaultMass = 0.10565800; // muon mass
float fDefaultMass = 0.10565800; // muon mass
// TODO: make fDefaultMass a private member (S.Zharko)
/// pack station, thread and triplet indices to an unique triplet ID
......@@ -154,12 +153,12 @@ public:
Tindex fDupletPortionStopIndex[L1Parameters::kMaxNstations] {0}; // end of the duplet portions for the station
L1Vector<Tindex> fDupletPortionSize {"L1Algo::fDupletPortionSize"}; // N duplets in a portion
/********************************************************************************************//**
/********************************************************************************************/ /**
* Temporary vectors used by the clone merger
* TODO: Probably, the subclass L1TrackMerger for clones merger would help to improve
* readability (S.Zharko)
***********************************************************************************************/
//
// Vectors that are parallel to fTracks
//
......@@ -172,7 +171,7 @@ public:
/// Index of the last hit of a track
L1Vector<L1HitIndex_t> fMergerTrackLastHit {"L1Algo::fMergerTrackLastHit"};
/// Index (TODO:??) of a track that can be merge with the given track
L1Vector<unsigned short> fMergerTrackNeighbour { "L1Algo::fMergerTrackNeighbour"};
L1Vector<unsigned short> fMergerTrackNeighbour {"L1Algo::fMergerTrackNeighbour"};
/// Chi2 value of the track merging procedure
L1Vector<float> fMergerTrackChi2 {"L1Algo::fMergerTrackChi2"};
/// Flag: is the given track already stored to the output
......@@ -223,24 +222,22 @@ public:
void SetNThreads(unsigned int n);
private:
int fNstations {0}; ///< number of all detector stations
int fNstationsBeforePipe {0}; ///< number of stations before pipe (MVD stations in CBM)
int fNfieldStations {0}; ///< number of stations in the field region
alignas(16) L1StationsArray_t fStations; ///< array of L1Station objects
int fNstations {0}; ///< number of all detector stations
int fNstationsBeforePipe {0}; ///< number of stations before pipe (MVD stations in CBM)
int fNfieldStations {0}; ///< number of stations in the field region
alignas(16) L1StationsArray_t fStations; ///< array of L1Station objects
public:
/// Gets total number of stations used in tracking
int GetNstations() const { return fNstations; }
int GetNstations() const { return fNstations; }
/// Gets number of stations before the pipe (MVD stations in CBM)
int GetNstationsBeforePipe() const { return fNstationsBeforePipe; }
/// Gets number of stations situated in field region (MVD + STS in CBM)
int GetNfieldStations() const { return fNfieldStations;}
int GetNfieldStations() const { return fNfieldStations; }
/// Gets reference to the stations array
const L1StationsArray_t& GetStations() const { return fStations; }
public:
L1Vector<L1Material> fRadThick {"fRadThick"}; // material for each station
int NStsStrips {0}; ///> number of strips
......@@ -285,7 +282,7 @@ public:
int fNThreads {0};
bool fUseHitErrors {true};
bool fMissingHits {0}; ///< TODO ???
bool fMissingHits {0}; ///< TODO ???
TrackingMode fTrackingMode {kSts};
fvec EventTime[L1Parameters::kMaxNthreads][L1Parameters::kMaxNthreads] {{0}};
......@@ -405,7 +402,7 @@ private:
L1InitManager fInitManager {&fParameters}; ///< Object of L1Algo initialization manager class
/*********************************************************************************************//**
/*********************************************************************************************/ /**
* ------ FUNCTIONAL PART ------
************************************************************************************************/
......@@ -452,7 +449,7 @@ private:
void MultiplySR(fvec const C[15], fvec const r_in[5], fvec r_out[5]);
void FilterTracks(fvec const r[5], fvec const C[15], fvec const m[5], fvec const V[15], fvec R[5], fvec W[15],
fvec* chi2);
///
///
void CAMergeClones();
......@@ -545,8 +542,8 @@ private:
/// Refit Triplets.
void f32( // input
Tindex n3, int istal, nsL1::vector<L1TrackPar>::TSimd& T_3, L1Vector<L1HitIndex_t>& hitsl_3, L1Vector<L1HitIndex_t>& hitsm_3,
L1Vector<L1HitIndex_t>& hitsr_3, int nIterations = 0);
Tindex n3, int istal, nsL1::vector<L1TrackPar>::TSimd& T_3, L1Vector<L1HitIndex_t>& hitsl_3,
L1Vector<L1HitIndex_t>& hitsm_3, L1Vector<L1HitIndex_t>& hitsr_3, int nIterations = 0);
/// Select triplets. Save them into vTriplets.
void f4( // input
......@@ -581,7 +578,8 @@ private:
/// Find triplets on station
void TripletsStaPort( // input
int istal, int istam, int istar, Tindex& nstaltriplets, L1TrackPar* T_1, L1FieldRegion* fld_1, L1HitIndex_t* hitsl_1,
int istal, int istam, int istar, Tindex& nstaltriplets, L1TrackPar* T_1, L1FieldRegion* fld_1,
L1HitIndex_t* hitsl_1,
Tindex& n_2, L1Vector<L1HitIndex_t>& i1_2, L1Vector<L1HitIndex_t>& hitsm_2,
......@@ -692,9 +690,9 @@ private:
fvec fMaxInvMom {L1Utils::kNaN}; ///< max considered q/p for tracks
fvec fMaxSlopePV {L1Utils::kNaN}; ///< max slope (tx\ty) in prim vertex
float fMaxSlope {L1Utils::kNaN}; ///< max slope (tx\ty) in 3d hit position of a triplet
fvec fRealTargetX {L1Utils::kNaN}; ///< real target position x coordinate
fvec fRealTargetY {L1Utils::kNaN}; ///< real target position y coordinate
fvec fRealTargetZ {L1Utils::kNaN}; ///< real target position z coordinate
fvec fRealTargetX {L1Utils::kNaN}; ///< real target position x coordinate
fvec fRealTargetY {L1Utils::kNaN}; ///< real target position y coordinate
fvec fRealTargetZ {L1Utils::kNaN}; ///< real target position z coordinate
fvec fTargX {L1Utils::kNaN}; ///< target position x coordinate for the current iteration (modifiable)
fvec fTargY {L1Utils::kNaN}; ///< target position y coordinate for the current iteration (modifiable)
fvec fTargZ {L1Utils::kNaN}; ///< target position z coordinate for the current iteration (modifiable)
......@@ -708,8 +706,8 @@ private:
// int TripNumThread;
int fTrackingLevel {2}; // currently not used
int fGhostSuppression {1}; // currently not used
int fTrackingLevel {2}; // currently not used
int fGhostSuppression {1}; // currently not used
float fMomentumCutOff {0.2}; // currently not used
/// ----- Debug features -----
......
......@@ -198,7 +198,8 @@ namespace tbb
L1HitIndex_t* hitsm_g2_,
// fvec *x_minusV_g2_, fvec *x_plusV_g2_, fvec *y_minusV_g2_, fvec *y_plusV_g2_,
// output
L1HitIndex_t* Duplets_start_, L1HitIndex_t* Duplets_hits_, std::vector<L1Triplet>* vTriplets_part_, unsigned* TripStartIndexH_,
L1HitIndex_t* Duplets_start_, L1HitIndex_t* Duplets_hits_, std::vector<L1Triplet>* vTriplets_part_,
unsigned* TripStartIndexH_,
unsigned* TripStopIndexH_)
: // input
isec(isec_)
......
......@@ -2,7 +2,7 @@
SPDX-License-Identifier: GPL-3.0-only
Authors: Sergey Gorbunov, Sergei Zharko [committer] */
/***********************************************************************************************//**
/***************************************************************************************************
* @file L1CAIteration.cxx
* @brief Definition of the L1CAIteration class methods
* @since 05.02.2022
......
......@@ -2,7 +2,7 @@
SPDX-License-Identifier: GPL-3.0-only
Authors: Sergey Gorbunov, Sergei Zharko [committer] */
/***********************************************************************************************//**
/***************************************************************************************************
* @file L1CAIteration.h
* @brief Declaration of the L1CAIteration class
* @since 05.02.2022
......@@ -17,8 +17,8 @@
// TODO: discuss the border conditions for the parameters. Implement them (S.Zharko)
// Implementation: use tuples for boundary conditions of the parameters
/// Class L1CAIteration describes L1 Track finder iteration.