10 #include <tracking/modules/spacePointCreator/GFTC2SPTCConverterModule.h>
11 #include <tracking/spacePointCreation/SpacePointTrackCand.h>
13 #include <framework/dataobjects/EventMetaData.h>
14 #include <framework/datastore/StoreObjPtr.h>
15 #include <framework/gearbox/Const.h>
19 #include <boost/tuple/tuple_comparison.hpp>
21 #include <pxd/dataobjects/PXDTrueHit.h>
22 #include <svd/dataobjects/SVDTrueHit.h>
32 setDescription(
"Module for converting genfit::TrackCands (e.g. from TrackFinderMCTruth) to SpacePointTrackCands.");
33 setPropertyFlags(c_ParallelProcessingCertified);
35 addParam(
"PXDClusters", m_PXDClusterName,
"PXDCluster collection name",
string(
""));
36 addParam(
"SVDClusters", m_SVDClusterName,
"SVDCluster collection name",
string(
""));
37 addParam(
"genfitTCName", m_genfitTCName,
"Name of container of genfit::TrackCands",
string(
""));
38 addParam(
"SpacePointTCName", m_SPTCName,
39 "Name of the container under which SpacePointTrackCands will be stored in the DataStore (NOTE: These SpaceTrackCands are not checked for curling behaviour, but are simply converted and stored!)",
42 addParam(
"SingleClusterSVDSP", m_SingleClusterSVDSPName,
43 "Single Cluster SVD SpacePoints collection name. NOTE: This StoreArray will be searched for SpacePoints only if 'useSingleClusterSP' is set to true!",
44 string(
"SVDSpacePoints"));
45 addParam(
"NoSingleClusterSVDSP", m_NoSingleClusterSVDSPName,
46 "Non Single Cluster SVD SpacePoints collection name. This StoreArray will be searched for SpacePoints",
string(
"SVDSpacePoints"));
47 addParam(
"PXDClusterSP", m_PXDClusterSPName,
"PXD Cluster SpacePoints collection name.",
string(
"PXDSpacePoints"));
49 addParam(
"minNDF", m_PARAMminNDF,
50 "Minimum number of degrees of freedom a SpacePointTrackCand has to contain in order to get registered in the DataStore. If set to 0, any number is accepted",
53 addParam(
"checkTrueHits", m_PARAMcheckTrueHits,
54 "Set to true if you want TrueHits of Clusters forming a SpacePoint (e.g. SVD) to be checked for equality",
false);
55 addParam(
"useSingleClusterSP", m_PARAMuseSingleClusterSP,
56 "Set to true if you want to use singleCluster SVD SpacePoints if no doubleCluster SVD SpacePoint can be found. NOTE: this gets overriden if 'skipCluster' is set to true!",
58 addParam(
"checkNoSingleSVDSP", m_PARAMcheckNoSingleSVDSP,
59 "Set to false if you want to disable the initial check for the StoreArray of Non Single Cluster SVD SpacePoints. NOTE: The module will still search for these SpacePoints first, so you have to make sure you are not registering SpacePoints under the StoreArray with the NoSingleClusterSVDSP name! (Disable the module that registers these SpacePoints)",
61 addParam(
"skipCluster", m_PARAMskipCluster,
62 "Set to true if you only want to skip the Clusters for which no appropriate SpacePoints can be found, instead of aborting the conversion of the whole GFTC when such a case occurs. NOTE: setting this to true automatically sets 'useSingleClusterSP' to false!",
69 void GFTC2SPTCConverterModule::initialize()
71 B2INFO(
"GFTC2SPTCConverter -------------- initialize() ---------------------");
78 if (m_PARAMuseSingleClusterSP) {
80 SCSPs.isRequired(m_SingleClusterSVDSPName);
82 if (m_PARAMcheckNoSingleSVDSP) {
84 nSCSPs.isRequired(m_NoSingleClusterSVDSPName);
87 pxdSPs.isRequired(m_PXDClusterSPName);
90 gfTrackCand.isRequired(m_genfitTCName);
94 spTrackCand.registerInDataStore(m_SPTCName, DataStore::c_ErrorIfAlreadyRegistered);
100 if (m_PARAMcheckTrueHits) {
105 if (m_PARAMminNDF < 0) {
106 B2WARNING(
"'minNDF' is set to a value below 0. Resetting to 0!");
113 void GFTC2SPTCConverterModule::event()
116 const int eventCounter = eventMetaDataPtr->getEvent();
117 B2DEBUG(10,
"GFTC2SPTCConverter::event(). Processing event " << eventCounter <<
" --------");
127 B2DEBUG(15,
"Found " << nTCs <<
" genfit::TrackCands in StoreArray " << mcTrackCands.getName());
129 for (
int iTC = 0; iTC < nTCs; ++iTC) {
134 "================================================================================\nNow processing genfit::TrackCand "
136 if (LogSystem::Instance().isLevelEnabled(LogConfig::c_Debug, 15, PACKAGENAME())) { trackCand->
Print(); }
139 std::pair<const SpacePointTrackCand, conversionStatus> spacePointTC = createSpacePointTC(trackCand, pxdClusters, svdClusters);
141 if (spacePointTC.second == 0) {
142 if (LogSystem::Instance().isLevelEnabled(LogConfig::c_Debug, 50, PACKAGENAME())) spacePointTC.first.print(50);
146 B2DEBUG(10,
"Added new SpacePointTrackCand to StoreArray " << spacePointTrackCands.getName());
148 B2DEBUG(10,
"The conversion failed due to: " << spacePointTC.second);
149 increaseFailCounter(spacePointTC.second);
151 }
catch (std::runtime_error& anE) {
152 B2ERROR(
"Caught exception in creation of SpacePointTrackCand: " << anE.what());
154 B2ERROR(
"Caught undefined exception in creation of SpacePointTrackCand!");
160 void GFTC2SPTCConverterModule::terminate()
162 stringstream generalOutput;
163 generalOutput <<
"GFTC2SPTCConverter::terminate(): got " << m_genfitTCCtr <<
" GFTCs and created " << m_SpacePointTCCtr <<
165 if (m_abortedLowNDFCtr) generalOutput <<
"For " << m_abortedLowNDFCtr <<
" SPTCs the NDF was below " << m_PARAMminNDF <<
"\n";
167 B2INFO(generalOutput.str());
168 if (LogSystem::Instance().isLevelEnabled(LogConfig::c_Debug, 1, PACKAGENAME())) {
169 stringstream verboseOutput;
170 verboseOutput <<
"counter variables: ";
171 verboseOutput <<
"abortedNoSP: " << m_abortedNoSPCtr <<
", abortedUnsuitableGFTC: " << m_abortedUnsuitableTCCtr <<
172 ", abortedNoValidSP: " << m_abortedNoValidSPCtr;
173 if (m_PARAMcheckTrueHits) verboseOutput <<
", abortedTrueHit: " << m_abortedTrueHitCtr;
174 if (m_PARAMskipCluster) {
175 verboseOutput <<
", skippedCluster: " << m_skippedCluster <<
", skippedPXDnoSP: " << m_skippedPXDnoSPCtr;
176 verboseOutput <<
", skippedSVDnoSP: " << m_skippedSVDnoSPCtr <<
", skippedPXDnoTH: " << m_skippedPXDnoTHCtr <<
", skippedSVDnoTH: "
177 << m_skippedSVDnoTHCtr;
178 verboseOutput <<
", skippedPXDunsuitable: " << m_skippedPXDunsuitableCtr <<
", skippedSVDunsuitable: " << m_skippedSVDunsuitableCtr;
179 verboseOutput <<
", skippedPXDnoValidSP " << m_skippedPXDnoValidSPCtr <<
", skippedSVDnoValidSP " << m_skippedSVDnoValidSPCtr;
181 if (m_nonSingleSPCtr) verboseOutput <<
", nonSingleSP " << m_nonSingleSPCtr;
182 verboseOutput <<
", noTwoClusterSP: " << m_noTwoClusterSPCtr <<
", singleClusterSVDSP: " << m_singleClusterSPCtr;
183 B2DEBUG(1, verboseOutput.str());
185 if (LogSystem::Instance().isLevelEnabled(LogConfig::c_Debug, 2, PACKAGENAME())) {
186 stringstream explanation;
187 explanation <<
"explanation of counter variables (key words only):\n";
188 explanation <<
"NoSP -> Found no related SpacePoint to a Cluster\n";
189 explanation <<
"Unsuitable -> Cluster combination of SpacePoint was not in consecutive order in GFTC\n";
190 explanation <<
"NoValidSP -> Cluster combination of SpacePoint was not contained in GFTC\n";
191 if (m_PARAMcheckTrueHits) explanation <<
"TrueHit/noTH -> found no related TrueHit to a SpacePoint\n";
192 if (m_nonSingleSPCtr) explanation <<
"nonSingleSP -> more than one singleCluster SpacePoint related to a Cluster\n";
193 explanation <<
"noTwoClusterSP -> found no two Cluster SpacePoint\n";
194 explanation <<
"singleClusterSVDSP -> number of tries to add a singleCluster SpacePoint for latter cases\n";
195 B2DEBUG(2, explanation.str());
200 std::pair<const Belle2::SpacePointTrackCand, GFTC2SPTCConverterModule::conversionStatus>
205 std::vector<HitInfo<SpacePoint> > tcSpacePoints;
209 int nHits = genfitTC->getNHits();
210 B2DEBUG(15,
"genfit::TrackCand contains " << nHits <<
" hits");
213 std::vector<flaggedPair<int> > fHitIDs;
214 for (
int i = 0; i < nHits; ++i) {
215 auto aHit = genfitTC->getHit(i);
217 fHitIDs.push_back(aPair);
220 bool usedSingleCluster =
false;
222 for (
int iTCHit = 0; iTCHit < nHits; ++iTCHit) {
224 double sortingParam = aTCHit->getSortingParameter();
226 B2DEBUG(20,
"Processing TrackCandHit " << iTCHit <<
" of " << nHits);
227 if (fHitIDs[iTCHit].get<0>()) {
228 B2DEBUG(60,
"This hit has already been added to the SpacePointTrackCand via a SpacePoint and will not be processed again");
230 std::pair<SpacePoint*, conversionStatus> aSpacePoint = processTrackCandHit(aTCHit, pxdClusters, svdClusters, fHitIDs, iTCHit);
233 if (aSpacePoint.first != NULL && (aSpacePoint.second >= 0 || aSpacePoint.second == c_nonSingleSP)) {
234 if (aSpacePoint.second == c_singleClusterSP) usedSingleCluster =
true;
235 tcSpacePoints.push_back({sortingParam, aSpacePoint.first});
236 B2DEBUG(60,
"Added SpacePoint " << aSpacePoint.first->getArrayIndex() <<
" from Array " << aSpacePoint.first->getArrayName() <<
237 " to tcSpacePoints");
238 m_NDF += getNDF(aSpacePoint.first);
240 convStatus = aSpacePoint.second;
241 B2DEBUG(60,
"There was an error during conversion: for Hit " << iTCHit <<
": " << convStatus);
242 if (!m_PARAMskipCluster) {
244 "There was an error during conversion for a GFTC. 'skipCluster' is set to false, hence this trackCand will not be converted!");
253 B2DEBUG(20,
"NDF for this SpacePointTrackCand: " << m_NDF);
254 if (m_NDF < m_PARAMminNDF) {
255 B2DEBUG(10,
"The created SpacePointTrackCand has not enough NDF: NDF is " << m_NDF <<
" but 'minNDF' is set to " << m_PARAMminNDF);
260 bool usedAllHits = checkUsedAllHits(fHitIDs);
261 if (!usedAllHits && !m_PARAMskipCluster) {
262 B2WARNING(
"There is at least one TrackCandHit that has not been marked as used although 'skipCluster' is set to false");
267 std::vector<const SpacePoint*> spacePoints;
268 std::vector<double> sortingParams;
270 spacePoints.push_back(aSP.second);
271 sortingParams.push_back(aSP.first);
280 if (m_PARAMcheckTrueHits) { spacePointTC.
addRefereeStatus(SpacePointTrackCand::c_checkedTrueHits); }
281 if (!usedAllHits) { spacePointTC.
addRefereeStatus(SpacePointTrackCand::c_omittedClusters); }
282 if (usedSingleCluster) { spacePointTC.
addRefereeStatus(SpacePointTrackCand::c_singleClustersSPs); }
284 return std::make_pair(spacePointTC, c_noFail);
288 std::pair<Belle2::SpacePoint*, GFTC2SPTCConverterModule::conversionStatus>
293 int detID = hit->getDetId();
294 int hitID = hit->getHitId();
295 int planeID = hit->getPlaneId();
296 B2DEBUG(60,
"Processing TrackCandHit " << iHit <<
" with detID: " << detID <<
", hitID: " << hitID <<
", planeID: " << planeID);
298 std::pair<SpacePoint*, conversionStatus> returnSP = { NULL, c_noFail };
300 if (detID == Const::PXD) {
301 const PXDCluster* aCluster = pxdClusters[hitID];
302 returnSP = getSpacePoint<PXDCluster, PXDTrueHit>(aCluster, flaggedHitIDs, iHit,
true, m_PXDClusterSPName);
303 if (m_PARAMskipCluster) { increaseSkippedCounter(returnSP.second, aCluster); }
304 if (returnSP.second == c_singleClusterSP) returnSP.second = c_noFail;
305 }
else if (detID == Const::SVD) {
306 const SVDCluster* aCluster = svdClusters[hitID];
307 returnSP = getSpacePoint<SVDCluster, SVDTrueHit>(aCluster, flaggedHitIDs, iHit,
false, m_NoSingleClusterSVDSPName);
308 if (m_PARAMskipCluster) { increaseSkippedCounter(returnSP.second, aCluster); }
310 throw SpacePointTrackCand::UnsupportedDetType();
316 template<
typename ClusterType,
typename TrueHitType>
317 std::pair<Belle2::SpacePoint*, GFTC2SPTCConverterModule::conversionStatus>
318 GFTC2SPTCConverterModule::getSpacePoint(
const ClusterType* cluster, std::vector<
flaggedPair<int> >& flaggedHitIDs,
int iHit,
319 bool singleCluster, std::string arrayName)
321 std::pair<SpacePoint*, conversionStatus> spacePoint = {NULL, c_noFail};
323 B2DEBUG(70,
"Trying to find a related SpacePoint in StoreArray " << arrayName <<
" for Cluster " << cluster->getArrayIndex() <<
324 " from Array " << cluster->getArrayName());
326 B2DEBUG(80,
"Found " << spacePoints.
size() <<
" related SpacePoints for Cluster " << cluster->getArrayIndex() <<
" from Array " <<
327 cluster->getArrayName());
330 if (spacePoints.
size() == 0) {
331 B2DEBUG(80,
"Found no related (single Cluster) SpacePoint!");
332 spacePoint.second = c_foundNoSpacePoint;
335 if (spacePoints.
size() > 1) {
336 B2ERROR(
"More than one single Cluster SpacePoint related to a Cluster! Returning only the first in RelationVector!");
337 spacePoint.second = c_nonSingleSP;
340 spacePoint.first = spacePoints[0];
342 spacePoint.second = c_singleClusterSP;
343 markHitAsUsed(flaggedHitIDs, iHit);
346 spacePoint = findAppropriateSpacePoint<ClusterType>(spacePoints, flaggedHitIDs);
347 if (spacePoint.first == NULL) {
348 B2DEBUG(80,
"Did not find an appropriate double Cluster SpacePoint for Cluster " << cluster->getArrayIndex() <<
" from Array " <<
349 cluster->getArrayName() <<
". Reason for failure: " << spacePoint.second);
350 m_noTwoClusterSPCtr++;
351 if (m_PARAMuseSingleClusterSP) {
352 B2DEBUG(80,
"Trying to get a single Cluster SpacePoint now!");
353 m_singleClusterSPCtr++;
355 return getSpacePoint<ClusterType, TrueHitType>(cluster, flaggedHitIDs, iHit,
true, m_SingleClusterSVDSPName);
360 if (m_PARAMcheckTrueHits && spacePoint.first != NULL) {
361 if (!foundRelatedTrueHit<TrueHitType>(spacePoint.first)) { spacePoint.second = c_foundNoTrueHit; }
368 template<
typename ClusterType>
369 std::pair<Belle2::SpacePoint*, GFTC2SPTCConverterModule::conversionStatus>
373 std::pair<SpacePoint*, conversionStatus> returnSP = { NULL, c_noFail };
374 B2DEBUG(100,
"Trying to find an appropriate SpacePoint from RelationVector with " << spacePoints.
size() <<
" entries!");
375 if (spacePoints.
size() == 0) {
376 B2DEBUG(80,
"There are no spacePoints to choose of!");
377 returnSP.second = c_foundNoSpacePoint;
382 int detID = spacePoints[0]->getType() == VXD::SensorInfoBase::SVD ? Const::SVD : Const::PXD;
385 std::vector<std::pair<bool, bool> > existAndValidSP;
387 std::vector<std::pair<int, int> > clusterPositions;
390 for (
unsigned int iSP = 0; iSP < spacePoints.
size(); ++iSP) {
392 B2DEBUG(100,
"Processing SpacePoint " << iSP + 1 <<
" of " << spacePoints.
size() <<
" with Index " << aSP->
getArrayIndex() <<
395 bool bothValid =
true;
396 bool foundBoth =
true;
398 std::vector<int> clusterInds = getClusterIndices<SVDCluster>(aSP, m_SVDClusterName);
399 for (
int index : clusterInds) {
401 std::pair<int, int> existAndValidClPos = checkExistAndValid(index, detID, flaggedHitIDs);
402 if (existAndValidClPos.first < 0) {
404 if (existAndValidClPos.second < 0) foundBoth =
false;
408 clusterPositions.push_back({iSP, existAndValidClPos.first});
409 B2DEBUG(999,
"clusterInd: " << index <<
" checkExistAndValid.first: " << existAndValidClPos.first <<
", .second: " <<
410 existAndValidClPos.second <<
" bothValid/foundBoth: " << bothValid <<
"/" << foundBoth);
413 existAndValidSP.push_back({foundBoth, bothValid});
414 B2DEBUG(100,
"Cluster combination of SpacePoint " << aSP->
getArrayIndex() <<
" is contained in genfit::TrackCand: " << foundBoth <<
415 ". SpacePoint is valid: " << bothValid);
418 int relVecPosition = getAppropriateSpacePointIndex(existAndValidSP, clusterPositions);
419 if (relVecPosition < 0) {
420 returnSP.second = getFailEnum(relVecPosition);
424 B2DEBUG(100,
"SpacePoint " << spacePoints[relVecPosition]->getArrayIndex() <<
425 " is the appropriate SpacePoint of all checked SpacePoints! The positions inside the GFTC are: " << clusterPositions.at(
426 relVecPosition * 2).second <<
" and " << clusterPositions.at(relVecPosition * 2 + 1).second);
427 markHitAsUsed(flaggedHitIDs, clusterPositions.at(relVecPosition * 2).second);
428 markHitAsUsed(flaggedHitIDs, clusterPositions.at(relVecPosition * 2 + 1).second);
429 returnSP.first = spacePoints[relVecPosition];
435 template<
typename ClusterType>
436 std::vector<int> GFTC2SPTCConverterModule::getClusterIndices(
const Belle2::SpacePoint* spacePoint, std::string storeArrayName)
438 std::vector<int> clusterInds;
440 B2ASSERT(
"Too many clusters. There are " << relClusters.
size() <<
" clusters.", relClusters.
size() < 3);
442 stringstream clusterStream;
443 for (
const ClusterType& aCluster : relClusters) {
444 clusterInds.push_back(aCluster.getArrayIndex());
445 clusterStream << aCluster.getArrayIndex() <<
" ";
449 "): clusters are: " << clusterStream.str());
455 std::pair<int, int> GFTC2SPTCConverterModule::checkExistAndValid(
int clusterInd,
int detID,
458 B2DEBUG(499,
"Now checking if Cluster " << clusterInd <<
" is valid");
459 std::pair<int, int> positions = { -1, -1};
467 unsigned int validPos = std::find(flaggedHitIDs.begin(), flaggedHitIDs.end(), validID) - flaggedHitIDs.begin();
468 unsigned int existingPos = std::find(flaggedHitIDs.begin(), flaggedHitIDs.end(), existingID) - flaggedHitIDs.begin();
470 B2DEBUG(100,
"validID = (" << validID.get<1>() <<
"," << validID.get<2>() <<
"), found at position " << validPos <<
471 ", existingID found at position " << existingPos <<
" of " << flaggedHitIDs.size());
474 if (validPos < flaggedHitIDs.size()) { positions.first = validPos; }
475 if (existingPos < flaggedHitIDs.size()) { positions.second = existingPos; }
477 B2DEBUG(999,
"Return values, .first: " << positions.first <<
", .second: " << positions.second);
484 if (spacePoint == NULL) {
485 B2ERROR(
"Got NULL pointer to determine the NDF of!");
490 if (assignedHits.first && assignedHits.second)
return 2;
492 if (assignedHits.first ^ assignedHits.second)
return 1;
497 int GFTC2SPTCConverterModule::getAppropriateSpacePointIndex(
const std::vector<std::pair<bool, bool> >& existAndValidSPs,
498 const std::vector<std::pair<int, int> >& clusterPositions)
501 int nExistingButUsedSP = std::count(existAndValidSPs.begin(), existAndValidSPs.end(), std::make_pair(
true,
false));
502 int nValidSP = std::count(existAndValidSPs.begin(), existAndValidSPs.end(), std::make_pair(
true,
true));
504 if (LogSystem::Instance().isLevelEnabled(LogConfig::c_Debug, 999, PACKAGENAME())) {
506 output <<
"content of passed vector of pairs (comma separated): ";
507 for (
auto entry : existAndValidSPs) { output << entry.first <<
"/" << entry.second <<
", "; }
508 B2DEBUG(999, output.str() <<
"nValidSP: " << nValidSP <<
" nExistingButUsedSP: " << nExistingButUsedSP);
512 if (nValidSP < 1 && nExistingButUsedSP > 0) {
514 "There are only Cluster Combinations where one of the Clusters is already used by another SpacePoint! This genfit::TrackCand cannot be converted properly to a SpacePointTrackCand!");
515 return c_unsuitableGFTC;
516 }
else if (nValidSP < 1 && nExistingButUsedSP < 1) {
517 B2DEBUG(120,
"Found no valid SpacePoint and no SpacePoint with existing but used Clusters/Hits!");
520 else if (nValidSP > 0) {
522 std::vector<std::pair<int, int> > positionInfos;
524 for (
unsigned int iSP = 0; iSP < existAndValidSPs.size(); ++iSP) {
525 if (!existAndValidSPs.at(iSP).second)
continue;
527 int posDiff = clusterPositions.at(iSP * 2).second - clusterPositions.at(iSP * 2 + 1).second;
529 B2DEBUG(200,
"Difference of positions of Clusters for entry " << iSP <<
" is " << posDiff);
530 positionInfos.push_back(std::make_pair(iSP, posDiff * posDiff));
534 sort(positionInfos.begin(), positionInfos.end(), [](
const pair<int, int>& lTuple,
const pair<int, int>& rTuple) { return lTuple.second < rTuple.second; });
536 if (positionInfos.at(0).second != 1) {
537 B2DEBUG(80,
"The shortest squared distance between two Clusters is " << positionInfos.at(0).second <<
538 "! This would lead to wrong ordered TrackCandHits.");
539 return c_unsuitableGFTC;
542 B2DEBUG(150,
"SpacePoint with index " << positionInfos.at(0).first <<
543 " is the valid SpacePoint with two Clusters in consecutive order from all valid SpacePoints.");
544 return positionInfos.at(0).first;
551 bool GFTC2SPTCConverterModule::checkUsedAllHits(std::vector<
flaggedPair<int> >& flaggedHitIDs)
554 for (
unsigned int i = 0; i < flaggedHitIDs.size(); ++i) {
556 B2DEBUG(200,
"Hit " << i <<
" with (detID,hitID): (" << fPair.get<1>() <<
"," << fPair.get<2>() <<
") has been used: " <<
558 if (!fPair.get<0>()) {
568 template <
typename TrueHitType>
569 bool GFTC2SPTCConverterModule::foundRelatedTrueHit(
const Belle2::SpacePoint* spacePoint,
unsigned int allowedRelations)
572 if (relTrueHits.
size() == 0) {
573 B2DEBUG(100,
"Found no TrueHit to SpacePoint " << spacePoint->
getArrayIndex() <<
" from Array " << spacePoint->
getArrayName());
576 B2DEBUG(100,
"Found " << relTrueHits.
size() <<
" related TrueHits for SpacePoint " << spacePoint->
getArrayIndex() <<
" from Array "
578 return (relTrueHits.
size() <= allowedRelations);
583 void GFTC2SPTCConverterModule::markHitAsUsed(std::vector<
flaggedPair<int> >& flaggedHitIDs,
int hitToMark)
585 flaggedHitIDs[hitToMark].get<0>() =
true;
587 B2DEBUG(150,
"Marked Hit " << hitToMark <<
" as used. (detID,hitID) of this hit is (" << fPair.get<1>() <<
"," << fPair.get<2>() <<