114 return StatusCode::SUCCESS;
124 for (
auto recRoI: collection ) {
125 if ( recRoI->roiWord() == roiWord ){
138 for (
auto recRoI: collection ) {
139 if ( recRoI->roiWord() == roiWord ){
152 ATH_MSG_ERROR(
"You are not supposed to run trigger on RUN2 layout anymore.");
153 return StatusCode::FAILURE;
162 if (!roiCollectionHandle.isValid()){
164 return StatusCode::FAILURE;
169 if (!recRoiCollectionHandle.isValid()){
171 return StatusCode::FAILURE;
174 std::vector< const TrigRoiDescriptor* > internalRoI;
178 for(; p_roids != p_roidsEn; ++p_roids ) {
179 internalRoI.push_back(*p_roids);
180 ATH_MSG_DEBUG(
"REGTEST: " <<
m_roiCollectionKey.key() <<
" eta = " <<
"(" << (*p_roids)->etaMinus() <<
")" << (*p_roids)->eta() <<
"(" << (*p_roids)->etaPlus() <<
")");
181 ATH_MSG_DEBUG(
"REGTEST: " <<
m_roiCollectionKey.key() <<
" phi = " <<
"(" << (*p_roids)->phiMinus() <<
")" << (*p_roids)->phi() <<
"(" << (*p_roids)->phiPlus() <<
")");
182 ATH_MSG_DEBUG(
"REGTEST: " <<
m_roiCollectionKey.key() <<
" zed = " <<
"(" << (*p_roids)->zedMinus() <<
")" << (*p_roids)->zed() <<
"(" << (*p_roids)->zedPlus() <<
")");
187 std::vector< const xAOD::MuonRoI* > recRoIVector;
188 std::vector< const xAOD::MuonRoI* > surrRoIs;
192 if( recRoI ==
nullptr )
continue;
193 recRoIVector.push_back(recRoI);
198 bool dynamicDeltaRpc =
false;
199 int nPassedBarrelSurrRoi = 0;
201 for(
const auto recRoI: *recRoiCollection ){
202 if(std::find(recRoIVector.begin(), recRoIVector.end(), recRoI) != recRoIVector.end())
continue;
204 bool surrounding =
false;
205 for(
const auto matchedRoI: recRoIVector ){
206 float deta = std::abs(recRoI->eta() - matchedRoI->eta());
207 float dphi = std::abs(recRoI->phi() - matchedRoI->phi());
208 if( dphi >
M_PI )dphi = 2.*
M_PI - dphi;
214 surrRoIs.push_back(recRoI);
218 for(
const auto recRoI: surrRoIs ){
220 if( std::abs((recRoI)->
eta()) <= 1.05 && (recRoI)->getThrNumber() >= 1 )nPassedBarrelSurrRoi++;
222 ATH_MSG_DEBUG(
"nPassedBarrelSurrRoi = " << nPassedBarrelSurrRoi);
224 if( nPassedBarrelSurrRoi >= 1 )
225 dynamicDeltaRpc =
true;
230 ATH_CHECK(muFastContainer.record(std::make_unique<xAOD::L2StandAloneMuonContainer>(), std::make_unique<xAOD::L2StandAloneMuonAuxContainer>()));
232 auto muCompositeContainer = std::make_unique<xAOD::TrigCompositeContainer>();
233 auto muCompositeAuxContainer = std::make_unique<xAOD::TrigCompositeAuxContainer>();
234 muCompositeContainer->setStore(muCompositeAuxContainer.get());
237 ATH_CHECK(muIdContainer.record(std::make_unique<TrigRoiDescriptorCollection>()));
240 ATH_CHECK(muMsContainer.record(std::make_unique<TrigRoiDescriptorCollection>()));
248 ATH_CHECK( muonCBColl.record (std::make_unique<xAOD::L2CombinedMuonContainer>(),
249 std::make_unique<xAOD::L2CombinedMuonAuxContainer>()) );
252 if (!trackHandle.isValid()){
254 return StatusCode::FAILURE;
259 *muonCBColl, *muFastContainer, dynamicDeltaRpc, ctx ));
263 for (
const auto p_CBmuon : *muonCBColl){
275 *muFastContainer, muCompositeContainer.get(), *muIdContainer, *muMsContainer, dynamicDeltaRpc, ctx));
280 ATH_CHECK(wh_muCompositeCont.
record(std::move(muCompositeContainer), std::move(muCompositeAuxContainer)));
288 for (
auto p_muon : *muFastContainer) {
294 for (
auto p_muonID : *muIdContainer) {
295 ATH_MSG_DEBUG(
"REGTEST: TrigRoiDescriptorCollection key:" <<
m_muIdContainerKey.key() <<
" eta/phi = " << (*p_muonID).eta() <<
"/" << (*p_muonID).phi());
299 for (
auto p_muonMS : *muMsContainer) {
300 ATH_MSG_DEBUG(
"REGTEST: TrigRoiDescriptorCollection key:" <<
m_muMsContainerKey.key() <<
" eta/phi = " << (*p_muonMS).eta() <<
"/" << (*p_muonMS).phi());
304 ATH_MSG_DEBUG(
"StatusCode MuFastSteering::execute(const EventContext& ctx) success");
305 return StatusCode::SUCCESS;
312 const std::vector<const xAOD::MuonRoI*>& muonRoIs,
317 const bool dynamicDeltaRpc,
318 const EventContext& ctx)
const
320 ATH_MSG_DEBUG(
"StatusCode MuFastSteering::findMuonSignature start");
321 StatusCode
sc = StatusCode::SUCCESS;
331 trackFitterTimer, trackExtraTimer, calibrationTimer );
348 p_roids = roids.begin();
349 for (p_roi=(muonRoIs).begin(); p_roi!=(muonRoIs).end(); ++p_roi) {
352 std::vector<TrigL2MuonSA::TrackPattern> trackPatterns;
357 rpcFitResult.
Clear();
358 tgcFitResult.
Clear();
382 if (!
sc.isSuccess()) {
385 trackPatterns.push_back(std::move(trackPattern));
388 rpcFitResult, tgcFitResult, mdtHits, cscHits,
390 trackPatterns, outputTracks, outputID, outputMS, ctx);
396 patternTimer.start();
401 if (!
sc.isSuccess()) {
405 rpcFitResult, tgcFitResult, mdtHits, cscHits,
407 trackPatterns, outputTracks, outputID, outputMS, ctx);
413 stationFitterTimer.start();
417 if (!
sc.isSuccess()) {
421 rpcFitResult, tgcFitResult, mdtHits, cscHits,
423 trackPatterns, outputTracks, outputID, outputMS, ctx);
426 stationFitterTimer.stop();
429 trackFitterTimer.start();
434 if (!
sc.isSuccess()) {
438 rpcFitResult, tgcFitResult, mdtHits, cscHits,
440 trackPatterns, outputTracks, outputID, outputMS, ctx);
443 trackFitterTimer.stop();
463 if (!
sc.isSuccess()) {
466 trackPatterns.push_back(std::move(trackPattern));
469 rpcFitResult, tgcFitResult, mdtHits, cscHits,
471 trackPatterns, outputTracks, outputID, outputMS, ctx);
477 patternTimer.start();
485 if (!
sc.isSuccess()) {
489 rpcFitResult, tgcFitResult, mdtHits, cscHits,
491 trackPatterns, outputTracks, outputID, outputMS, ctx);
497 stationFitterTimer.start();
515 m_cscsegmaker->FindSuperPointCsc(cscHits,trackPatterns,tgcFitResult,muonRoad);
517 if (!
sc.isSuccess()) {
521 rpcFitResult, tgcFitResult, mdtHits, cscHits,
523 trackPatterns, outputTracks, outputID, outputMS, ctx);
527 stationFitterTimer.stop();
530 trackFitterTimer.start();
536 if (!
sc.isSuccess()) {
540 rpcFitResult, tgcFitResult, mdtHits, cscHits,
542 trackPatterns, outputTracks, outputID, outputMS, ctx);
545 trackFitterTimer.stop();
549 const float ETA_LIMIT = 2.8;
550 const float DELTA_ETA_LIMIT = 1.0;
553 float roiEta = (*p_roi)->eta();
555 ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
556 track.etaMap = roiEta;
561 trackExtraTimer.start();
565 if (
sc != StatusCode::SUCCESS) {
569 rpcFitResult, tgcFitResult, mdtHits, cscHits,
571 trackPatterns, outputTracks, outputID, outputMS, ctx);
574 trackExtraTimer.stop();
578 if (
sc != StatusCode::SUCCESS) {
582 rpcFitResult, tgcFitResult, mdtHits, cscHits,
584 trackPatterns, outputTracks, outputID, outputMS, ctx);
590 rpcFitResult, tgcFitResult, mdtHits, cscHits,
592 trackPatterns, outputTracks, outputID, outputMS, ctx);
600 std::vector<uint32_t> localBuffer;
606 if (
sc != StatusCode::SUCCESS ) {
609 ATH_MSG_DEBUG(
"Retrieved the buffer, with size: " << localBuffer.size());
615 ATH_MSG_DEBUG(
"The size of the TrigCompositeContainer is: " << outputMuonCal->
size() );
619 return StatusCode::FAILURE;
621 tc->setDetail(
"muCalibDS", localBuffer );
625 if (p_roids==roids.end())
break;
628 ATH_MSG_DEBUG(
"StatusCode MuFastSteering::findMuonSignature success");
629 return StatusCode::SUCCESS;
638 const std::vector<const TrigRoiDescriptor*>& roids,
639 const std::vector<const xAOD::MuonRoI*>& muonRoIs,
642 const bool dynamicDeltaRpc,
643 const EventContext& ctx)
const
645 ATH_MSG_DEBUG(
"StatusCode MuFastSteering::findMuonSignatureIO start");
646 StatusCode
sc = StatusCode::SUCCESS;
657 trackFitterTimer, trackExtraTimer, calibrationTimer );
672 p_roids = roids.begin();
673 for (
const auto p_roi : muonRoIs) {
674 ATH_MSG_DEBUG(
"roi eta/phi: " << (*p_roi).eta() <<
"/" << (*p_roi).phi());
677 if ( (idtracks).
empty() )
ATH_MSG_DEBUG(
"IO TEST: xAOD::TrackParticleContainer has 0 tracks --> Can not use FTF tracks...");
678 else ATH_MSG_DEBUG(
"IO TEST: xAOD::TrackParticleContainer has " << (idtracks).
size() <<
" tracks --> Start inside-out mode!");
680 std::vector<TrigL2MuonSA::TrackPattern> trackPatterns;
681 int idtrack_idx = -1;
682 for (
auto idtrack : idtracks) {
698 rpcFitResult.
Clear();
699 tgcFitResult.
Clear();
704 trackPatterns.clear();
707 if (!
sc.isSuccess()) {
714 if ( std::abs(idtrack->eta()) < 1.05 ){
715 ATH_MSG_DEBUG(
"FTF track at IP is in Barrel: " << idtrack->eta());
717 ATH_MSG_DEBUG(
"FTF track at IP is in Endcap: " << idtrack->eta());
740 if (!
sc.isSuccess()) {
749 patternTimer.start();
754 if (!
sc.isSuccess()) {
761 stationFitterTimer.start();
765 if (!
sc.isSuccess()) {
769 stationFitterTimer.stop();
772 trackFitterTimer.start();
776 if (!
sc.isSuccess()) {
780 trackFitterTimer.stop();
800 if (!
sc.isSuccess()) {
809 patternTimer.start();
816 if (!
sc.isSuccess()) {
823 stationFitterTimer.start();
831 m_cscsegmaker->FindSuperPointCsc(cscHits,trackPatterns,tgcFitResult,muonRoad);
832 if (!
sc.isSuccess()) {
836 stationFitterTimer.stop();
839 trackFitterTimer.start();
844 if (!
sc.isSuccess()) {
848 trackFitterTimer.stop();
854 const float ETA_LIMIT = 2.8;
855 const float DELTA_ETA_LIMIT = 1.0;
856 float roiEta = (*p_roi).eta();
858 && ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
859 trackPatterns.back().etaMap = roiEta;
864 if (
sc != StatusCode::SUCCESS) {
869 if ( std::abs(trackPatterns.back().pt) >
ZERO_LIMIT ) {
870 storeMuonSA(p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
871 rpcFitResult, tgcFitResult, mdtHits, cscHits,
873 trackPatterns.back(), outputSAs, ctx);
875 muonCB->makePrivateStore();
878 muonCB->
setPt(idtrack->pt());
879 muonCB->
setEta(idtrack->eta());
880 muonCB->
setPhi(idtrack->phi());
891 if(outputSAs.
empty()) {
897 rpcFitResult.
Clear();
898 tgcFitResult.
Clear();
903 trackPatterns.clear();
905 storeMuonSA(p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
906 rpcFitResult, tgcFitResult, mdtHits, cscHits,
908 trackPattern, outputSAs, ctx);
910 ATH_MSG_ERROR(
"outputSAs is still empty after attempted dummy store.");
911 return StatusCode::FAILURE;
914 muonCB->makePrivateStore();
928 for (
auto outputSA : outputSAs){
929 ATH_MSG_DEBUG(
"outputSA pt/eta/phi: " << outputSA->pt() <<
"/" << outputSA->etaMS() <<
"/" << outputSA->phiMS());
933 for (
auto outputCB : outputCBs){
934 ATH_MSG_DEBUG(
"outputCB pt/eta/phi: " << outputCB->pt() <<
"/" << outputCB->eta() <<
"/" << outputCB->phi());
938 if (p_roids==roids.end())
break;
941 ATH_MSG_DEBUG(
"StatusCode MuFastSteering::findMuonSignatureIO success");
942 return StatusCode::SUCCESS;
950 const std::vector<const xAOD::MuonRoI*>& muonRoIs,
952 const bool dynamicDeltaRpc,
953 const EventContext& ctx)
const
955 ATH_MSG_DEBUG(
"StatusCode MuFastSteering::findMultiTrackSignature start");
956 StatusCode
sc = StatusCode::SUCCESS;
960 std::vector<TrigL2MuonSA::RpcFitResult> clusterFitResults;
961 std::vector< TrigL2MuonSA::MuonRoad > clusterRoad;
962 std::vector<TrigL2MuonSA::MdtHits> mdtHits_cluster_normal;
973 trackFitterTimer, trackExtraTimer, calibrationTimer );
990 p_roids = roids.begin();
991 for (p_roi=(muonRoIs).begin(); p_roi!=(muonRoIs).end(); ++p_roi) {
994 std::vector<TrigL2MuonSA::TrackPattern> trackPatterns;
999 rpcFitResult.
Clear();
1000 tgcFitResult.
Clear();
1006 clusterFitResults.clear();
1007 clusterRoad.clear();
1008 mdtHits_cluster_normal.clear();
1024 mdtHits_cluster_normal,
1027 if (!
sc.isSuccess()) {
1035 for(
unsigned int i_road = 0; i_road < clusterRoad.size(); i_road++){
1037 std::vector<TrigL2MuonSA::TrackPattern> tmp_trkPats; tmp_trkPats.clear();
1039 patternTimer.start();
1041 clusterRoad.at(i_road),
1042 mdtHits_cluster_normal.at(i_road),
1044 if (!
sc.isSuccess()) {
1048 patternTimer.stop();
1051 stationFitterTimer.start();
1053 clusterFitResults.at(i_road),
1055 if (!
sc.isSuccess()) {
1060 stationFitterTimer.stop();
1063 trackFitterTimer.start();
1065 clusterFitResults.at(i_road),
1068 if (!
sc.isSuccess()) {
1072 trackFitterTimer.stop();
1075 const float ETA_LIMIT = 2.8;
1076 const float DELTA_ETA_LIMIT = 1.0;
1078 float roiEta = (*p_roi)->eta();
1080 && ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
1081 track.etaMap = roiEta;
1086 trackExtraTimer.start();
1091 if (
sc != StatusCode::SUCCESS) {
1096 trackExtraTimer.stop();
1098 if(tmp_trkPats.size() > 0){
1099 ATH_MSG_DEBUG(
"temp pT calculated 2mu-in-1RoI alg = " << tmp_trkPats[0].pt <<
" GeV");
1100 if( (std::abs(tmp_trkPats[0].barrelSagitta) <
ZERO_LIMIT &&
1101 std::abs(tmp_trkPats[0].barrelRadius) <
ZERO_LIMIT) ||
1104 trackPatterns.push_back(tmp_trkPats[0]);
1107 storeMuonSA(*p_roi, *p_roids, clusterRoad.at(i_road), mdtRegion, rpcHits, tgcHits,
1108 clusterFitResults.at(i_road), tgcFitResult, mdtHits_cluster_normal.at(i_road), cscHits,
1109 stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1112 if(trackPatterns.empty()){
1113 ATH_MSG_DEBUG(
"multi-track SA falied to reconstruct muons");
1114 trackPatterns.emplace_back();
1115 storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1116 rpcFitResult, tgcFitResult, mdtHits, cscHits,
1117 stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1124 ATH_MSG_DEBUG(
"multi-track SA does nothings and skips for EndcapRoI");
1140 if (!
sc.isSuccess()) {
1142 trackPatterns.emplace_back();
1144 storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1145 rpcFitResult, tgcFitResult, mdtHits, cscHits,
1146 stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1152 patternTimer.start();
1162 if (!
sc.isSuccess()) {
1165 storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1166 rpcFitResult, tgcFitResult, mdtHits, cscHits,
1167 stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1170 patternTimer.stop();
1173 stationFitterTimer.start();
1190 m_cscsegmaker->FindSuperPointCsc(cscHits,trackPatterns,tgcFitResult,muonRoad);
1192 if (!
sc.isSuccess()) {
1194 storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1195 rpcFitResult, tgcFitResult, mdtHits, cscHits,
1196 stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1200 stationFitterTimer.stop();
1203 trackFitterTimer.start();
1209 if (!
sc.isSuccess()) {
1211 storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1212 rpcFitResult, tgcFitResult, mdtHits, cscHits,
1213 stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1216 trackFitterTimer.stop();
1219 const float ETA_LIMIT = 2.8;
1220 const float DELTA_ETA_LIMIT = 1.0;
1222 float roiEta = (*p_roi)->eta();
1224 && ( std::abs(track.etaMap) > ETA_LIMIT || std::abs(track.etaMap-roiEta) > DELTA_ETA_LIMIT ) ) {
1225 track.etaMap = roiEta;
1230 trackExtraTimer.start();
1234 if (
sc != StatusCode::SUCCESS) {
1236 storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1237 rpcFitResult, tgcFitResult, mdtHits, cscHits,
1238 stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1241 trackExtraTimer.stop();
1243 storeMuonSA(*p_roi, *p_roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1244 rpcFitResult, tgcFitResult, mdtHits, cscHits,
1245 stgcHits, mmHits, trackPatterns.back(), outputTracks, ctx);
1250 if (
sc != StatusCode::SUCCESS) {
1255 if (p_roids==roids.end())
break;
1258 ATH_MSG_DEBUG(
"StatusCode MuFastSteering::findMultiTrackSignature success");
1259 return StatusCode::SUCCESS;
1277 const std::vector<TrigL2MuonSA::TrackPattern>& trackPatterns,
1281 const EventContext& ctx)
const
1284 if( trackPatterns.size() > 0 ) {
1289 storeMuonSA(roi, roids, muonRoad, mdtRegion, rpcHits, tgcHits,
1290 rpcFitResult, tgcFitResult, mdtHits, cscHits,
1292 pattern, outputTracks, ctx);
1297 ATH_MSG_DEBUG(
"Not update output objects because trackPatterns has no object");
1317 const EventContext& ctx )
const
1321 const int currentRoIId = roids->
roiId();
1323 const EventIDBase& eventID = ctx.eventID();
1325 if (!eventInfo.isValid()) {
1335 int barrelinner = 0;
1336 int endcapinner = 3;
1342 if (pattern.s_address==-1) {
1357 ATH_MSG_DEBUG(
"### Hit patterns at the Muon Spectrometer ###");
1358 ATH_MSG_DEBUG(
"pattern#0: # of hits at inner =" << pattern.mdtSegments[inner].size());
1359 ATH_MSG_DEBUG(
"pattern#0: # of hits at middle =" << pattern.mdtSegments[middle].size());
1360 ATH_MSG_DEBUG(
"pattern#0: # of hits at outer =" << pattern.mdtSegments[outer].size());
1361 if (pattern.s_address==-1){
1362 ATH_MSG_DEBUG(
"pattern#0: # of hits at ee =" << pattern.mdtSegments[ee].size());
1363 ATH_MSG_DEBUG(
"pattern#0: # of hits at endcap barrel inner =" << pattern.mdtSegments[barrelinner].size());
1364 ATH_MSG_DEBUG(
"pattern#0: # of hits at BEE =" << pattern.mdtSegments[bee].size());
1366 ATH_MSG_DEBUG(
"pattern#0: # of hits at BME =" << pattern.mdtSegments[bme].size());
1367 ATH_MSG_DEBUG(
"pattern#0: # of hits at barrel endcap inner =" << pattern.mdtSegments[endcapinner].size());
1369 ATH_MSG_DEBUG(
"### ************************************* ###");
1370 ATH_MSG_DEBUG(
"Estimated muon pt = " << pattern.pt <<
" GeV");
1376 muonSA->makePrivateStore();
1379 muonSA->
setPt(pattern.pt*pattern.charge);
1383 muonSA->
setPtCSC(pattern.ptCSC*pattern.charge);
1385 muonSA->
setEta(pattern.etaVtx);
1386 muonSA->
setPhi(pattern.phiVtx);
1398 muonSA->
setRMS(pattern.superPoints[inner].R);
1399 muonSA->
setZMS(pattern.superPoints[inner].Z);
1400 muonSA->
setDirZMS(pattern.superPoints[inner].Alin);
1422 muonSA->
setSuperPoint(inner, pattern.superPoints[inner].R, pattern.superPoints[inner].Z,
1423 pattern.superPoints[inner].Alin, pattern.superPoints[inner].Blin, pattern.superPoints[inner].Chi2);
1424 muonSA->
setSuperPoint(middle, pattern.superPoints[middle].R, pattern.superPoints[middle].Z,
1425 pattern.superPoints[middle].Alin, pattern.superPoints[middle].Blin, pattern.superPoints[middle].Chi2);
1426 muonSA->
setSuperPoint(outer, pattern.superPoints[outer].R, pattern.superPoints[outer].Z,
1427 pattern.superPoints[outer].Alin, pattern.superPoints[outer].Blin, pattern.superPoints[outer].Chi2);
1428 if (pattern.s_address==-1){
1429 muonSA->
setSuperPoint(ee, pattern.superPoints[ee].R, pattern.superPoints[ee].Z,
1430 pattern.superPoints[ee].Alin, pattern.superPoints[ee].Blin, pattern.superPoints[ee].Chi2);
1431 muonSA->
setSuperPoint(barrelinner, pattern.superPoints[barrelinner].R, pattern.superPoints[barrelinner].Z,
1432 pattern.superPoints[barrelinner].Alin, pattern.superPoints[barrelinner].Blin, pattern.superPoints[barrelinner].Chi2);
1433 muonSA->
setSuperPoint(csc, pattern.superPoints[csc].R, pattern.superPoints[csc].Z,
1434 pattern.superPoints[csc].Alin, pattern.superPoints[csc].Blin, pattern.superPoints[csc].Chi2);
1436 muonSA->
setSuperPoint(endcapinner, pattern.superPoints[endcapinner].R, pattern.superPoints[endcapinner].Z,
1437 pattern.superPoints[endcapinner].Alin, pattern.superPoints[endcapinner].Blin, pattern.superPoints[endcapinner].Chi2);
1443 uint32_t muondetmask = 0;
1450 muonSA->
setLvl1Id( eventInfo->extendedLevel1ID() );
1483 std::vector<std::string> mdtId;
1485 if ( mdtHit.isOutlier==0 || mdtHit.isOutlier==1 ) {
1486 muonSA->
setMdtHit(mdtHit.OnlineId, mdtHit.isOutlier, mdtHit.Chamber,
1487 mdtHit.R, mdtHit.Z, mdtHit.cPhi0, mdtHit.Residual,
1488 mdtHit.DriftTime, mdtHit.DriftSpace, mdtHit.DriftSigma);
1489 mdtId.push_back(mdtHit.Id.getString());
1493 accessor_mdthitid( *muonSA ) = std::move(mdtId);
1496 std::vector<float> cscResol;
1499 if ( cscHit.isOutlier==0 || cscHit.isOutlier==1 ) {
1500 muonSA->
setCscHit(cscHit.isOutlier, cscHit.Chamber, cscHit.StationName,
1501 cscHit.StationEta, cscHit.StationPhi,
1502 cscHit.ChamberLayer, cscHit.WireLayer, cscHit.MeasuresPhi, cscHit.Strip,
1503 cscHit.eta, cscHit.phi, cscHit.r, cscHit.z,
1504 cscHit.charge, cscHit.time, cscHit.Residual);
1505 cscResol.push_back(cscHit.resolution);
1507 <<
"OL=" << cscHit.isOutlier <<
","
1508 <<
"Ch=" << cscHit.Chamber <<
","
1509 <<
"StationName=" << cscHit.StationName <<
","
1510 <<
"StationEta=" << cscHit.StationEta <<
","
1511 <<
"StationPhi=" << cscHit.StationPhi <<
","
1512 <<
"ChamberLayer=" << cscHit.ChamberLayer <<
","
1513 <<
"WireLayer=" << cscHit.WireLayer <<
","
1514 <<
"MeasuresPhi=" << cscHit.MeasuresPhi <<
","
1515 <<
"Strip=" << cscHit.Strip <<
","
1516 <<
"eta=" << cscHit.eta <<
","
1517 <<
"phi=" << cscHit.phi <<
","
1518 <<
"r=" << cscHit.r <<
","
1519 <<
"z=" << cscHit.z <<
","
1520 <<
"charge=" << cscHit.charge <<
","
1521 <<
"Rs=" << cscHit.Residual <<
","
1522 <<
"t=" << cscHit.time);
1527 accessor_cschitresol( *muonSA ) = std::move(cscResol);
1530 float sumbeta[8]={0};
1531 float nhit_layer[8]={0};
1533 muonSA->
setRpcHit(rpcHit.layer, rpcHit.measuresPhi,
1534 rpcHit.x, rpcHit.y, rpcHit.z,
1535 rpcHit.time, rpcHit.distToEtaReadout, rpcHit.distToPhiReadout,
1536 rpcHit.stationName);
1538 <<
"stationName=" << rpcHit.stationName <<
","
1539 <<
"layer=" << rpcHit.layer <<
","
1540 <<
"measuresPhi=" << rpcHit.measuresPhi <<
","
1541 <<
"x=" << rpcHit.x <<
","
1542 <<
"y=" << rpcHit.y <<
","
1543 <<
"y=" << rpcHit.z);
1545 float dRMS = std::sqrt( std::abs(pattern.etaMap-rpcHit.eta)*std::abs(pattern.etaMap-rpcHit.eta) + std::acos(std::cos(pattern.phiMS-rpcHit.phi))*std::acos(std::cos(pattern.phiMS-rpcHit.phi)) );
1546 if(dRMS>0.05)
continue;
1547 float muToF = rpcHit.l/1000/(CLHEP::c_light/1000);
1548 float Tprop = rpcHit.distToPhiReadout/1000*4.8;
1549 float beta = rpcHit.l/1000/(muToF+rpcHit.time-Tprop+3.125/2)/(CLHEP::c_light/1000);
1550 sumbeta[rpcHit.layer]=sumbeta[rpcHit.layer]+beta;
1551 nhit_layer[rpcHit.layer]=nhit_layer[rpcHit.layer]+1;
1554 std::vector<float> Avebeta_layer;
1555 for(
int i_layer=0;i_layer<8;i_layer++){
1556 if(nhit_layer[i_layer]!=0)Avebeta_layer.push_back( sumbeta[i_layer]/nhit_layer[i_layer] );
1558 if(Avebeta_layer.size()>0) muonSA->
setBeta( std::accumulate(Avebeta_layer.begin(),Avebeta_layer.end(),0.0)/Avebeta_layer.size() );
1560 Avebeta_layer.clear();
1564 muonSA->
setTgcHit(tgcHit.eta, tgcHit.phi, tgcHit.r, tgcHit.z,
1565 tgcHit.width, tgcHit.sta, tgcHit.isStrip,
1566 tgcHit.bcTag, tgcHit.inRoad);
1568 <<
"eta=" << tgcHit.eta <<
","
1569 <<
"phi=" << tgcHit.phi <<
","
1570 <<
"r=" << tgcHit.r <<
","
1571 <<
"z=" << tgcHit.z <<
","
1572 <<
"width=" << tgcHit.width <<
","
1573 <<
"stationNum=" << tgcHit.sta <<
","
1574 <<
"isStrip=" << tgcHit.isStrip <<
","
1575 <<
"bcTag=" << tgcHit.bcTag <<
","
1576 <<
"inRoad=" << tgcHit.inRoad);
1581 for(
unsigned int i_hit=0; i_hit<stgcHits.size(); i_hit++) {
1582 if ( stgcHits[i_hit].isOutlier==0 || stgcHits[i_hit].isOutlier==1 ) {
1585 muonSA->
setStgcCluster(stgcHits[i_hit].layerNumber, stgcHits[i_hit].isOutlier, stgcHits[i_hit].channelType,
1586 stgcHits[i_hit].
eta, stgcHits[i_hit].
phi, stgcHits[i_hit].
r, stgcHits[i_hit].
z,
1587 stgcHits[i_hit].ResidualR, stgcHits[i_hit].ResidualPhi,
1588 stgcHits[i_hit].stationEta, stgcHits[i_hit].stationPhi, stgcHits[i_hit].stationName);
1591 <<
"eta=" << stgcHits[i_hit].
eta <<
","
1592 <<
"phi=" << stgcHits[i_hit].
phi <<
","
1593 <<
"r=" << stgcHits[i_hit].
r <<
","
1594 <<
"z=" << stgcHits[i_hit].
z <<
","
1595 <<
"z=" << stgcHits[i_hit].ResidualR <<
","
1596 <<
"z=" << stgcHits[i_hit].ResidualPhi);
1601 for(
unsigned int i_hit=0; i_hit<mmHits.size(); i_hit++) {
1602 if ( mmHits[i_hit].isOutlier==0 || mmHits[i_hit].isOutlier==1 ) {
1605 muonSA->
setMmCluster(mmHits[i_hit].layerNumber, mmHits[i_hit].isOutlier,
1606 mmHits[i_hit].
eta, mmHits[i_hit].
phi, mmHits[i_hit].
r, mmHits[i_hit].
z,
1607 mmHits[i_hit].ResidualR, mmHits[i_hit].ResidualPhi,
1608 mmHits[i_hit].stationEta, mmHits[i_hit].stationPhi, mmHits[i_hit].stationName);
1611 <<
"eta=" << tgcHits[i_hit].
eta <<
","
1612 <<
"phi=" << tgcHits[i_hit].
phi <<
","
1613 <<
"r=" << tgcHits[i_hit].
r <<
","
1614 <<
"z=" << tgcHits[i_hit].
z <<
","
1615 <<
"width=" << tgcHits[i_hit].
width <<
","
1616 <<
"stationNum=" << tgcHits[i_hit].sta <<
","
1617 <<
"isStrip=" << tgcHits[i_hit].isStrip <<
","
1618 <<
"bcTag=" << tgcHits[i_hit].
bcTag <<
","
1619 <<
"inRoad=" << tgcHits[i_hit].inRoad);
1624 for (
int i_station=0; i_station<8; i_station++) {
1625 for (
int i_sector=0; i_sector<2; i_sector++) {
1626 muonSA->
setRoad(i_station, i_sector, muonRoad.
aw[i_station][i_sector], muonRoad.
bw[i_station][i_sector]);
1627 muonSA->
setRegionZ(i_station, i_sector, mdtRegion.
zMin[i_station][i_sector], mdtRegion.
zMax[i_station][i_sector]);
1628 muonSA->
setRegionR(i_station, i_sector, mdtRegion.
rMin[i_station][i_sector], mdtRegion.
rMax[i_station][i_sector]);
1629 muonSA->
setRegionEta(i_station, i_sector, mdtRegion.
etaMin[i_station][i_sector], mdtRegion.
etaMax[i_station][i_sector]);
1664 if (pattern.s_address==-1) {
1667 if ( std::abs(pattern.superPoints[inner].R) >
ZERO_LIMIT && std::abs(pattern.superPoints[inner].Z) >
ZERO_LIMIT ) {
1669 float theta = std::atan(pattern.superPoints[inner].R/std::abs(pattern.superPoints[inner].Z));
1670 float eta = (std::tan(
theta/2.)!=0.)? -std::log(std::tan(
theta/2.))*pattern.superPoints[inner].Z/std::abs(pattern.superPoints[inner].Z): 0.;
1676 if ( std::abs(pattern.superPoints[middle].R) >
ZERO_LIMIT && std::abs(pattern.superPoints[middle].Z) >
ZERO_LIMIT ) {
1679 double phi1 = tgcFitResult.
tgcMid1[1];
1680 double phi2 = tgcFitResult.
tgcMid2[1];
1681 if ( tgcFitResult.
tgcMid1[3]==0. || tgcFitResult.
tgcMid2[3]==0. ) {
1684 }
else if( phi1*phi2 < 0 && std::abs(phi1)>(
M_PI/2.) ) {
1685 double tmp1 = (phi1>0)? phi1 -
M_PI : phi1 +
M_PI;
1686 double tmp2 = (phi2>0)? phi2 -
M_PI : phi2 +
M_PI;
1687 double tmp = (tmp1+tmp2)/2.;
1690 phi = (phi2+phi1)/2.;
1695 float theta = std::atan(pattern.superPoints[middle].R/std::abs(pattern.superPoints[middle].Z));
1696 float eta = (std::tan(
theta/2.)!=0.)? -std::log(std::tan(
theta/2.))*pattern.superPoints[middle].Z/std::abs(pattern.superPoints[middle].Z): 0.;
1703 if ( std::abs(pattern.superPoints[middle].R) >
ZERO_LIMIT && std::abs(pattern.superPoints[middle].Z) >
ZERO_LIMIT ) {
1710 float theta = std::atan(pattern.superPoints[middle].R/std::abs(pattern.superPoints[middle].Z));
1711 float eta = (std::tan(
theta/2.)!=0.)? -std::log(std::tan(
theta/2.))*pattern.superPoints[middle].Z/std::abs(pattern.superPoints[middle].Z): 0.;
1733 float mseta = pattern.etaMap;
1734 float msphi = pattern.phiMS;
1738 mseta = roids->
eta();
1739 msphi = roids->
phi();
1743 const float phiHalfWidth = 0.1;
1744 const float etaHalfWidth = 0.1;
1750 mseta - etaHalfWidth,
1751 mseta + etaHalfWidth,
1753 msphi - phiHalfWidth,
1754 msphi + phiHalfWidth);
1758 << mseta <<
"/" << msphi);
1761 <<
" phi=" << MSroiDescriptor->
phi()
1762 <<
", eta=" << MSroiDescriptor->
eta());
1784 const double scalePhiWidthForFailure = 2;
1785 const double scaleRoIforZeroPt = 2;
1793 float phiHalfWidth = 0.1;
1794 float etaHalfWidth = 0.1;
1809 if (pattern.isTgcFailure || pattern.isRpcFailure)
1810 phiHalfWidth *= scalePhiWidthForFailure;
1816 pattern.etaVtx - etaHalfWidth,
1817 pattern.etaVtx + etaHalfWidth,
1819 pattern.phiVtx - phiHalfWidth,
1820 pattern.phiVtx + phiHalfWidth);
1823 <<
"pattern.etaVtx/pattern.phiVtx="
1824 << pattern.etaVtx <<
"/" << pattern.phiVtx);
1827 <<
" phi=" << IDroiDescriptor->
phi()
1828 <<
", eta=" << IDroiDescriptor->
eta());
1838 roids->
eta() - (roids->
eta() - roids->
etaMinus()) * scaleRoIforZeroPt,
1839 roids->
eta() + (roids->
etaPlus() - roids->
eta()) * scaleRoIforZeroPt,
1844 ATH_MSG_VERBOSE(
"will Record an RoiDescriptor for Inner Detector in case with zero pT:"
1845 <<
" phi=" << IDroiDescriptor->
phi()
1846 <<
", phi min=" << IDroiDescriptor->
phiMinus()
1847 <<
", phi max=" << IDroiDescriptor->
phiPlus()
1848 <<
", eta=" << IDroiDescriptor->
eta()
1849 <<
", eta min=" << IDroiDescriptor->
etaMinus()
1850 <<
", eta max=" << IDroiDescriptor->
etaPlus());
1865 if (name ==
"MuFastSteering_Muon") {
1867 }
else if (name ==
"MuFastSteering_900GeV") {
1881 bool isBarrel = (muonSA->
sAddress()==-1) ? true :
false;
1884 float pt = muonSA->
pt();
1887 const int N_PARAMS = 2;
1890 const float etaMinWin_brl = 0.10;
1891 const float etaMinWin_ec1 = 0.10;
1892 const float etaMinWin_ec2 = 0.10;
1893 const float etaMinWin_ec3 = 0.10;
1894 const float etaMinWin_ecA = 0.10;
1895 const float etaMinWin_ecB = 0.10;
1897 const float etaMaxWin_brl = 0.20;
1898 const float etaMaxWin_ec1 = 0.20;
1899 const float etaMaxWin_ec2 = 0.20;
1900 const float etaMaxWin_ec3 = 0.20;
1901 const float etaMaxWin_ecA = 0.20;
1902 const float etaMaxWin_ecB = 0.20;
1904 const float etaParams_brl[N_PARAMS] = { 0.038, 0.284};
1905 const float etaParams_ec1[N_PARAMS] = { 0.011, 0.519};
1906 const float etaParams_ec2[N_PARAMS] = { 0.023, 0.253};
1907 const float etaParams_ec3[N_PARAMS] = { 0.018, 0.519};
1908 const float etaParams_ecA[N_PARAMS] = { 0.010, 0.431};
1909 const float etaParams_ecB[N_PARAMS] = { 0.023, 0.236};
1912 const float phiMinWin_brl = 0.125;
1913 const float phiMinWin_ec1 = 0.125;
1914 const float phiMinWin_ec2 = 0.125;
1915 const float phiMinWin_ec3 = 0.10;
1916 const float phiMinWin_ecA = 0.15;
1917 const float phiMinWin_ecB = 0.15;
1919 const float phiMaxWin_brl = 0.20;
1920 const float phiMaxWin_ec1 = 0.20;
1921 const float phiMaxWin_ec2 = 0.20;
1922 const float phiMaxWin_ec3 = 0.20;
1923 const float phiMaxWin_ecA = 0.25;
1924 const float phiMaxWin_ecB = 0.20;
1926 const float phiParams_brl[N_PARAMS] = { 0.000, 0.831};
1927 const float phiParams_ec1[N_PARAMS] = { 0.000, 0.885};
1928 const float phiParams_ec2[N_PARAMS] = { 0.015, 0.552};
1929 const float phiParams_ec3[N_PARAMS] = { 0.008, 0.576};
1930 const float phiParams_ecA[N_PARAMS] = { 0.000, 0.830};
1931 const float phiParams_ecB[N_PARAMS] = { 0.006, 1.331};
1936 float params[N_PARAMS];
1939 memcpy(params,etaParams_brl,
sizeof(params));
1940 minWin = etaMinWin_brl;
1941 maxWin = etaMaxWin_brl;
1944 memcpy(params,phiParams_brl,
sizeof(params));
1945 minWin = phiMinWin_brl;
1946 maxWin = phiMaxWin_brl;
1954 memcpy(params,etaParams_ecA,
sizeof(params));
1955 minWin = etaMinWin_ecA;
1956 maxWin = etaMaxWin_ecA;
1959 memcpy(params,phiParams_ecA,
sizeof(params));
1960 minWin = phiMinWin_ecA;
1961 maxWin = phiMaxWin_ecA;
1966 memcpy(params,etaParams_ecB,
sizeof(params));
1967 minWin = etaMinWin_ecB;
1968 maxWin = etaMaxWin_ecB;
1971 memcpy(params,phiParams_ecB,
sizeof(params));
1972 minWin = phiMinWin_ecB;
1973 maxWin = phiMaxWin_ecB;
1977 if( std::abs(
eta) < 1.5 ) {
1979 memcpy(params,etaParams_ec1,
sizeof(params));
1980 minWin = etaMinWin_ec1;
1981 maxWin = etaMaxWin_ec1;
1984 memcpy(params,phiParams_ec1,
sizeof(params));
1985 minWin = phiMinWin_ec1;
1986 maxWin = phiMaxWin_ec1;
1989 else if( std::abs(
eta) < 2.0 ) {
1991 memcpy(params,etaParams_ec2,
sizeof(params));
1992 minWin = etaMinWin_ec2;
1993 maxWin = etaMaxWin_ec2;
1996 memcpy(params,phiParams_ec2,
sizeof(params));
1997 minWin = phiMinWin_ec2;
1998 maxWin = phiMaxWin_ec2;
2003 memcpy(params,etaParams_ec3,
sizeof(params));
2004 minWin = etaMinWin_ec3;
2005 maxWin = etaMaxWin_ec3;
2008 memcpy(params,phiParams_ec3,
sizeof(params));
2009 minWin = phiMinWin_ec3;
2010 maxWin = phiMaxWin_ec3;
2017 float x = params[0] + params[1] / pt;
2019 if(
x < minWin ) retval = minWin;
2020 if(
x > maxWin ) retval = maxWin;
2030 std::vector<TrigL2MuonSA::TrackPattern>& trackPatterns )
const
2045 std::vector<float> t_eta, t_phi;
2046 std::vector<float> f_eta, f_phi;
2047 std::vector<float> r_inner, r_middle, r_outer;
2048 std::vector<float> f_residuals;
2060 invalid_rpc_roi_number,
2061 efficiency, sag_inverse, address, absolute_pt, sagitta, track_pt,
2062 track_eta, track_phi, failed_eta, failed_phi,
2063 res_inner, res_middle, res_outer, fit_residuals );
2067 if( !trackPatterns.empty() ) {
2074 float count_inner = 0;
2075 float count_middle = 0;
2076 float count_outer = 0;
2080 if (std::abs(mdtHit.DriftSpace) <
ZERO_LIMIT)
continue;
2082 char st = mdtHit.cType[1];
2086 r_inner.push_back(mdtHit.Residual/norm);
2087 if (mdtHit.isOutlier==0) f_residuals.push_back(mdtHit.Residual/norm);
2092 r_middle.push_back(mdtHit.Residual/norm);
2093 if (mdtHit.isOutlier==0) f_residuals.push_back(mdtHit.Residual/norm);
2098 r_outer.push_back(mdtHit.Residual/norm);
2099 if (mdtHit.isOutlier==0) f_residuals.push_back(mdtHit.Residual/norm);
2103 inner_mdt_hits = count_inner;
2104 middle_mdt_hits = count_middle;
2105 outer_mdt_hits = count_outer;
2107 track_pt = (std::abs(pattern.pt ) >
ZERO_LIMIT)? pattern.charge*pattern.pt: 9999.;
2108 absolute_pt = std::abs(track_pt);
2111 t_eta.push_back(pattern.etaMap);
2112 t_phi.push_back(pattern.phiMS);
2115 f_eta.push_back(roi->
eta());
2116 f_phi.push_back(roi->
phi());
2119 sagitta = (std::abs(pattern.barrelSagitta) >
ZERO_LIMIT)? pattern.barrelSagitta: 9999.;
2120 sag_inverse = (std::abs(pattern.barrelSagitta) >
ZERO_LIMIT)? 1./pattern.barrelSagitta: 9999.;
2121 address = pattern.s_address;
2124 return StatusCode::SUCCESS;
Scalar eta() const
pseudorapidity method
Scalar phi() const
phi method
Scalar theta() const
theta method
#define ATH_CHECK
Evaluate an expression and check for errors.
#define ATH_MSG_DEBUG(x,...)
#define ATH_MSG_ERROR(x,...)
#define ATH_MSG_WARNING(x,...)
#define ATH_MSG_VERBOSE(x,...)
#define ATH_MSG_INFO(x,...)
Header file to be included by clients of the Monitored infrastructure.
const LVL1::RecMuonRoI * matchingRecRoI(uint32_t roiWord, const DataVector< LVL1::RecMuonRoI > &collection)
size_t size() const
Number of registered mappings.
unsigned bcTag(unsigned bcBitMap)
static const Attributes_t empty
bool msgLvl(const MSG::Level lvl) const
An algorithm that can be simultaneously executed in multiple threads.
DataModel_detail::const_iterator< DataVector > const_iterator
const T * at(size_type n) const
Access an element, as an rvalue.
value_type push_back(value_type pElem)
Add an element to the end of the collection.
const_iterator end() const noexcept
Return a const_iterator pointing past the end of the collection.
const_iterator begin() const noexcept
Return a const_iterator pointing at the beginning of the collection.
size_type size() const noexcept
Returns the number of elements in the collection.
bool empty() const noexcept
Returns true if the collection is empty.
ElementLink implementation for ROOT usage.
This class defines the reconstructed Muon ROI.
Group of local monitoring quantities and retain correlation when filling histograms
Declare a monitored scalar variable.
int L2MuonAlgoMap(const std::string &name) const
ToolHandle< GenericMonitoringTool > m_monTool
SG::WriteHandleKey< TrigRoiDescriptorCollection > m_muIdContainerKey
Gaudi::Property< float > m_scaleRoadBarrelMiddle
SG::ReadHandleKey< xAOD::MuonRoIContainer > m_recRoiCollectionKey
Gaudi::Property< bool > m_use_new_segmentfit
Gaudi::Property< bool > m_use_RoIBasedDataAccess_RPC
Gaudi::Property< int > m_esd_mm_size
Gaudi::Property< float > m_dPhisurrRoI
ToolHandle< TrigL2MuonSA::MuCalStreamerTool > m_calStreamer
SG::ReadHandleKey< TrigRoiDescriptorCollection > m_roiCollectionKey
virtual StatusCode initialize() override
Gaudi::Property< int > m_esd_rpc_size
Gaudi::Property< bool > m_use_RoIBasedDataAccess_TGC
Gaudi::Property< bool > m_use_mm
Gaudi::Property< bool > m_fill_FSIDRoI
SG::WriteHandleKey< xAOD::TrigCompositeContainer > m_muCompositeContainerKey
SG::WriteHandleKey< xAOD::L2StandAloneMuonContainer > m_muFastContainerKey
StatusCode findMultiTrackSignature(const std::vector< const TrigRoiDescriptor * > &roi, const std::vector< const xAOD::MuonRoI * > &muonRoIs, DataVector< xAOD::L2StandAloneMuon > &outputTracks, const bool dynamicDeltaRpc, const EventContext &ctx) const
findMultiTrackSignature(), includes reconstract algorithms for multi-track mode
Gaudi::Property< bool > m_insideOut
Gaudi::Property< int > m_esd_csc_size
StatusCode findMuonSignatureIO(const xAOD::TrackParticleContainer &idtracks, const std::vector< const TrigRoiDescriptor * > &roids, const std::vector< const xAOD::MuonRoI * > &muonRoIs, DataVector< xAOD::L2CombinedMuon > &outputCBs, DataVector< xAOD::L2StandAloneMuon > &outputSAs, const bool dynamicDeltaRpc, const EventContext &ctx) const
findMuonSignatureIO(), includes reconstract algorithms for inside-out mode
Gaudi::Property< bool > m_use_RoIBasedDataAccess_MM
Gaudi::Property< bool > m_multiTrack
Gaudi::Property< double > m_rWidth_RPC_Failed
Gaudi::Property< bool > m_use_RoIBasedDataAccess_STGC
Gaudi::Property< float > m_ftfminPt
ToolHandle< TrigL2MuonSA::MuFastTrackFitter > m_trackFitter
Gaudi::Property< float > m_scaleRoadBarrelInner
ToolHandle< TrigL2MuonSA::FtfRoadDefiner > m_ftfRoadDefiner
Gaudi::Property< bool > m_use_endcapInnerFromBarrel
Gaudi::Property< int > m_esd_tgc_size
bool storeIDRoiDescriptor(const TrigRoiDescriptor *roids, const TrigL2MuonSA::TrackPattern &pattern, const DataVector< xAOD::L2StandAloneMuon > &outputTracks, TrigRoiDescriptorCollection &outputID) const
Gaudi::Property< float > m_dEtasurrRoI
Gaudi::Property< int > m_esd_mdt_size
ToolHandle< TrigL2MuonSA::MuFastPatternFinder > m_patternFinder
SG::WriteHandleKey< TrigRoiDescriptorCollection > m_muMsContainerKey
Gaudi::Property< bool > m_calDataScouting
Gaudi::Property< bool > m_use_RoIBasedDataAccess_CSC
ToolHandle< ITrigMuonBackExtrapolator > m_backExtrapolatorTool
Handle to MuonBackExtrapolator tool.
ToolHandle< TrigL2MuonSA::MuFastDataPreparator > m_dataPreparator
Gaudi::Property< bool > m_use_mcLUT
TrigL2MuonSA::RecMuonRoIUtils m_recMuonRoIUtils
ToolHandle< TrigL2MuonSA::CscSegmentMaker > m_cscsegmaker
Gaudi::Property< bool > m_use_rpc
Gaudi::Property< bool > m_topoRoad
SG::ReadHandleKey< DataVector< LVL1::RecMuonRoI > > m_run2recRoiCollectionKey
Gaudi::Property< int > m_esd_stgc_size
SG::WriteHandleKey< xAOD::L2CombinedMuonContainer > m_outputCBmuonCollKey
float getRoiSizeForID(bool isEta, const xAOD::L2StandAloneMuon *muonSA) const
bool updateOutputObjects(const xAOD::MuonRoI *roi, const TrigRoiDescriptor *roids, const TrigL2MuonSA::MuonRoad &muonRoad, const TrigL2MuonSA::MdtRegion &mdtRegion, const TrigL2MuonSA::RpcHits &rpcHits, const TrigL2MuonSA::TgcHits &tgcHits, const TrigL2MuonSA::RpcFitResult &rpcFitResult, const TrigL2MuonSA::TgcFitResult &tgcFitResult, const TrigL2MuonSA::MdtHits &mdtHits, const TrigL2MuonSA::CscHits &cscHits, const TrigL2MuonSA::StgcHits &stgcHits, const TrigL2MuonSA::MmHits &mmHits, const std::vector< TrigL2MuonSA::TrackPattern > &trackPatterns, DataVector< xAOD::L2StandAloneMuon > &outputTracks, TrigRoiDescriptorCollection &outputID, TrigRoiDescriptorCollection &outputMS, const EventContext &ctx) const
Called at the end of the algorithm processing to set the steering navigation properly.
Gaudi::Property< bool > m_use_stgc
Gaudi::Property< float > m_scaleRoadBarrelOuter
Gaudi::Property< bool > m_useRun3Config
Gaudi::Property< double > m_rWidth_TGC_Failed
ToolHandle< TrigL2MuonSA::MuFastTrackExtrapolator > m_trackExtrapolator
ToolHandle< TrigL2MuonSA::MuFastStationFitter > m_stationFitter
StatusCode updateMonitor(const xAOD::MuonRoI *roi, const TrigL2MuonSA::MdtHits &mdtHits, std::vector< TrigL2MuonSA::TrackPattern > &trackPatterns) const
Update monitoring variables.
MuFastSteering(const std::string &name, ISvcLocator *svc)
Constructor.
bool storeMuonSA(const xAOD::MuonRoI *roi, const TrigRoiDescriptor *roids, const TrigL2MuonSA::MuonRoad &muonRoad, const TrigL2MuonSA::MdtRegion &mdtRegion, const TrigL2MuonSA::RpcHits &rpcHits, const TrigL2MuonSA::TgcHits &tgcHits, const TrigL2MuonSA::RpcFitResult &rpcFitResult, const TrigL2MuonSA::TgcFitResult &tgcFitResult, const TrigL2MuonSA::MdtHits &mdtHits, const TrigL2MuonSA::CscHits &cscHits, const TrigL2MuonSA::StgcHits &stgcHits, const TrigL2MuonSA::MmHits &mmHits, const TrigL2MuonSA::TrackPattern &pattern, DataVector< xAOD::L2StandAloneMuon > &outputTracks, const EventContext &ctx) const
SG::ReadHandleKey< xAOD::EventInfo > m_eventInfoKey
Gaudi::Property< bool > m_use_RoIBasedDataAccess_MDT
Gaudi::Property< double > m_winPt
SG::ReadHandleKey< xAOD::TrackParticleContainer > m_FTFtrackKey
StatusCode findMuonSignature(const std::vector< const TrigRoiDescriptor * > &roi, const std::vector< const xAOD::MuonRoI * > &muonRoIs, DataVector< xAOD::L2StandAloneMuon > &outputTracks, xAOD::TrigCompositeContainer *outputMuonCal, TrigRoiDescriptorCollection &outputID, TrigRoiDescriptorCollection &outputMS, const bool dynamicDeltaRpc, const EventContext &ctx) const
findMuonSignature(), includes reconstract algorithms
bool storeMSRoiDescriptor(const TrigRoiDescriptor *roids, const TrigL2MuonSA::TrackPattern &pattern, const DataVector< xAOD::L2StandAloneMuon > &outputTracks, TrigRoiDescriptorCollection &outputMS) const
virtual StatusCode execute(const EventContext &ctx) const override
execute(), main code of the algorithm for AthenaMT
Gaudi::Property< bool > m_doEndcapForl2mt
virtual double etaMinus() const override final
gets eta at zMinus
virtual double etaPlus() const override final
gets eta at zedPlus
virtual double phi() const override final
Methods to retrieve data members.
virtual double phiMinus() const override final
gets phiMinus
virtual double eta() const override final
virtual double phiPlus() const override final
gets phiPlus
Helper class to provide type-safe access to aux data.
StatusCode record(std::unique_ptr< T > data)
Record a const object to the store.
double zMin[N_STATION][N_SECTOR]
double rMin[N_STATION][N_SECTOR]
double zMax[N_STATION][N_SECTOR]
double etaMax[N_STATION][N_SECTOR]
double etaMin[N_STATION][N_SECTOR]
int chamberType[N_STATION][N_SECTOR][2]
double rMax[N_STATION][N_SECTOR]
double aw[N_STATION][N_SECTOR]
void setScales(double inner, double middle, double outer)
double bw[N_STATION][N_SECTOR]
nope - should be used for standalone also, perhaps need to protect the class def bits ifndef XAOD_ANA...
virtual unsigned int roiWord() const override final
virtual unsigned int roiId() const override final
these quantities probably don't need to be used any more
virtual unsigned int l1Id() const override final
void setPt(float pt)
Set the transverse momentum ( ) of the muon.
void setStrategy(int value)
set algorithm strategy flag
void setErrorFlag(int value)
set algorithm error flag
void setIdTrackLink(const ElementLink< xAOD::TrackParticleContainer > &link)
set ID track used to make the CB muon
void setMuSATrackLink(const ElementLink< xAOD::L2StandAloneMuonContainer > &link)
set SA muon used to make the CB muon
void setPhi(float phi)
Set the azimuthal angle ( ) of the muon.
void setEta(float eta)
Set the pseudorapidity ( ) of the muon.
void setCharge(float value)
set seeding muon charge
void setRegionR(int station, int sector, float min, float max)
R range.
void setEta(float eta)
Set the pseudorapidity ( ) of the muon.
void setStgcCluster(const unsigned int layer, const int isOutlier, const int type, const float eta, const float phi, const float r, const float z, const float residualR, const float residualPhi, const int stationEta, const int stationPhi, const int stationName)
Set sTGC hits.
void setBeta(float value)
Set beta.
void setRpcFitInn(float phi, float slope, float offset)
Set the results of RPC fit.
void setPhi(float phi)
Set the azimuthal angle ( ) of the muon.
void setRpcHit(uint32_t layer, uint32_t measuresPhi, float x, float y, float z, float time, float distEta, float distPhi, const std::string &stationName)
Set RPC hits.
void setCscHit(int isOutlier, int chamber, uint32_t stationName, int stationEta, int stationPhi, int chamberLayer, int wireLayer, int measuresPhi, int strip, float eta, float phi, float r, float z, int charge, float time, float residual)
Set the properties of each CSC tube.
void setBarrelSagitta(float value)
Set the fitted sagitta of the muon in the barrel.
int sAddress() const
Get the station address of the muon.
void setDeltaPt(float value)
Set error of pT.
void setEtaMS(float value)
Set the eta at muon spectrometer.
void setMdtHit(uint32_t onlineId, int isOutier, int chamber, float r, float z, float phi, float residual, float time, float space, float sigma)
Set the properties of each MDT tube.
void setTgcInn(float eta, float phi, float r, float z)
Set the results of TGC fit.
void setMmClustersCapacity(const int value)
Set size of storage for MM clusters.
void setDeltaEta(float value)
Set error of eta.
void setRoiSystem(uint32_t value)
void setRoad(int station, int sector, float aw, float bw)
Road.
void setTgcHit(float eta, float phi, float r, float z, float width, int stationNum, bool isStrip, int bcTag, bool inRoad)
Set TGC hits.
void setRoiNumber(uint32_t value)
void setDeltaPhi(float value)
Set error of phi.
void setPtEndcapRadius(float value)
void setTgcMid2(float eta, float phi, float r, float z)
float etaMS() const
Get the eta at muon spectrometer.
float phiMS() const
Get the phi at muon spectrometer.
void setStgcClustersCapacity(const int value)
Set size of storage for sTGC clusters.
void setTrackPosition(float r, float z, float eta, float phi)
Set position of muon track.
void setRMS(float value)
Set the R at muon spectrometer.
void setPtCSC(float value)
void setLumiBlock(uint32_t value)
void setRoiThreshold(uint32_t value)
void setTgcMidF(float rhoChi2, long rhoN, float phiChi2, long phiN)
void setPhiMap(float value)
Set phi used to refer pT LUT.
void setIsTgcFailure(int value)
Set flag to record if TGC is properly read.
void setRoiSubsystem(uint32_t value)
void setRpcHitsCapacity(int value)
Size of storage to be reserved.
virtual double pt() const
The transverse momentum ( ) of the particle.
void setRoiSector(uint32_t value)
void setRpcFitOut(float phi, float slope, float offset)
void setLvl1Id(uint32_t value)
void setChamberType2(int station, int sector, int chamberType)
void setMmCluster(const unsigned int layer, const int isOutlier, const float eta, const float phi, const float r, const float z, const float residualR, const float residualPhi, const int stationEta, const int stationPhi, const int stationName)
Set MM hits.
void setEtaBin(int value)
Set eta bin of pT LUT.
void setEtaMap(float value)
Set eta used to refer pT LUT.
void setMuonDetMask(uint32_t value)
void setDirPhiMS(float value)
Set tan phi at muon spectrometer.
void setPtEndcapBeta(float value)
void setCscHitsCapacity(int value)
Set size of storage for CSC hits.
void setRegionZ(int station, int sector, float min, float max)
Z range.
void setEndcapRadius(float value)
Set the fitted radius of the muon in the endcap.
void setEndcapBeta(float value)
Set the fitted value in the endcap.
void setChamberType1(int station, int sector, int chamberType)
Set the muon road information.
void setSAddress(int value)
Set the station address of the muon.
void setRpcFitMid(float phi, float slope, float offset)
void setPhiMS(float value)
Set the phi at muon spectrometer.
void setEndcapAlpha(float value)
Set the fitted value in the endcap.
void setRoIWord(uint32_t value)
Set the RoI ID of the seeding LVL1 muon.
void setRoiId(uint32_t value)
void setTgcHitsCapacity(int value)
Set size of storage for TGC hits.
void setRoiEta(float value)
void setTgcMid1(float eta, float phi, float r, float z)
void setRegionEta(int station, int sector, float min, float max)
Eta range.
void setIsRpcFailure(int value)
Set flag to record if RPC is properly read.
void setPt(float pt)
Set the transverse momentum ( ) of the muon.
void setRoiPhi(float value)
void setSuperPoint(int chamber, float r, float z, float slope, float intercept=0., float chi2=0.)
Set the properties of one particular super point measurement.
void setMdtHitsCapacity(int value)
Set size of storage for MDT hits.
void setDirZMS(float value)
Set dRdZ at muon spectrometer.
void setAlgoId(int value)
void setPhiBin(int value)
Set phi bin of pT LUT.
void setZMS(float value)
Set the Z at muon spectrometer.
void setBarrelRadius(float value)
Set the fitted radius of the muon in the barrel.
void setPtEndcapAlpha(float value)
void setTgcPt(float value)
void setTgcInnF(float rhoStd, long rhoN, float phiStd, long phiN)
float eta() const
The pseudorapidity ( ) of the muon candidate.
Hemisphere getHemisphere() const
Returns the hemisphere that detected the muon candidate.
RoISource getSource() const
Returns the system that detected the muon candidate.
uint32_t roiWord() const
The "raw" RoI word describing the muon candidate.
int getThrNumber() const
Get the logic number of the highest threshold this RoI passed.
float phi() const
The azimuthal angle ( ) of the muon candidate.
int getSectorID() const
Get the sector ID number.
int getRoI() const
Get the "RoI number" (position inside the sector).
void efficiency(std::vector< double > &bins, std::vector< double > &values, const std::vector< std::string > &files, const std::string &histname, const std::string &tplotname, const std::string &label="")
constexpr T wrapToPi(T phi)
Wrap angle in radians to [-pi, pi].
ValuesCollection< T > Collection(std::string name, const T &collection)
Declare a monitored (double-convertible) collection.
SG::ReadCondHandle< T > makeHandle(const SG::ReadCondHandleKey< T > &key, const EventContext &ctx=Gaudi::Hive::currentContext())
std::vector< StgcHitData > StgcHits
std::vector< MdtHitData > MdtHits
std::vector< MmHitData > MmHits
std::vector< CscHitData > CscHits
std::vector< RpcHitData > RpcHits
std::vector< TgcHitData > TgcHits
@ BarrelInner
Inner station in the barrel spectrometer.
@ EndcapOuter
Outer station in the endcap spectrometer.
@ BarrelMiddle
Middle station in the barrel spectrometer.
@ EndcapMiddle
Middle station in the endcap spectrometer.
@ BEE
BEE measurement point.
@ EndcapExtra
Extra station in the endcap spectrometer.
@ BarrelOuter
Outer station in the barrel spectrometer.
@ BME
BME measurement point.
@ EndcapInner
Inner station in the endcap spectrometer.
ECRegions whichECRegion(const float eta, const float phi)
TrigCompositeContainer_v1 TrigCompositeContainer
Declare the latest version of the container.
MuonRoIContainer_v1 MuonRoIContainer
L2CombinedMuon_v1 L2CombinedMuon
Define the latest version of the muon CB class.
TrigComposite_v1 TrigComposite
Declare the latest version of the class.
TrackParticleContainer_v1 TrackParticleContainer
Definition of the current "TrackParticle container version".
L2StandAloneMuon_v2 L2StandAloneMuon
Define the latest version of the muon SA class.
Helper for azimuthal angle calculations.