File indexing completed on 2025-01-09 23:33:59
0001
0002
0003
0004
0005 #include "RecoMuon/MuonSeedGenerator/interface/SETSeedFinder.h"
0006 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0007 #include "FWCore/Framework/interface/Event.h"
0008 #include "RecoMuon/TrackingTools/interface/MuonPatternRecoDumper.h"
0009 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0010 #include "TrackingTools/DetLayers/interface/DetLayer.h"
0011 #include "Geometry/CommonDetUnit/interface/GeomDet.h"
0012 #include "DataFormats/MuonDetId/interface/MuonSubdetId.h"
0013 #include "DataFormats/MuonDetId/interface/CSCDetId.h"
0014 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h"
0015
0016 #include "TMath.h"
0017
0018 using namespace edm;
0019 using namespace std;
0020
0021 const string metname = "Muon|RecoMuon|SETMuonSeedFinder";
0022
0023 SETSeedFinder::SETSeedFinder(const ParameterSet& parameterSet) : MuonSeedVFinder() {
0024
0025 ParameterSet trajectoryBuilderParameters = parameterSet.getParameter<ParameterSet>("SETTrajBuilderParameters");
0026 apply_prePruning = trajectoryBuilderParameters.getParameter<bool>("Apply_prePruning");
0027
0028 thePtExtractor = new MuonSeedPtExtractor(trajectoryBuilderParameters);
0029 }
0030
0031 void SETSeedFinder::seeds(const MuonRecHitContainer& cluster, std::vector<TrajectorySeed>& result) {}
0032
0033
0034 namespace {
0035 struct sorter {
0036 sorter() {}
0037 bool operator()(MuonTransientTrackingRecHit::MuonRecHitPointer const& hit_1,
0038 MuonTransientTrackingRecHit::MuonRecHitPointer const& hit_2) const {
0039 return (hit_1->globalPosition().mag2() < hit_2->globalPosition().mag2());
0040 }
0041 };
0042 const sorter sortSegRadius;
0043 }
0044
0045 std::vector<SETSeedFinder::MuonRecHitContainer> SETSeedFinder::sortByLayer(MuonRecHitContainer& cluster) const {
0046 stable_sort(cluster.begin(), cluster.end(), sortSegRadius);
0047
0048
0049
0050 std::vector<MuonRecHitContainer> MuonRecHitContainer_perLayer;
0051 if (!cluster.empty()) {
0052 int iHit = 0;
0053 MuonRecHitContainer hitsInThisLayer;
0054 hitsInThisLayer.push_back(cluster[iHit]);
0055 DetId detId = cluster[iHit]->hit()->geographicalId();
0056 const GeomDet* geomDet = theService->trackingGeometry()->idToDet(detId);
0057 while (iHit < int(cluster.size()) - 1) {
0058 DetId detId_2 = cluster[iHit + 1]->hit()->geographicalId();
0059 const GlobalPoint gp_nextHit = cluster[iHit + 1]->globalPosition();
0060
0061
0062 float distanceToDetector = fabs(geomDet->surface().localZ(gp_nextHit));
0063
0064
0065
0066
0067
0068
0069 bool specialCase = false;
0070 if (detId.subdetId() == MuonSubdetId::DT && detId_2.subdetId() == MuonSubdetId::DT) {
0071 DTChamberId dtCh(detId);
0072 DTChamberId dtCh_2(detId_2);
0073 specialCase = (dtCh.station() == dtCh_2.station());
0074 } else if (detId.subdetId() == MuonSubdetId::CSC && detId_2.subdetId() == MuonSubdetId::CSC) {
0075 CSCDetId cscCh(detId);
0076 CSCDetId cscCh_2(detId_2);
0077 specialCase = (cscCh.station() == cscCh_2.station() && cscCh.ring() == cscCh_2.ring());
0078 }
0079
0080 if (distanceToDetector < 0.001 || true == specialCase) {
0081 hitsInThisLayer.push_back(cluster[iHit + 1]);
0082 } else {
0083 specialCase = false;
0084 if (((cluster[iHit]->isDT() && cluster[iHit + 1]->isCSC()) ||
0085 (cluster[iHit]->isCSC() && cluster[iHit + 1]->isDT())) &&
0086
0087
0088 fabs(cluster[iHit + 1]->globalPosition().mag() - cluster[iHit]->globalPosition().mag()) < 10.) {
0089 hitsInThisLayer.push_back(cluster[iHit + 1]);
0090
0091 detId = cluster[iHit + 1]->hit()->geographicalId();
0092 geomDet = theService->trackingGeometry()->idToDet(detId);
0093 } else if (!specialCase) {
0094
0095
0096 MuonRecHitContainer_perLayer.push_back(hitsInThisLayer);
0097 hitsInThisLayer.clear();
0098 hitsInThisLayer.push_back(cluster[iHit + 1]);
0099 detId = cluster[iHit + 1]->hit()->geographicalId();
0100 geomDet = theService->trackingGeometry()->idToDet(detId);
0101 }
0102 }
0103 ++iHit;
0104 }
0105 MuonRecHitContainer_perLayer.push_back(hitsInThisLayer);
0106 }
0107 return MuonRecHitContainer_perLayer;
0108 }
0109
0110 void SETSeedFinder::limitCombinatorics(std::vector<MuonRecHitContainer>& MuonRecHitContainer_perLayer) {
0111 const int maximumNumberOfCombinations = 1000000;
0112 unsigned nLayers = MuonRecHitContainer_perLayer.size();
0113 if (1 == nLayers) {
0114 return;
0115 }
0116
0117
0118 if (MuonRecHitContainer_perLayer.size() > 15) {
0119 MuonRecHitContainer_perLayer.resize(1);
0120 return;
0121 }
0122
0123 std::vector<double> sizeOfLayer(nLayers);
0124
0125 double nAllCombinations = 1.;
0126 for (unsigned int i = 0; i < nLayers; ++i) {
0127
0128 sizeOfLayer.at(i) = MuonRecHitContainer_perLayer.at(i).size();
0129 nAllCombinations *= MuonRecHitContainer_perLayer.at(i).size();
0130 }
0131
0132
0133 while (nAllCombinations > float(maximumNumberOfCombinations)) {
0134 std::vector<double>::iterator maxEl_it = max_element(sizeOfLayer.begin(), sizeOfLayer.end());
0135 int maxEl = maxEl_it - sizeOfLayer.begin();
0136 nAllCombinations /= MuonRecHitContainer_perLayer.at(maxEl).size();
0137 MuonRecHitContainer_perLayer.erase(MuonRecHitContainer_perLayer.begin() + maxEl);
0138 sizeOfLayer.erase(sizeOfLayer.begin() + maxEl);
0139 }
0140 return;
0141 }
0142
0143 std::vector<SETSeedFinder::MuonRecHitContainer> SETSeedFinder::findAllValidSets(
0144 const std::vector<SETSeedFinder::MuonRecHitContainer>& MuonRecHitContainer_perLayer) {
0145 std::vector<MuonRecHitContainer> allValidSets;
0146
0147
0148
0149
0150
0151 unsigned nLayers = MuonRecHitContainer_perLayer.size();
0152 if (1 == nLayers) {
0153 return allValidSets;
0154 }
0155 MuonRecHitContainer validSet;
0156 unsigned int iPos0 = 0;
0157 std::vector<unsigned int> iLayer(12);
0158 std::vector<unsigned int> size(12);
0159 if (iPos0 < nLayers) {
0160 size.at(iPos0) = MuonRecHitContainer_perLayer.at(iPos0).size();
0161 for (iLayer[iPos0] = 0; iLayer[iPos0] < size[iPos0]; ++iLayer[iPos0]) {
0162 validSet.clear();
0163 validSet.push_back(MuonRecHitContainer_perLayer[iPos0][iLayer[iPos0]]);
0164 unsigned int iPos1 = 1;
0165 if (iPos1 < nLayers) {
0166 size.at(iPos1) = MuonRecHitContainer_perLayer.at(iPos1).size();
0167 for (iLayer[iPos1] = 0; iLayer[iPos1] < size[iPos1]; ++iLayer[iPos1]) {
0168 validSet.resize(iPos1);
0169 validSet.push_back(MuonRecHitContainer_perLayer[iPos1][iLayer[iPos1]]);
0170 unsigned int iPos2 = 2;
0171 if (iPos2 < nLayers) {
0172 size.at(iPos2) = MuonRecHitContainer_perLayer.at(iPos2).size();
0173 for (iLayer[iPos2] = 0; iLayer[iPos2] < size[iPos2]; ++iLayer[iPos2]) {
0174 validSet.resize(iPos2);
0175 validSet.push_back(MuonRecHitContainer_perLayer[iPos2][iLayer[iPos2]]);
0176 unsigned int iPos3 = 3;
0177 if (iPos3 < nLayers) {
0178 size.at(iPos3) = MuonRecHitContainer_perLayer.at(iPos3).size();
0179 for (iLayer[iPos3] = 0; iLayer[iPos3] < size[iPos3]; ++iLayer[iPos3]) {
0180 validSet.resize(iPos3);
0181 validSet.push_back(MuonRecHitContainer_perLayer[iPos3][iLayer[iPos3]]);
0182 unsigned int iPos4 = 4;
0183 if (iPos4 < nLayers) {
0184 size.at(iPos4) = MuonRecHitContainer_perLayer.at(iPos4).size();
0185 for (iLayer[iPos4] = 0; iLayer[iPos4] < size[iPos4]; ++iLayer[iPos4]) {
0186 validSet.resize(iPos4);
0187 validSet.push_back(MuonRecHitContainer_perLayer[iPos4][iLayer[iPos4]]);
0188 unsigned int iPos5 = 5;
0189 if (iPos5 < nLayers) {
0190 size.at(iPos5) = MuonRecHitContainer_perLayer.at(iPos5).size();
0191 for (iLayer[iPos5] = 0; iLayer[iPos5] < size[iPos5]; ++iLayer[iPos5]) {
0192 validSet.resize(iPos5);
0193 validSet.push_back(MuonRecHitContainer_perLayer[iPos5][iLayer[iPos5]]);
0194 unsigned int iPos6 = 6;
0195 if (iPos6 < nLayers) {
0196 size.at(iPos6) = MuonRecHitContainer_perLayer.at(iPos6).size();
0197 for (iLayer[iPos6] = 0; iLayer[iPos6] < size[iPos6]; ++iLayer[iPos6]) {
0198 validSet.resize(iPos6);
0199 validSet.push_back(MuonRecHitContainer_perLayer[iPos6][iLayer[iPos6]]);
0200 unsigned int iPos7 = 7;
0201 if (iPos7 < nLayers) {
0202 size.at(iPos7) = MuonRecHitContainer_perLayer.at(iPos7).size();
0203 for (iLayer[iPos7] = 0; iLayer[iPos7] < size[iPos7]; ++iLayer[iPos7]) {
0204 validSet.resize(iPos7);
0205 validSet.push_back(MuonRecHitContainer_perLayer[iPos7][iLayer[iPos7]]);
0206 unsigned int iPos8 = 8;
0207 if (iPos8 < nLayers) {
0208 size.at(iPos8) = MuonRecHitContainer_perLayer.at(iPos8).size();
0209 for (iLayer[iPos8] = 0; iLayer[iPos8] < size[iPos8]; ++iLayer[iPos8]) {
0210 validSet.resize(iPos8);
0211 validSet.push_back(MuonRecHitContainer_perLayer[iPos8][iLayer[iPos8]]);
0212 unsigned int iPos9 = 9;
0213 if (iPos9 < nLayers) {
0214 size.at(iPos9) = MuonRecHitContainer_perLayer.at(iPos9).size();
0215 for (iLayer[iPos9] = 0; iLayer[iPos9] < size[iPos9]; ++iLayer[iPos9]) {
0216 validSet.resize(iPos9);
0217 validSet.push_back(MuonRecHitContainer_perLayer[iPos9][iLayer[iPos9]]);
0218 unsigned int iPos10 = 10;
0219 if (iPos10 < nLayers) {
0220 size.at(iPos10) = MuonRecHitContainer_perLayer.at(iPos10).size();
0221 for (iLayer[iPos10] = 0; iLayer[iPos10] < size[iPos10]; ++iLayer[iPos10]) {
0222 validSet.resize(iPos10);
0223 validSet.push_back(MuonRecHitContainer_perLayer[iPos10][iLayer[iPos10]]);
0224 unsigned int iPos11 = 11;
0225 if (iPos11 < nLayers) {
0226 size.at(iPos11) = MuonRecHitContainer_perLayer.at(iPos11).size();
0227 for (iLayer[iPos11] = 0; iLayer[iPos11] < size[iPos11];
0228 ++iLayer[iPos11]) {
0229 }
0230 } else {
0231 allValidSets.push_back(validSet);
0232 }
0233 }
0234 } else {
0235 allValidSets.push_back(validSet);
0236 }
0237 }
0238 } else {
0239 allValidSets.push_back(validSet);
0240 }
0241 }
0242 } else {
0243 allValidSets.push_back(validSet);
0244 }
0245 }
0246 } else {
0247 allValidSets.push_back(validSet);
0248 }
0249 }
0250 } else {
0251 allValidSets.push_back(validSet);
0252 }
0253 }
0254 } else {
0255 allValidSets.push_back(validSet);
0256 }
0257 }
0258 } else {
0259 allValidSets.push_back(validSet);
0260 }
0261 }
0262 } else {
0263 allValidSets.push_back(validSet);
0264 }
0265 }
0266 } else {
0267 allValidSets.push_back(validSet);
0268 }
0269 }
0270 } else {
0271 allValidSets.push_back(validSet);
0272 }
0273 }
0274 } else {
0275 allValidSets.push_back(validSet);
0276 }
0277 return allValidSets;
0278 }
0279
0280 std::pair<int, int>
0281 SETSeedFinder::checkAngleDeviation(double dPhi_1, double dPhi_2) const {
0282
0283
0284
0285
0286
0287
0288
0289 double mult = dPhi_1 * dPhi_2;
0290 int signVal = 1;
0291 if (fabs(dPhi_1) < fabs(dPhi_2)) {
0292 signVal = -1;
0293 }
0294 int signMult = -1;
0295 if (mult > 0)
0296 signMult = 1;
0297 std::pair<int, int> sign;
0298 sign = make_pair(signVal, signMult);
0299
0300 return sign;
0301 }
0302
0303 void SETSeedFinder::validSetsPrePruning(std::vector<SETSeedFinder::MuonRecHitContainer>& allValidSets) {
0304
0305
0306
0307
0308 for (unsigned int iSet = 0; iSet < allValidSets.size(); ++iSet) {
0309 pre_prune(allValidSets[iSet]);
0310 }
0311 }
0312
0313 void SETSeedFinder::pre_prune(SETSeedFinder::MuonRecHitContainer& validSet) const {
0314 unsigned nHits = validSet.size();
0315 if (nHits > 3) {
0316
0317
0318 std::vector<double> dPhi;
0319 double dPhi_tmp;
0320 bool wildCandidate;
0321 int pruneHit_tmp;
0322
0323 for (unsigned int iHit = 1; iHit < nHits; ++iHit) {
0324 dPhi_tmp = validSet[iHit]->globalPosition().phi() - validSet[iHit - 1]->globalPosition().phi();
0325 dPhi.push_back(dPhi_tmp);
0326 }
0327 std::vector<int> pruneHit;
0328
0329
0330 for (unsigned int iHit = 0; iHit < nHits; ++iHit) {
0331 double dPHI_MIN = 0.02;
0332 if (iHit) {
0333
0334
0335 wildCandidate = false;
0336
0337
0338
0339 if (4 == validSet[iHit - 1]->dimension() && 4 == validSet[iHit]->dimension() &&
0340 fabs(validSet[iHit]->globalPosition().phi() - validSet[iHit - 1]->globalPosition().phi()) > dPHI_MIN) {
0341 wildCandidate = true;
0342 }
0343 pruneHit_tmp = -1;
0344 if (wildCandidate) {
0345
0346 if (1 == iHit) {
0347 if (4 == validSet[iHit + 1]->dimension() && 4 == validSet[iHit + 2]->dimension()) {
0348
0349 dPhi_tmp = validSet[iHit + 1]->globalPosition().phi() - validSet[iHit - 1]->globalPosition().phi();
0350
0351 std::pair<int, int> sign = checkAngleDeviation(dPhi_tmp, dPhi[2]);
0352 if (1 == sign.first && 1 == sign.second) {
0353 pruneHit_tmp = iHit;
0354 }
0355 }
0356 } else if (iHit > 1 && iHit < validSet.size() - 1) {
0357 if (4 == validSet[0]->dimension() &&
0358 4 == validSet[1]->dimension() && pruneHit.back() != int(iHit - 1) &&
0359 pruneHit.back() != 1) {
0360
0361
0362 dPhi_tmp = validSet[iHit + 1]->globalPosition().phi() - validSet[iHit - 1]->globalPosition().phi();
0363
0364 std::pair<int, int> sign = checkAngleDeviation(dPhi[0], dPhi_tmp);
0365 if (1 == sign.first && 1 == sign.second) {
0366 pruneHit_tmp = iHit;
0367 } else {
0368
0369 dPhi_tmp = validSet[iHit + 1]->globalPosition().phi() - validSet[iHit]->globalPosition().phi();
0370 std::pair<int, int> sign = checkAngleDeviation(dPhi[0], dPhi_tmp);
0371 if (1 == sign.first && 1 == sign.second) {
0372 pruneHit_tmp = iHit - 1;
0373 }
0374 }
0375 }
0376 } else {
0377
0378 if (pruneHit.size() > 1 && pruneHit[pruneHit.size() - 1] < 0 && pruneHit[pruneHit.size() - 2] < 0) {
0379 std::pair<int, int> sign = checkAngleDeviation(dPhi[dPhi.size() - 2], dPhi[dPhi.size() - 1]);
0380 if (-1 == sign.first && -1 == sign.second) {
0381 pruneHit_tmp = iHit;
0382 }
0383 }
0384 }
0385 }
0386 pruneHit.push_back(pruneHit_tmp);
0387 }
0388 }
0389
0390
0391 for (unsigned int iHit = 1; iHit < nHits; ++iHit) {
0392 int count = 0;
0393 if (pruneHit[iHit - 1] > 0) {
0394 validSet.erase(validSet.begin() + pruneHit[iHit - 1] - count);
0395 ++count;
0396 }
0397 }
0398 }
0399 }
0400
0401 std::vector<SeedCandidate> SETSeedFinder::fillSeedCandidates(std::vector<MuonRecHitContainer>& allValidSets) {
0402
0403
0404
0405
0406 std::vector<SeedCandidate> seedCandidates_inCluster;
0407
0408
0409 for (unsigned int iSet = 0; iSet < allValidSets.size(); ++iSet) {
0410
0411
0412
0413
0414
0415
0416
0417 CLHEP::Hep3Vector momEstimate;
0418 int chargeEstimate;
0419 estimateMomentum(allValidSets[iSet], momEstimate, chargeEstimate);
0420 MuonRecHitContainer MuonRecHitContainer_theSet_prep;
0421
0422
0423 SeedCandidate seedCandidates_inCluster_prep;
0424 seedCandidates_inCluster_prep.theSet = allValidSets[iSet];
0425 seedCandidates_inCluster_prep.momentum = momEstimate;
0426 seedCandidates_inCluster_prep.charge = chargeEstimate;
0427 seedCandidates_inCluster.push_back(seedCandidates_inCluster_prep);
0428
0429 }
0430 return seedCandidates_inCluster;
0431 }
0432
0433 void SETSeedFinder::estimateMomentum(const MuonRecHitContainer& validSet,
0434 CLHEP::Hep3Vector& momEstimate,
0435 int& charge) const {
0436 int firstMeasurement = -1;
0437 int lastMeasurement = -1;
0438
0439
0440
0441
0442
0443
0444
0445
0446
0447 for (unsigned int iMeas = 0; iMeas < validSet.size(); ++iMeas) {
0448 if (4 == validSet[iMeas]->dimension() && (validSet[iMeas]->isCSC() || validSet[iMeas]->isDT())) {
0449 firstMeasurement = iMeas;
0450 break;
0451 }
0452 }
0453
0454
0455 std::vector<double> momentum_estimate;
0456 double pT = 0.;
0457 MuonTransientTrackingRecHit::ConstMuonRecHitPointer firstHit;
0458 MuonTransientTrackingRecHit::ConstMuonRecHitPointer secondHit;
0459
0460 for (int loop = 0; loop < 2; ++loop) {
0461
0462 if (!loop) {
0463
0464
0465 for (int iMeas = validSet.size() - 1; iMeas > -1; --iMeas) {
0466 if (4 == validSet[iMeas]->dimension() && (validSet[iMeas]->isCSC() || validSet[iMeas]->isDT()) &&
0467
0468
0469 fabs(validSet[iMeas]->globalPosition().z()) < 1000.) {
0470 lastMeasurement = iMeas;
0471 break;
0472 }
0473 }
0474 } else {
0475
0476 for (unsigned int iMeas = 1; iMeas < validSet.size(); ++iMeas) {
0477 if (4 == validSet[iMeas]->dimension() && (validSet[iMeas]->isCSC() || validSet[iMeas]->isDT())) {
0478 lastMeasurement = iMeas;
0479 break;
0480 }
0481 }
0482 }
0483
0484 if (-1 == lastMeasurement && -1 == firstMeasurement) {
0485 firstMeasurement = 0;
0486 lastMeasurement = validSet.size() - 1;
0487 }
0488
0489 else if (-1 == lastMeasurement) {
0490 lastMeasurement = firstMeasurement;
0491 } else if (-1 == firstMeasurement) {
0492 firstMeasurement = lastMeasurement;
0493 }
0494
0495 firstHit = validSet[firstMeasurement];
0496 secondHit = validSet[lastMeasurement];
0497 if (firstHit->isRPC() && secondHit->isRPC()) {
0498 momentum_estimate.push_back(300.);
0499 momentum_estimate.push_back(300.);
0500 } else {
0501 if (firstHit->isRPC()) {
0502 firstHit = secondHit;
0503 } else if (secondHit->isRPC()) {
0504 secondHit = firstHit;
0505 }
0506
0507
0508
0509
0510
0511 if (2 == firstHit->dimension() && 2 == secondHit->dimension()) {
0512 momentum_estimate.push_back(999999999.);
0513 momentum_estimate.push_back(999999999.);
0514 } else {
0515 momentum_estimate = thePtExtractor->pT_extract(firstHit, secondHit);
0516 }
0517 }
0518 pT = fabs(momentum_estimate[0]);
0519 if (true || pT > 40.) {
0520
0521
0522 break;
0523 }
0524 }
0525
0526 const float pT_min = 1.99;
0527 if (pT > 3000.) {
0528 pT = 3000.;
0529 } else if (pT < pT_min) {
0530 if (pT > 0) {
0531 pT = pT_min;
0532 } else if (pT > (-1) * pT_min) {
0533 pT = (-1) * pT_min;
0534 } else if (pT < -3000.) {
0535 pT = -3000;
0536 }
0537 }
0538
0539
0540
0541 charge = momentum_estimate[0] > 0 ? 1 : -1;
0542
0543
0544
0545
0546 double xHit = validSet[firstMeasurement]->globalPosition().x();
0547 double yHit = validSet[firstMeasurement]->globalPosition().y();
0548 double rHit = TMath::Sqrt(pow(xHit, 2) + pow(yHit, 2));
0549
0550 double thetaInner = validSet[firstMeasurement]->globalPosition().theta();
0551
0552
0553
0554
0555 double rTrack = (pT / (0.3 * 3.8)) * 100.;
0556
0557 double par = -1. * (2. / charge) * (TMath::ASin(rHit / (2 * rTrack)));
0558 double sinPar = TMath::Sin(par);
0559 double cosPar = TMath::Cos(par);
0560
0561
0562 double sinPhiH = 1. / (2. * charge * rTrack) * (xHit + ((sinPar) / (cosPar - 1.)) * yHit);
0563 double cosPhiH = -1. / (2. * charge * rTrack) * (((sinPar) / (1. - cosPar)) * xHit + yHit);
0564
0565
0566
0567
0568
0569 momEstimate = CLHEP::Hep3Vector(pT * cosPhiH, pT * sinPhiH, pT / TMath::Tan(thetaInner));
0570
0571 const float minMomenum = 5.;
0572 if (momEstimate.mag() < minMomenum) {
0573 int sign = (pT < 0.) ? -1 : 1;
0574 pT = sign * (fabs(pT) + 1);
0575 CLHEP::Hep3Vector momEstimate2(pT * cosPhiH, pT * sinPhiH, pT / TMath::Tan(thetaInner));
0576 momEstimate = momEstimate2;
0577 if (momEstimate.mag() < minMomenum) {
0578 pT = sign * (fabs(pT) + 1);
0579 CLHEP::Hep3Vector momEstimate3(pT * cosPhiH, pT * sinPhiH, pT / TMath::Tan(thetaInner));
0580 momEstimate = momEstimate3;
0581 if (momEstimate.mag() < minMomenum) {
0582 pT = sign * (fabs(pT) + 1);
0583 CLHEP::Hep3Vector momEstimate4(pT * cosPhiH, pT * sinPhiH, pT / TMath::Tan(thetaInner));
0584 momEstimate = momEstimate4;
0585 }
0586 }
0587 }
0588 }
0589
0590 TrajectorySeed SETSeedFinder::makeSeed(const TrajectoryStateOnSurface& firstTSOS,
0591 const TransientTrackingRecHit::ConstRecHitContainer& hits) const {
0592 edm::OwnVector<TrackingRecHit> recHitsContainer;
0593 for (unsigned int iHit = 0; iHit < hits.size(); ++iHit) {
0594 recHitsContainer.push_back(hits.at(iHit)->hit()->clone());
0595 }
0596 PropagationDirection dir = oppositeToMomentum;
0597 if (useSegmentsInTrajectory) {
0598 dir = alongMomentum;
0599 }
0600
0601 PTrajectoryStateOnDet const& seedTSOS =
0602 trajectoryStateTransform::persistentState(firstTSOS, hits.at(0)->geographicalId().rawId());
0603 TrajectorySeed seed(seedTSOS, recHitsContainer, dir);
0604
0605
0606
0607
0608
0609
0610
0611
0612 return seed;
0613 }