16 #include "Identifier/Identifier.h"
33 double baseScorePerHit = 17.;
45 double hitQualityScore;
49 hitQualityScore = (1.2 * (baseScorePerHit -
x2 * .5));
51 hitQualityScore = (baseScorePerHit -
x2);
52 if (hitQualityScore < 0.)
139 return StatusCode::SUCCESS;
169 if (!
key.key().empty()) {
183 ATH_CHECK(outputTracks.record(std::make_unique<TrackCollection>()));
186 return StatusCode::SUCCESS;
192 std::list<Trk::Vertex> vertices =
m_zvertexmaker->newEvent(ctx, seedEventData);
193 if (not vertices.empty()) ZVE =
true;
197 std::list<Trk::Vertex> vertexList;
201 const bool PIX =
true;
202 const bool SCT =
true;
209 std::multimap<double, Trk::Track*> qualitySortedTrackCandidates;
212 while ((seed =
m_seedsmaker->next(ctx, seedEventData))) {
214 std::list<Trk::Track*> trackList =
m_trackmaker->getTracks(ctx, trackEventData, seed->spacePoints());
216 qualitySortedTrackCandidates.insert(std::make_pair(-trackQuality(
t),
t));
232 for (
const std::pair<const double, Trk::Track*> & qualityAndTrack: qualitySortedTrackCandidates) {
238 outputTracks->push_back(qualityAndTrack.second);
247 outputTracks->clear();
258 return StatusCode::SUCCESS;
268 ATH_CHECK(outputTracks.record(std::make_unique<TrackCollection>()));
271 return StatusCode::SUCCESS;
296 std::list<Trk::Vertex> vertexList;
300 const bool PIX = true ;
301 const bool SCT = true ;
307 std::vector<int> numberHistogram(
m_histsize, 0);
308 std::vector<double> zWeightedHistogram(
m_histsize, 0.);
309 std::vector<double> ptWeightedHistogram(
m_histsize, 0.);
316 std::multimap<double, Trk::Track*> qualitySortedTrackCandidates;
319 bool doWriteNtuple =
m_seedsmaker->getWriteNtupleBoolProperty();
324 if(!eventInfo.
isValid()) {EvNumber = -1.0;}
else {EvNumber = eventInfo->
eventNumber();}
328 while ((seed =
m_seedsmaker->next(ctx, seedEventData))) {
332 bool firstTrack{
true};
335 std::list<Trk::Track*> trackList =
m_trackmaker->getTracks(ctx, trackEventData, seed->spacePoints());
339 qualitySortedTrackCandidates.insert(std::make_pair(-trackQuality(
t),
t));
347 fillZHistogram(
t, beamPosPerigee, numberHistogram, zWeightedHistogram, ptWeightedHistogram);
369 ATH_MSG_WARNING(
"SpacePointsPixelKey is empty. Skipping the second seeding pass that uses pixel seeds.");
373 std::pair<double,double> zBoundaries;
376 findZvertex(vertexList, zBoundaries, numberHistogram, zWeightedHistogram, ptWeightedHistogram);
379 m_seedsmaker->find3Sp(ctx, seedEventData, vertexList, &(zBoundaries.first));
385 while ((seed =
m_seedsmaker->next(ctx, seedEventData))) {
389 std::list<Trk::Track*> trackList =
m_trackmaker->getTracks(ctx, trackEventData, seed->spacePoints());
392 qualitySortedTrackCandidates.insert(std::make_pair(-trackQuality(
t),
t));
410 for (
const std::pair<const double, Trk::Track*> & qualityAndTrack: qualitySortedTrackCandidates) {
428 outputTracks->push_back(qualityAndTrack.second);
439 outputTracks->clear();
449 return StatusCode::SUCCESS;
461 ATH_CHECK(outputTracks.record(std::make_unique<TrackCollection>()));
463 const bool PIX = true ;
464 const bool STRIP = true ;
482 std::list<Trk::Vertex> vertexList;
491 std::multimap<double, Trk::Track*> qualitySortedTrackCandidates;
494 bool doWriteNtuple =
m_seedsmaker->getWriteNtupleBoolProperty();
499 if(!eventInfo.
isValid()) {EvNumber = -1.0;}
else {EvNumber = eventInfo->
eventNumber();}
503 while ((seed =
m_seedsmaker->next(ctx, seedEventData))) {
508 std::list<Trk::Track*> trackList =
m_trackmaker->getTracks(ctx, trackEventData, seed->spacePoints());
512 qualitySortedTrackCandidates.insert(std::make_pair(-trackQuality(
t),
t));
531 for (
const std::pair<const double, Trk::Track*> & qualityAndTrack: qualitySortedTrackCandidates) {
548 outputTracks->push_back(qualityAndTrack.second);
556 outputTracks->clear();
566 return StatusCode::SUCCESS;
579 ATH_CHECK(outputTracks.record(std::make_unique<TrackCollection>()));
582 return StatusCode::SUCCESS;
588 std::unique_ptr<RoiDescriptor> roiComp = std::make_unique<RoiDescriptor>(
true);
593 double beamZ = beamSpotHandle->beamVtx().position().z();
598 for (
const ROIPhiRZ &calo_roi : calo_rois_ref) {
599 double phi = calo_roi.phi();
600 if (std::abs(phi)>=
M_PI && phi!=-
M_PI)
continue;
601 double eta = calo_roi.eta();
609 roi =
new RoiDescriptor( eta, roiEtaMin, roiEtaMax,phi, roiPhiMin ,roiPhiMax,
z,roiZMin,roiZMax);
615 return StatusCode::FAILURE;
618 std::vector<IdentifierHash> listOfStripIds;
619 std::vector<IdentifierHash> listOfPixIds;
621 m_regsel_strip->lookup(ctx)->HashIDList( *roiComp, listOfStripIds );
624 m_seedsmaker->newRegion(ctx, seedEventData, listOfPixIds, listOfStripIds);
625 std::list<Trk::Vertex> vertexList;
629 const bool PIX = true ;
630 const bool STRIP = true ;
640 std::multimap<double, Trk::Track*> qualitySortedTrackCandidates;
643 bool doWriteNtuple =
m_seedsmaker->getWriteNtupleBoolProperty();
648 if(!eventInfo.
isValid()) {EvNumber = -1.0;}
else {EvNumber = eventInfo->
eventNumber();}
652 while ((seed =
m_seedsmaker->next(ctx, seedEventData))) {
657 std::list<Trk::Track*> trackList =
m_trackmaker->getTracks(ctx, trackEventData, seed->spacePoints());
660 qualitySortedTrackCandidates.insert(std::make_pair(-trackQuality(
t),
t));
679 for (
const std::pair<const double, Trk::Track*> & qualityAndTrack: qualitySortedTrackCandidates) {
697 outputTracks->push_back(qualityAndTrack.second);
705 outputTracks->clear();
715 return StatusCode::SUCCESS;
732 return StatusCode::SUCCESS;
741 msg(assign_level) <<std::endl;
742 MsgStream& out_msg=
msg();
756 std::string s1;
for (
int i=0;
i<
n; ++
i) s1.append(
" "); s1.append(
"|");
758 std::string
s2;
for (
int i=0;
i<
n; ++
i)
s2.append(
" ");
s2.append(
"|");
760 std::string
s3;
for (
int i=0;
i<
n; ++
i)
s3.append(
" ");
s3.append(
"|");
762 std::string
s4;
for (
int i=0;
i<
n; ++
i)
s4.append(
" ");
s4.append(
"|");
766 n = 65-s5.size();
for (
int i=0;
i<
n; ++
i) s5.append(
" "); s5.append(
"|");
768 out<<
"|----------------------------------------------------------------"
769 <<
"----------------------------------------------------|"
771 out<<
"| Use primary vertices z-coordinates finding?| "<<s5
774 out<<
"| Tool for primary vertices z-coordinates finding | "<<
m_zvertexmaker.type()<<s1
783 out<<
"|----------------------------------------------------------------"
784 <<
"----------------------------------------------------|"
795 out<<
"|-------------------------------------------------------------------";
796 out<<
"---------------------------------|"
798 out<<
"| Investigated "
799 <<std::setw(9)<<
counter[
kNSeeds]<<
" space points seeds and found ";
804 else out<<
" tracks using old strategy |"<<std::endl;
806 out<<
"|-------------------------------------------------------------------";
807 out<<
"---------------------------------|"
818 out<<
"|-------------------------------------------------------------------";
819 out<<
"-----------------------------|"
844 unsigned int nsp = 0;
847 if (spacePointsPixel.isValid()) {
862 if (spacePointsSCT.isValid()) {
882 std::set<const Trk::PrepRawData*>
clusters;
884 std::vector<const Trk::PrepRawData*> freeClusters;
885 freeClusters.reserve(15);
890 while (it_qualityAndTrack!=qualitySortedTracks.end()) {
891 freeClusters.clear();
907 freeClusters.push_back(
pr);
913 int nFreeClusters =
static_cast<int>(freeClusters.size());
914 if (nFreeClusters >=
m_nfreeCut || nFreeClusters==nClusters) {
917 clusters.insert(freeClusters.begin(), freeClusters.end());
918 ++it_qualityAndTrack;
921 delete (*it_qualityAndTrack).second;
922 qualitySortedTracks.erase(it_qualityAndTrack++);
930 std::set<const Trk::PrepRawData*>
clusters;
932 std::vector<const Trk::PrepRawData*> freeClusters;
933 freeClusters.reserve(15);
938 while (it_qualityAndTrack!=qualitySortedTracks.end()) {
939 freeClusters.clear();
964 freeClusters.push_back(
pr);
970 clusters.insert(freeClusters.begin(), freeClusters.end());
972 int nFreeClusters =
static_cast<int>(freeClusters.size());
973 if(
passEtaDepCuts( (*it_qualityAndTrack).second, nClusters, nFreeClusters, nPixels) ){
975 ++it_qualityAndTrack;
978 delete (*it_qualityAndTrack).second;
979 qualitySortedTracks.erase(it_qualityAndTrack++);
990 std::vector<int>& numberHistogram,
991 std::vector<double>& zWeightedHistogram,
992 std::vector<double>& ptWeightedHistogram)
const
1002 constexpr
double rSquare_max_forZHisto = 60.*60.;
1003 if (position.x()*position.x()+position.y()*position.y() >= rSquare_max_forZHisto)
return;
1009 if (not TP.
production(paramsAtFirstSurface))
return;
1013 if (not
m_proptool->propagate(Gaudi::Hive::currentContext(),
1016 const AmgVector(5)& parsAtBeamSpot = TP.parameters();
1017 if (std::abs(parsAtBeamSpot[0]) >
m_imcut)
return;
1023 ++numberHistogram[
z];
1025 zWeightedHistogram[
z] += parsAtBeamSpot[1];
1027 ptWeightedHistogram[
z] +=
pT;
1037 std::pair<double, double> & zBoundaries,
1038 const std::vector<int>& numberHistogram,
1039 const std::vector<double>& zWeightedHistogram,
1040 const std::vector<double>& ptWeightedHistogram)
const
1042 zBoundaries = {1000., -1000};
1044 std::multimap<int ,double> vertexZ_sortedByNtracks;
1045 std::multimap<double,double> vertexZ_sortedBySumPt;
1048 int minBinContentSum = 3;
1058 if (vertexNtracks>=minBinContentSum and (numberHistogram.at(
binIndex) >= numberHistogram.at(
binIndex-1) and numberHistogram.at(
binIndex) >= numberHistogram.at(
binIndex+1))) {
1060 double vertexZestimate = (zWeightedHistogram.at(
binIndex-1)+zWeightedHistogram.at(
binIndex)+zWeightedHistogram.at(
binIndex+1))/
static_cast<double>(vertexNtracks);
1064 if (vertexZestimate < zBoundaries.first) zBoundaries.first = vertexZestimate;
1065 if (vertexZestimate > zBoundaries.second) zBoundaries.second = vertexZestimate;
1070 vertexZ_sortedByNtracks.insert(std::make_pair(-vertexNtracks, vertexZestimate));
1071 vertexZ_sortedBySumPt.insert(std::make_pair(-
vertexSumPt, vertexZestimate));
1078 std::set<double> leadingVertices;
1081 for (std::pair<int, double> nTrackAndZ: vertexZ_sortedByNtracks) {
1086 leadingVertices.insert(nTrackAndZ.second);
1087 leadingVertices.insert((*vertex_pt_and_z++).second);
1090 for (
double v: leadingVertices) {
1095 if (zBoundaries.first > zBoundaries.second) {
1096 zBoundaries.first = -1000.;
1097 zBoundaries.second = +1000.;
1100 zBoundaries.first -= 20.;
1101 zBoundaries.second += 20.;
1133 if(!
par)
return false;
1135 double eta = std::abs(
par->eta());
1136 if(nClusters < m_etaDependentCutsSvc->getMinSiHitsAtEta(eta))
return false;
1137 if(nFreeClusters < m_etaDependentCutsSvc->getMinSiNotSharedAtEta(eta))
return false;
1139 if(nPixels < m_etaDependentCutsSvc->getMinPixelHitsAtEta(eta))
return false;
1150 int vol_id, lay_id, mod_id;
1151 float m_x, m_y, m_z;
1165 if (!IDs && !IDp)
return;
1169 std::vector<VLM_Data> vlm;
1171 for (
const auto*
s : *
track->trackStateOnSurfaces()) {
1196 if (
bec == -2) vol_id = 7;
1197 if (
bec == 2) vol_id = 9;
1199 if (bec < -2 || bec > 2)
continue;
1209 int new_vol = 0, new_lay = 0;
1211 if (vol_id == 7 || vol_id == 9) {
1212 new_vol = 10 * vol_id + lay_id;
1214 }
else if (vol_id == 8) {
1216 new_vol = 10 * vol_id + lay_id;
1219 vlm.emplace_back(new_vol, new_lay, mod_id,
pos.x(),
pos.y(),
pos.z());
1230 if (
bec < 0) vol_id = 12;
1231 if (
bec > 0) vol_id = 14;
1242 vlm.emplace_back(vol_id, lay_id, mod_id,
pos.x(),
pos.y(),
pos.z());
1248 std::vector<VLM_Data> vlm2;
1250 for (std::size_t
it1 = 0;
it1 < vlm.size() - 1;
it1++) {
1251 if (vlm.at(
it1).vol_id > 14) {
1252 vlm2.push_back(vlm.at(
it1));
1256 std::size_t it2 =
it1 + 1;
1258 int src = vlm.at(
it1).vol_id * 1000 + vlm.at(
it1).lay_id;
1259 int dst = vlm.at(it2).vol_id * 1000 + vlm.at(it2).lay_id;
1262 vlm2.push_back(vlm.at(
it1));
1263 vlm2.push_back(vlm.at(it2));
1272 constexpr
float minDist = 20.0;
1274 for (
auto it =
std::next(vlm2.begin());
it != vlm2.end(); ) {
1275 auto jt = std::prev(
it);
1276 float dx =
it->m_x - jt->m_x;
1277 float dy =
it->m_y - jt->m_y;
1278 float dz =
it->m_z - jt->m_z;
1280 float dist = std::sqrt(
dx*
dx +
dy*
dy + dz*dz);
1282 if (dist < minDist)
it = vlm2.erase(
it);
1289 for (std::size_t
it1 = 0;
it1 < vlm2.size() - 1; ++
it1) {
1290 std::size_t it2 =
it1 + 1;
1292 int src = vlm2.at(
it1).vol_id * 1000 + vlm2.at(
it1).lay_id;
1293 int dst = vlm2.at(it2).vol_id * 1000 + vlm2.at(it2).lay_id;
1296 auto [im1, new1] = m_GBTSTrainingData.insert({
src, {}});
1297 auto [im2, new2] = im1->second.insert({dst, 1
ul});
1298 if (!new2) im2->second++;
1305 tableFile <<
"from,to,probability,flow\n";
1307 unsigned long nTotal = 0;
1308 for (
const auto& [
src, conns] : m_GBTSTrainingData) {
1309 unsigned long nTotalDst = 0;
1310 for (
const auto& [dst,
n] : conns) {
1313 nTotal += nTotalDst;
1314 for (
const auto& [dst,
n] : conns) {
1316 tableFile <<
src <<
", " << dst <<
", " << std::fixed << std::setprecision(6) <<
prob <<
", " <<
prob <<
'\n';