From 1bc620f251a33f6944e9efcaa6cdbfa2bf5c0ebb Mon Sep 17 00:00:00 2001 From: erica brondolin Date: Thu, 5 Jun 2014 11:17:36 +0200 Subject: [PATCH 01/16] New try to add DAF --- DAFTest/DAFValidator/macro/.__afsD2B2 | Bin 0 -> 20480 bytes DAFTest/DAFValidator/macro/.__afsE9C8 | Bin 0 -> 12288 bytes DAFTest/DAFValidator/macro/HistoHit.C | 210 ++++++ .../DAFValidator/macro/PlotComparisonMaker.C | 84 +++ .../macro/PlotComparisonMaker_v2.C | 67 ++ DAFTest/DAFValidator/plugins/BuildFile.xml | 16 + DAFTest/DAFValidator/plugins/DAFValidator.cc | 701 ++++++++++++++++++ DAFTest/DAFValidator/plugins/DAFValidator.h | 147 ++++ .../DAFValidator/plugins/DAFValidator_v1.cc | 186 +++++ ...rackValidator_DAFValidator_SingleMu_cfg.py | 126 ++++ ...tiTrackValidator_DAFValidator_TTbar_cfg.py | 133 ++++ .../test/MultiTrackValidator_SingleMu_cfg.py | 83 +++ .../test/MultiTrackValidator_TTbar_cfg.py | 89 +++ .../plugins/TkPixelMeasurementDet.cc | 1 - .../SiTrackerMRHTools/.admin/CVS/Entries | 2 + .../SiTrackerMRHTools/.admin/CVS/Repository | 1 + RecoTracker/SiTrackerMRHTools/.admin/CVS/Root | 1 + RecoTracker/SiTrackerMRHTools/.admin/CVS/Tag | 1 + .../SiTrackerMRHTools/.admin/developers | 50 ++ RecoTracker/SiTrackerMRHTools/BuildFile.xml | 21 + .../interface/GenericProjectedRecHit2D.h | 85 +++ .../interface/GroupedDAFHitCollector.h | 56 ++ .../interface/MeasurementByLayerGrouper.h | 39 + .../interface/MultiRecHitCollector.h | 26 + .../interface/SiTrackerMultiRecHitUpdator.h | 83 +++ .../interface/SimpleDAFHitCollector.h | 48 ++ .../SiTrackerMRHTools/plugins/BuildFile.xml | 6 + .../plugins/MultiRecHitCollectorESProducer.cc | 74 ++ .../plugins/MultiRecHitCollectorESProducer.h | 39 + .../SiTrackerMultiRecHitUpdatorESProducer.cc | 42 ++ .../SiTrackerMultiRecHitUpdatorESProducer.h | 26 + .../SiTrackerMRHTools/plugins/module.cc | 17 + .../python/GroupedMultiRecHitCollector_cff.py | 16 + .../python/GroupedMultiRecHitCollector_cfi.py | 13 + .../python/SiTrackerMultiRecHitUpdator_cff.py | 6 + .../python/SiTrackerMultiRecHitUpdator_cfi.py | 11 + .../python/SimpleMultiRecHitCollector_cff.py | 20 + .../python/SimpleMultiRecHitCollector_cfi.py | 12 + RecoTracker/SiTrackerMRHTools/src/.__afs4007 | Bin 0 -> 32768 bytes .../src/GenericProjectedRecHit2D.cc | 36 + .../src/GroupedDAFHitCollector.cc | 235 ++++++ .../src/MeasurementByLayerGrouper.cc | 72 ++ .../src/SiTrackerMultiRecHitUpdator.cc | 379 ++++++++++ .../src/SiTrackerMultiRecHitUpdator.cc~ | 240 ++++++ .../src/SimpleDAFHitCollector.cc | 193 +++++ RecoTracker/SiTrackerMRHTools/src/module.cc | 10 + .../test/DAFRecoTrack_cfg.py | 56 ++ RecoTracker/TrackProducer/BuildFile.xml | 1 + .../interface/DAFTrackProducerAlgorithm.h | 95 +++ .../TrackProducer/plugins/BuildFile.xml | 2 + .../TrackProducer/plugins/DAFTrackProducer.cc | 134 ++++ .../TrackProducer/plugins/DAFTrackProducer.h | 33 + .../TrackProducer/plugins/SealModules.cc | 2 + .../TrackProducer/plugins/TrackRefitter.cc | 5 + .../python/CTFFinalFitWithMaterialDAF_cff.py | 41 + .../python/CTFFinalFitWithMaterialDAF_cfi.py | 17 + .../src/DAFTrackProducerAlgorithm.cc | 382 ++++++++++ .../interface/MRHChi2MeasurementEstimator.h | 8 +- .../src/Chi2MeasurementEstimator.cc | 2 + TrackingTools/KalmanUpdators/src/KFUpdator.cc | 1 + .../src/MRHChi2MeasurementEstimator.cc | 73 +- TrackingTools/PatternTools/BuildFile.xml | 1 + .../PatternTools/interface/TrajAnnealing.h | 48 ++ .../PatternTools/src/TrajAnnealing.cc | 70 ++ TrackingTools/PatternTools/src/classes.h | 6 +- .../PatternTools/src/classes_def.xml | 4 + .../TrackFitters/python/TrackFitters_cff.py | 2 +- .../TrackFitters/src/KFFittingSmoother.cc | 4 +- .../TrackFitters/src/KFTrajectoryFitter.cc | 46 +- .../TrackFitters/src/KFTrajectorySmoother.cc | 1 - .../interface/TransientTrackingRecHit.h | 11 + 71 files changed, 4703 insertions(+), 45 deletions(-) create mode 100644 DAFTest/DAFValidator/macro/.__afsD2B2 create mode 100644 DAFTest/DAFValidator/macro/.__afsE9C8 create mode 100644 DAFTest/DAFValidator/macro/HistoHit.C create mode 100644 DAFTest/DAFValidator/macro/PlotComparisonMaker.C create mode 100644 DAFTest/DAFValidator/macro/PlotComparisonMaker_v2.C create mode 100644 DAFTest/DAFValidator/plugins/BuildFile.xml create mode 100644 DAFTest/DAFValidator/plugins/DAFValidator.cc create mode 100644 DAFTest/DAFValidator/plugins/DAFValidator.h create mode 100644 DAFTest/DAFValidator/plugins/DAFValidator_v1.cc create mode 100644 DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_SingleMu_cfg.py create mode 100644 DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_TTbar_cfg.py create mode 100644 DAFTest/DAFValidator/test/MultiTrackValidator_SingleMu_cfg.py create mode 100644 DAFTest/DAFValidator/test/MultiTrackValidator_TTbar_cfg.py create mode 100644 RecoTracker/SiTrackerMRHTools/.admin/CVS/Entries create mode 100644 RecoTracker/SiTrackerMRHTools/.admin/CVS/Repository create mode 100644 RecoTracker/SiTrackerMRHTools/.admin/CVS/Root create mode 100644 RecoTracker/SiTrackerMRHTools/.admin/CVS/Tag create mode 100644 RecoTracker/SiTrackerMRHTools/.admin/developers create mode 100644 RecoTracker/SiTrackerMRHTools/BuildFile.xml create mode 100644 RecoTracker/SiTrackerMRHTools/interface/GenericProjectedRecHit2D.h create mode 100644 RecoTracker/SiTrackerMRHTools/interface/GroupedDAFHitCollector.h create mode 100644 RecoTracker/SiTrackerMRHTools/interface/MeasurementByLayerGrouper.h create mode 100644 RecoTracker/SiTrackerMRHTools/interface/MultiRecHitCollector.h create mode 100644 RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h create mode 100644 RecoTracker/SiTrackerMRHTools/interface/SimpleDAFHitCollector.h create mode 100644 RecoTracker/SiTrackerMRHTools/plugins/BuildFile.xml create mode 100644 RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.cc create mode 100644 RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.h create mode 100644 RecoTracker/SiTrackerMRHTools/plugins/SiTrackerMultiRecHitUpdatorESProducer.cc create mode 100644 RecoTracker/SiTrackerMRHTools/plugins/SiTrackerMultiRecHitUpdatorESProducer.h create mode 100644 RecoTracker/SiTrackerMRHTools/plugins/module.cc create mode 100644 RecoTracker/SiTrackerMRHTools/python/GroupedMultiRecHitCollector_cff.py create mode 100644 RecoTracker/SiTrackerMRHTools/python/GroupedMultiRecHitCollector_cfi.py create mode 100644 RecoTracker/SiTrackerMRHTools/python/SiTrackerMultiRecHitUpdator_cff.py create mode 100644 RecoTracker/SiTrackerMRHTools/python/SiTrackerMultiRecHitUpdator_cfi.py create mode 100644 RecoTracker/SiTrackerMRHTools/python/SimpleMultiRecHitCollector_cff.py create mode 100644 RecoTracker/SiTrackerMRHTools/python/SimpleMultiRecHitCollector_cfi.py create mode 100644 RecoTracker/SiTrackerMRHTools/src/.__afs4007 create mode 100644 RecoTracker/SiTrackerMRHTools/src/GenericProjectedRecHit2D.cc create mode 100644 RecoTracker/SiTrackerMRHTools/src/GroupedDAFHitCollector.cc create mode 100644 RecoTracker/SiTrackerMRHTools/src/MeasurementByLayerGrouper.cc create mode 100644 RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc create mode 100644 RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc~ create mode 100644 RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc create mode 100644 RecoTracker/SiTrackerMRHTools/src/module.cc create mode 100644 RecoTracker/SiTrackerMRHTools/test/DAFRecoTrack_cfg.py create mode 100644 RecoTracker/TrackProducer/interface/DAFTrackProducerAlgorithm.h create mode 100644 RecoTracker/TrackProducer/plugins/DAFTrackProducer.cc create mode 100644 RecoTracker/TrackProducer/plugins/DAFTrackProducer.h create mode 100644 RecoTracker/TrackProducer/python/CTFFinalFitWithMaterialDAF_cff.py create mode 100644 RecoTracker/TrackProducer/python/CTFFinalFitWithMaterialDAF_cfi.py create mode 100644 RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc create mode 100644 TrackingTools/PatternTools/interface/TrajAnnealing.h create mode 100644 TrackingTools/PatternTools/src/TrajAnnealing.cc diff --git a/DAFTest/DAFValidator/macro/.__afsD2B2 b/DAFTest/DAFValidator/macro/.__afsD2B2 new file mode 100644 index 0000000000000000000000000000000000000000..4a59fabeb5cc34262b4af994e7bb4d49a3c254f8 GIT binary patch literal 20480 zcmeI3TWlOx8OI0O64DR~lv^Vzoo)foI_uq?bzHZ`c1fMu2_$KRm!xS)-0|-0?#SaA zGc%5zTWM8jtM&m^0-5;DWDYSRA4@=_1(B$>n|D6P`^HN zow)iPAMZ@3LX-kZ0i}RaKq;UUPzopolmbeDOICq!?lSFD+}#_KJKUWd-_UlvJh?WK zW4SHF|La$2+SBkO*Z{wHtEN2#Pr%pUA-DtfLJl^<+u_uDP5U7{4&Q)-up4r) z7JmO0P5T|3f#={^I1Z1%z3@r61v2n1czvCw{T99h7JL-OU<5WnKNKJb8{ir^d!?qG zhM&L>;M?#hJOKAY9X<>K*1)T4HSHxh3CH1!@F)b}!yI_v!n@&}@Y6SI+GFrAEPxC9 zVHmE27t!CMP;TU`cz6_s+d!PyvFbF;H8V;Nn;m7bj_&iL*2GHO&97KPC zm*Fg&fuF$(@ECj!?gJl8xC^3>5S6~sNh>Vdm6=67`ynk2nDFgtN5H{mib^#;EsvS* z0W%Q26)_@QYe6IddZsc}_szLRCf7Wpbc(m#aoe%jjN*8K6&G?;h7+@KqpV+uqtSQk zC`6-glw6K}z;x!V-hrr{GNlkfSRERwc=O@#aAvdPn8LT~rpSolVVe-q@PuQ9p%;aS zC_7P6Cd;ilaecC!sy9FFSV@Wzp~u%*_O{gYIm@r)D^o$}>)B@2c1`b$%!c<)yu%C|Lqij?G@2Lci#c&;aUWlX{3`9sl8WN`i6G$@Ld=#ryz=d^~B# z>FdkV*VFWE$qR*?5#=_D%@0Z()(&`fRaAX*f%$BgCr*;dC&@%y#P5dM?qs2j6 zw@sFBlVOE|5QOsV?qICU&d=(bmcQi-?cL>GJsND-C=9;nLA&vR2megtXiu8t*bXYHj>GVY^pv{RoJ1RAxE? zI(|2F1hleT><@{S$q@qmE?uLuDs9e6CTG=I9DbyUsx9VSQ`F|&L$>Eeqn@X(P>_=W z!=Y(HbR!oVj&npsHc1ZlLZO=p!*cX4_DVyB`RHB5cJ%e<`lA6~C@_f$=4@%Jd|R*+ zn{C~;v?<+6>oAB*EKr*P`VXy%ybESZVYl0d^V^KBHh|eao%N;B=wb!HN5 z758CI4j1!SS7~bm^L$Aj<*78_@|2@2SAI1QOHPOxNNh|_3?`>Z>NrQK6`!7wDNUM| z9F@^3t5`hR&0gK+TIaJ@7$mv=A7P#S63F$xh<>%OCT7il8cxC2;a)Id3w!|H4}WF7 z|0LWGpMe_O4DW$|$+bSb04LxWJP0!|32a5yu7xY$ayU)>r{FhfTatFDgHk{#pcGIF zCCm@6e=VqHk1eu2ye#L;qlMr@2h(M-&To*boD}NRxh2 zCw42IBVU6Tf?;hBiSd|QzHK^X->l38{F|J7+q>qglW#r@K4w+CI76Bm7euQX>5{Y- z!%4bN$0HECOgf^+J-oY{mOc&g*2pVgGA8cTVlj5GF3T+A<9?gj)3C$%^;vm)q)u;H6r|5?`eXW$ul0=@(f!zW-E z3h-X|J8S)?;chTN?gyBJkH9v#6}Er@I`qI*unt~j-T!kq3EzeLpaOEgz|A1w75o8@ z!-H@S90IvVU=AGE3%5fLybspFKa%_T6USHJkMJxUgCnpP@^Cf$jrad2;al)cP#>j$ zQa~x76i^B%1(X6xf&U8yM7nFRa~omzm=!h{u9RtoxD}$>H#1&H(hJ@idGUpB1Eflw$C2#LdVQR%pK{6*4AA+c0a#i@i#C7Vz#xa-~VdX)8!nH?vo zlF&Z^Zk#yrCm?}9aN>Xv;>H<};La6fDDiUGC&5%02v?yWPl7jh6enQu^*mf?2D(cdHnys{QLj@ zS;oEx-+_<75g3C3=ztf&3*i1UjQtIM1>b_tz^A~1KIniZI0t@NV(epZ5A1{Y!5Bm! z0C&Jm&;>7p=KuqLJk8k8;79Nc_!@iy_P`F<02jbn@F(i{9sCBq0$&1G+vk7|GC&5% z02v?yWPl8i0W$FT88|*>j5~O++`eU0Vg>hlDv4s*oehGqYSpIU$g6tpmsehQnbC6l zy7Bjgw|%46f6GI#UeBUEX}kV`n#?9*rSadeO0uwv&Qr~jZ1LI<`=f^XdRg!08(ie=3O=kJiK#R}Ef}QMh|0;* zY9tmrEBuh<`^wAY?KXF#i>kPcQ+bk-Z(Sud6(!n8(OSJyy~r;XE2t3{>1@b1Hn{hO zj8x+Bqa$8MQazD&jAz=b@4St#!d(Er(w}f-i&!P4$Vgh(68Wa9 z{G`jxy+6kN66cHiCgGz}aZgqe&{LT}mv8-1c3*Q%Ri0I+bh@^tlB}dWFe-PDJqB*C zct5#v7g<8FZ?}VoW2MOcc5{ngipmELE#XCY&c^P`cdy!PG^&l-symkl)<0x>T7^8s cOAZaUVr{pKp14O*1UgCWgR8&F%W_cYzwhyk>i_@% literal 0 HcmV?d00001 diff --git a/DAFTest/DAFValidator/macro/HistoHit.C b/DAFTest/DAFValidator/macro/HistoHit.C new file mode 100644 index 0000000000000..d92701694aa1f --- /dev/null +++ b/DAFTest/DAFValidator/macro/HistoHit.C @@ -0,0 +1,210 @@ + +void drawingPlotFromOneFile(const std::string& datafile) +{ + float x[20] = {0.0, 0.5, 1, 2.5, 5, 10, 25, 50, 100, 10000, 1000000, 10000000, 50000000, 75000000, 100000000, 250000000, 500000000, 750000000, 1000000000, 5000000000}; + TH1F *g = new TH1F("g","histo",19,x);//100,0.5,100.5);//,1,0.5,10000000000); + std::string perc; + std::string line; + int i; + int npar = 5; + std::ifstream inFile; + inFile.open (datafile.c_str(), std::ios::in); + + TF1 *f1 = new TF1("f1","sin(x)/x",-10,10); + + //con parametri esterni + //TF1 *f1 = new TF1("f1","[0]*x*sin([1]*x)",-3,3); + //f1->SetParameter(0,10); + //f1->SetParameter(1,2); + + f1->SetTitle("Disegno di una funzione"); + f1->GetXaxis ()->SetTitle ("x"); + f1->GetYaxis ()->SetTitle ("sin(x)/x"); + f1->GetXaxis ()->CenterTitle (); + f1->GetYaxis ()->CenterTitle (); + + + while(!inFile.eof()) + { + getline(inFile, line); + istringstream iss(line); + string sub; + iss >> sub; + if (sub == "Begin" || sub == "something"){ + std::cin.ignore(256,' '); + } else { + inFile >> perc; + if(atof(perc.c_str())) { + double value = (double)atof(perc.c_str()); + //std::cout<<"Alla riga " <Fill(value*npar); + } + } + i++; + + } + + inFile.close(); + + TCanvas *c = new TCanvas("c_graph","c_graph"); + c->cd(); + c->SetGridy(); + c->SetGridx(); + c->SetTickx(); + c->SetTicky(); + c->SetLogy(); + c->SetLogx(); + + g->SetTitle("TGraph Title"); + g->GetXaxis()->SetTitle("#chi^{2}"); + g->GetYaxis()->SetTitle("N"); + g->SetMarkerStyle(11); + g->SetMarkerColor(6); +// g->SetMinimum(0); +// g->SetMaximum(40); + g->Draw("HISTO"); + f1->Draw("same"); + + c->Print( "histoProva.pdf","pdf" ); + +} + + +void drawingPlotFromTwoFile(const std::string& datafile1, const std::string& datafile2) +{ + TH1F *g = new TH1F("g","chi2",30,0.5,30.5);//,1,0.5,10000000000); + TH1F *g2= new TH1F("g2","chi2_prob",50,0.0,1.0);//,1,0.5,10000000000); + TH1F *h = new TH1F("h","histo2",30,0.5,30.5); + TH1F *h2= new TH1F("h2","chi2_prob2",50,0.0,1.0);//,1,0.5,10000000000); + std::string perc; + std::string line; + int i; + int npar = 5; + double chi2Cut = 100; + std::ifstream inFile1, inFile2; + inFile1.open (datafile1.c_str(), std::ios::in); + inFile2.open (datafile2.c_str(), std::ios::in); + + TF1 *fgamma = new TF1("fgamma", "TMath::GammaDist(x, [0], [1], [2])", 0, 30); + fgamma->SetParameters(npar/2, 0, 2); + + + while(!inFile1.eof()) + { + getline(inFile1, line); + istringstream iss(line); + string sub; + iss >> sub; + if (sub == "Begin" || sub == "something"){ + std::cin.ignore(256,' '); + } else { + inFile1 >> perc; + if(atof(perc.c_str())) { + double value = (double)atof(perc.c_str()); + //std::cout<<"Alla riga " <Fill(value*npar); + + g2->Fill(TMath::Prob(value*npar, npar)); + + } + } + i++; + + } + + inFile1.close(); + i = 0; + + while(!inFile2.eof()) + { + getline(inFile2, line); + istringstream iss(line); + string sub; + iss >> sub; + if (sub == "Begin" || sub == "something"){ + std::cin.ignore(256,' '); + } else { + inFile2 >> perc; + if(atof(perc.c_str())) { + double value = (double)atof(perc.c_str()); + //std::cout<<"Alla riga " <Fill(value*npar); + + h2->Fill(TMath::Prob(value*npar, npar)); + + } + } + i++; + + } + inFile2.close(); + + TCanvas *c = new TCanvas("c_graph","c_graph"); + c->cd(); + c->SetGridy(); + c->SetGridx(); + c->SetTickx(); + c->SetTicky(); +// c->SetLogy(); + + TLegend* legend = new TLegend(0.56, 0.77, 0.76, 0.92); + legend -> SetFillColor(kWhite); + legend -> SetFillStyle(1001); + legend -> SetTextFont(42); + legend -> SetTextSize(0.03); + + legend -> AddEntry(g,"cutsRecoTracks","L"); + legend -> AddEntry(h,"ctfWithMaterialTracksDAF","L"); + legend -> AddEntry(fgamma,"#chi^{2} with 5 dof","l"); + + g->SetTitle("TGraph Title"); + g->GetXaxis()->SetTitle("#chi^{2}"); + g->GetYaxis()->SetTitle("N/N_{tot}"); + g->SetMarkerStyle(11); + g->SetMarkerColor(6); + g->SetLineColor(2); + g -> GetXaxis() -> SetTitleSize(0.03); + g -> GetYaxis() -> SetTitleSize(0.03); + g -> GetXaxis() -> SetLabelSize(0.03); + g -> GetYaxis() -> SetLabelSize(0.03); + h->SetLineColor(4); + h->SetLineWidth(2); +// g->Fit(fgamma); + fgamma->SetLineColor(13); + fgamma->SetLineWidth(2); + fgamma->Draw(); + g->DrawNormalized("sameHISTO"); + h->DrawNormalized("sameHISTO"); + legend->Draw("same"); + fgamma->SetLineColor(13); + fgamma->SetLineWidth(2); + fgamma->Draw("same"); + + c->Print( "histoProva2.pdf","pdf" ); + + legend->Clear(); + legend -> AddEntry(g,"cutsRecoTracks","L"); + legend -> AddEntry(h,"ctfWithMaterialTracksDAF","L"); + + TCanvas *c2 = new TCanvas("c_graph2","c_graph2"); + c2->cd(); + c2->SetGridy(); + c2->SetGridx(); + c2->SetTickx(); + c2->SetTicky(); + //c2->SetLogy(); + g2->GetXaxis()->SetTitle("#chi^{2} prob"); + g2->GetYaxis()->SetTitle("N"); + g2-> GetXaxis() -> SetTitleSize(0.03); + g2-> GetYaxis() -> SetTitleSize(0.03); + g2-> GetXaxis() -> SetLabelSize(0.03); + g2-> GetYaxis() -> SetLabelSize(0.03); + g2->SetLineColor(2); + h2->SetLineColor(4); + h2->SetLineWidth(2); + g2->Draw(); + h2->Draw("same"); + legend->Draw("same"); + c->Print( "histoProva3.pdf","pdf" ); +} + diff --git a/DAFTest/DAFValidator/macro/PlotComparisonMaker.C b/DAFTest/DAFValidator/macro/PlotComparisonMaker.C new file mode 100644 index 0000000000000..fd01f11eacfb6 --- /dev/null +++ b/DAFTest/DAFValidator/macro/PlotComparisonMaker.C @@ -0,0 +1,84 @@ +/////////// +// Macro that provide to plot multivalidation varibles for recoTrack and DAF +// variables are: effic,fakerate,dzres_vs_eta_Sigma,pull*,chi2_prob ... +////////// + +#include + +std::string folderName = "/afs/cern.ch/user/e/ebrondol/CMSSWarea/CMSSW_7_1_0_pre5/src/DAFTest/DAFValidator/"; +std::string FileName1 = "multiprova.root"; +std::string FileName2 = "multiprova.root"; +//std::string FileName1 = "multitrackvalidator_SingleMuPt10_100evts_AllAssociators.root"; +//std::string FileName2 = "multitrackvalidator_DAF_SingleMuPt10_100evts_v3_AllAssociators.root"; +//std::string FileName1 = "multitrackvalidator_TTbar_10evts_AllAssociators.root"; +//std::string FileName2 = "multitrackvalidator_DAF_TTbar_10evts_v3_AllAssociators.root"; +std::string baseFolderRootName = "DQMData/Tracking/Track/"; +//std::string Associator = "quickAssociatorByHits"; +std::string Associator = "AssociatorByChi2"; +//std::string Associator = "AssociatorByPull"; +std::string MultivalLabelTracks1 = "cutsReco"; +std::string MultivalLabelTracks2 = "ctfWithMaterialDAF"; +std::string FolderRootName1 = baseFolderRootName + MultivalLabelTracks2 + "_" + Associator + "/"; +std::string FolderRootName2 = baseFolderRootName + MultivalLabelTracks2 + "_" + Associator + "/"; +//std::string HistoName = "dzres_vs_eta_Sigma"; + +//std::string HistoName = "chi2"; +//std::string HistoName = "assocSharedHit"; +//std::string HistoName = "tracks"; +//std::string HistoName = "pullDz"; +//std::string HistoName = "hits"; + +void PlotComparisonMaker(const char* HistoName) +{ + std::cout << "Plotting " << HistoName << " variable..." << std::endl; + std::string inFileTotalName1 = folderName + FileName1; + std::string inFileTotalName2 = folderName + FileName2; + + std::cout << "InputFile1: " << inFileTotalName1 << std::endl; + std::cout << "InputFile2: " << inFileTotalName2 << std::endl; + + TFile* f1 = TFile::Open(inFileTotalName1.c_str(), "READ"); + TFile* f2 = TFile::Open(inFileTotalName2.c_str(), "READ"); + + std::cout << "InputRootFile1: " << FolderRootName1 << std::endl; + std::cout << "InputRootFile2: " << FolderRootName2 << std::endl; + + TH1F* histo1 = (TH1F*)( f1->Get((FolderRootName1+HistoName).c_str()) ); + TH1F* histo2 = (TH1F*)( f2->Get((FolderRootName2+HistoName).c_str()) ); + + TCanvas* c1 = new TCanvas(); + c1 -> cd(); + c1 -> SetGridx(); + c1 -> SetGridy(); + + histo1 -> SetMarkerColor(2); + histo1 -> SetLineColor(2); + histo1 -> SetLineWidth(2); + histo2 -> SetMarkerColor(4); + histo2 -> SetLineColor(4); + histo1 -> GetYaxis() -> SetTitle("Number of Events"); + histo1 -> GetXaxis() -> SetTitle("#chi^{2}"); + histo1 -> GetXaxis() -> SetTitleSize(0.03); + histo1 -> GetYaxis() -> SetTitleSize(0.03); + histo1 -> GetXaxis() -> SetLabelSize(0.03); + histo1 -> GetYaxis() -> SetLabelSize(0.03); + + TLegend* legend = new TLegend(0.16, 0.77, 0.30, 0.92); + legend -> SetFillColor(kWhite); + legend -> SetFillStyle(1001); + legend -> SetTextFont(42); + legend -> SetTextSize(0.03); + + legend -> AddEntry(histo1,("cutsRecoTracks - "+Associator).c_str(),"PL"); + legend -> AddEntry(histo2,("ctfWithMaterialTracksDAF - "+Associator).c_str(),"PL"); + +// histo1 -> Draw("Histo"); +// histo2 -> Draw("Histosame"); + histo1 -> Draw("P"); + histo2 -> Draw("Psame"); + legend -> Draw("same"); + + c1 -> Print((string(HistoName)+"Comparison.pdf").c_str(), "pdf"); + c1 -> Print((string(HistoName)+"Comparison.png").c_str(), "png"); +// c1 -> SaveAs((string(HistoName)+"Comparison.C").c_str()); +} diff --git a/DAFTest/DAFValidator/macro/PlotComparisonMaker_v2.C b/DAFTest/DAFValidator/macro/PlotComparisonMaker_v2.C new file mode 100644 index 0000000000000..09ffc6a3e6ca8 --- /dev/null +++ b/DAFTest/DAFValidator/macro/PlotComparisonMaker_v2.C @@ -0,0 +1,67 @@ +//////// +// Macro that provide to plot multivalidation varibles for DAFValidator class +////////// + +#include + +std::string folderName = "/afs/cern.ch/user/e/ebrondol/CMSSWarea/CMSSW_7_1_0_pre5/src/DAFTest/DAFValidator/MultiTrackValidator/"; +std::string FileName1 = "DAFValidator_SingleMuPt10_100evts_v3_TrackAssocByPull.root"; +std::string FileName2 = "DAFValidator_TTbar_10evts_v3_TrackAssocByPull.root"; +std::string baseFolderRootName = "demo/"; +std::string HistoName = "Weight"; + +//void PlotComparisonMaker_v2(const char* HistoName) +void PlotComparisonMaker_v2() +{ + std::cout << "Plotting " << HistoName << " variable..." << std::endl; + std::string inFileTotalName1 = folderName + FileName1; + std::string inFileTotalName2 = folderName + FileName2; + + std::cout << "InputFile1: " << inFileTotalName1 << std::endl; + std::cout << "InputFile2: " << inFileTotalName2 << std::endl; + + TFile* f1 = TFile::Open(inFileTotalName1.c_str(), "READ"); + TFile* f2 = TFile::Open(inFileTotalName2.c_str(), "READ"); + + TH1F* histo1 = (TH1F*)( f1->Get((baseFolderRootName+HistoName).c_str()) ); + TH1F* histo2 = (TH1F*)( f2->Get((baseFolderRootName+HistoName).c_str()) ); + + TCanvas* c1 = new TCanvas(); + c1 -> cd(); + c1 -> SetGridx(); + c1 -> SetGridy(); + + histo1 -> SetMarkerColor(2); + histo1 -> SetLineColor(2); + histo1 -> SetLineWidth(2); + histo2 -> SetMarkerColor(4); + histo2 -> SetLineColor(4); + histo1 -> GetXaxis() -> SetTitle(HistoName.c_str()); + histo1 -> GetYaxis() -> SetTitle("Number of events"); + histo1 -> GetXaxis() -> SetTitleSize(0.03); + histo1 -> GetYaxis() -> SetTitleSize(0.03); + histo1 -> GetXaxis() -> SetLabelSize(0.03); + histo1 -> GetYaxis() -> SetLabelSize(0.03); + + TLegend* legend = new TLegend(0.16, 0.77, 0.30, 0.92); + legend -> SetFillColor(kWhite); + legend -> SetFillStyle(1001); + legend -> SetTextFont(42); + legend -> SetTextSize(0.03); + + legend -> AddEntry(histo1,"SingleMuPt10","PL"); + legend -> AddEntry(histo2,"TTbar","PL"); + + histo1 -> DrawNormalized(); + histo2 -> DrawNormalized("same"); +// histo1 -> Draw("Histo"); +// histo2 -> Draw("Histosame"); +// histo1 -> Draw("P"); +// histo2 -> Draw("Psame"); + legend -> Draw("same"); + + c1 -> Print((string(HistoName)+".pdf").c_str(), "pdf"); + c1 -> Print((string(HistoName)+".png").c_str(), "png"); +// c1 -> SaveAs((string(HistoName)+"Comparison.C").c_str()); +} + diff --git a/DAFTest/DAFValidator/plugins/BuildFile.xml b/DAFTest/DAFValidator/plugins/BuildFile.xml new file mode 100644 index 0000000000000..7291e72584726 --- /dev/null +++ b/DAFTest/DAFValidator/plugins/BuildFile.xml @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + + + diff --git a/DAFTest/DAFValidator/plugins/DAFValidator.cc b/DAFTest/DAFValidator/plugins/DAFValidator.cc new file mode 100644 index 0000000000000..909304154618e --- /dev/null +++ b/DAFTest/DAFValidator/plugins/DAFValidator.cc @@ -0,0 +1,701 @@ +#include "DAFTest/DAFValidator/plugins/DAFValidator.h" + +#include "TrackingTools/PatternTools/interface/Trajectory.h" +#include "TrackingTools/PatternTools/interface/TrajAnnealing.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/Utilities/interface/Exception.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "SimTracker/TrackAssociation/interface/TrackAssociatorBase.h" +#include "SimTracker/Records/interface/TrackAssociatorRecord.h" +#include "SimTracker/TrackerHitAssociation/interface/TrackerHitAssociator.h" +#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h" +#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h" +#include "DataFormats/GeometryVector/interface/LocalPoint.h" +#include "TrackingTools/PatternTools/interface/TrajectoryMeasurement.h" +#include "DataFormats/TrackerRecHit2D/interface/SiPixelRecHit.h" +#include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit2D.h" +#include "DataFormats/TrackerRecHit2D/interface/SiStripMatchedRecHit2D.h" +#include "DataFormats/TrackerRecHit2D/interface/ProjectedSiStripRecHit2D.h" +#include "DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h" +#include "TrackingTools/PatternTools/interface/TrajTrackAssociation.h" +#include "DataFormats/TrackingRecHit/interface/TrackingRecHitFwd.h" +#include "RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h" +#include "SimDataFormats/TrackingHit/interface/PSimHit.h" + +using namespace std; +using namespace edm; +typedef TransientTrackingRecHit::ConstRecHitPointer ConstRecHitPointer; + + +int event = 0; + +DAFValidator::DAFValidator(const edm::ParameterSet& iConfig): + theConf_(iConfig), + tracksTag_(iConfig.getUntrackedParameter("tracks")), + trackingParticleTag_(iConfig.getParameter("trackingParticleLabel")), + associatorTag_(iConfig.getUntrackedParameter("associator")) +{ + //now do what ever initialization is needed + edm::Service fs; + annealing_weight = fs->make("AnnWeight","Changing of weights as a funct of annealing", 1000, 0.0, 1.0, 100, -1, 90); + annealing_weight_tgraph1 = fs->make(); + annealing_weight_tgraph2 = fs->make(); + annealing_weight_tgraph3 = fs->make(); + annealing_weight_tgraph4 = fs->make(); + annealing_weight_tgraph5 = fs->make(); + annealing_weight_tgraph6 = fs->make(); + annealing_weight_tot = fs->make(); + + //histos + histo_maxweight = fs->make("Weight", "max weight of the mrh components ", 110, 0, 1.1); + processtype_withassociatedsimhit_merged = fs->make("Process_Type_merged", "type of the process(merged_simhit)", 20, 0, 20); + processtype_withassociatedsimhit = fs->make("Process_Type", "type of the process", 20, 0, 20); + Hit_Histo = fs->make("Momentum_of_Hit", "momentum of the hit", 100, 0, 100); + MergedHisto = fs->make("Histogram_Hit_Merged", "type of the hit", 5, 0, 5); + NotMergedHisto = fs->make("Histogram_Hit_NotMerged", "type of the hit", 5, 0, 5); + weight_vs_processtype_merged = fs->make("WeightVsProcessType", "weight vs proc type", 20, 0, 20, 110, 0, 1.1 ); + weight_vs_processtype_notmerged = fs->make("WeightVsProcessTypeNotMerged", "weight vs proc type not merged", 20, 0, 20, 110, 0, 1.1 ); + pull_vs_weight = fs->make("PullVsWeight", "pull vs weight", 100, 0, 20, 110, 0, 1.1 ); + Merged_vs_weight = fs->make("HitsMergedVsWeight", "hits vs weight", 5, 0, 5, 110, 0, 1.1 ); + NotMerged_vs_weight = fs->make("HitsNotMergedVsWeight", "hits vs weight", 5, 0, 5, 110, 0, 1.1 ); + NotMergedPos = fs->make("BadHitsPositionNotMerged", "badposition", 600, -30, 30, 2400, -1200, 1200); + MergedPos = fs->make("BadHitsPositionMerged()", "badposition", 600, -30, 30, 2400, -1200, 1200); + +} + +DAFValidator::~DAFValidator() +{ + + // do anything here that needs to be done at desctruction time + // (e.g. close files, deallocate resources etc.) + +} + +// ------------ method called for each event ------------ +void +DAFValidator::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) +{ + using namespace reco; + event++; + + //get the track collection + Handle> trackCollection; + iEvent.getByLabel(tracksTag_, trackCollection); + + //get the trajectory annealing collection + Handle trajAnnCollection; + iEvent.getByLabel(tracksTag_, trajAnnCollection); + + //get the association map between Traj and Track + Handle assoMap; + iEvent.getByLabel(tracksTag_, assoMap); + + int nAnnealing = 1; + for(TrajAnnealingCollection::const_iterator iTA = trajAnnCollection->begin() ; + iTA != trajAnnCollection->end(); iTA++){ + //iTA->Debug(); + std::vector Weights = iTA->weights(); + float ann; + ann = iTA->getAnnealing(); + for(unsigned int i = 0; i < Weights.size(); i++) + { + if(nAnnealing == 1){ + annealing_weight_tgraph1->SetPoint(nHitsAnn1,Weights.at(i),ann); + nHitsAnn1++; + } + if(nAnnealing == 2){ + annealing_weight_tgraph2->SetPoint(nHitsAnn2,Weights.at(i),ann); + nHitsAnn2++; + } + if(nAnnealing == 3){ + annealing_weight_tgraph3->SetPoint(nHitsAnn3,Weights.at(i),ann); + nHitsAnn3++; + } + if(nAnnealing == 4){ + annealing_weight_tgraph4->SetPoint(nHitsAnn4,Weights.at(i),ann); + nHitsAnn4++; + } + if(nAnnealing == 5){ + annealing_weight_tgraph5->SetPoint(nHitsAnn5,Weights.at(i),ann); + nHitsAnn5++; + } + if(nAnnealing == 6){ + annealing_weight_tgraph6->SetPoint(nHitsAnn6,Weights.at(i),ann); + nHitsAnn6++; + } + annealing_weight->Fill(Weights.at(i),ann); + } + if(nAnnealing == 6) nAnnealing = 1; + else nAnnealing++; + } + + + //CMSSW_5_1_3 + //get tracker geometry + ESHandle tkgeom; + iSetup.get().get(tkgeom); + + //get the tracking particle collection + Handle trackingParticleCollection; + iEvent.getByLabel(trackingParticleTag_, trackingParticleCollection); + // float SimTracknum=trackingParticleCollection->size(); + + //hit associator :: CHECK IT + TrackerHitAssociator hitAssociate(iEvent, theConf_); + + //track associator (tracking particles to the reco track) + ESHandle associatorHandle; + iSetup.get().get(associatorTag_,associatorHandle); + reco::RecoToSimCollection RecsimColl = associatorHandle->associateRecoToSim(trackCollection, trackingParticleCollection, &iEvent, &iSetup); + + //loop over the recotrack looking for corresponding trackingparticle + int i = 0; + int nSimu = 0; + + for(TrajTrackAssociationCollection::const_iterator it = assoMap->begin();it != assoMap->end(); ++it){ + + std::map trackid; + + const edm::Ref > traj = it->key; + + const reco::TrackRef trackref = it->val; + trackid.insert(make_pair(trackref,i)); + edm::RefToBase track(trackCollection,i); + i++; + vector > simTracks; + TrackingParticleRef matchedSimTrack; + int nSim = 0; + + if(RecsimColl.find(track) != RecsimColl.end()){ + + simTracks=RecsimColl[track]; + float fractionmax=0; + for(vector >::const_iterator it = simTracks.begin(); it != simTracks.end(); ++it) + { + TrackingParticleRef simTrack = it->first; + float fraction = it->second; + + //pick the trackingparticle with the highest fraction of hishared hits + if(fraction > fractionmax) + { + matchedSimTrack = simTrack; + fractionmax=fraction; + nSim++; } + } + + analyzeHits(matchedSimTrack.get(), track.get(), hitAssociate, traj, tkgeom.product(), event); + nSimu++; + + } + } +} +//-------------------------------------------------------------------------------------- +void DAFValidator::analyzeHits(const TrackingParticle* tpref, + const reco::Track* rtref, + TrackerHitAssociator& hitassociator, + const edm::Ref > traj_iterator, + const TrackerGeometry* geom, + int event) { + + + if (!tpref || !rtref) { + cout << "something wrong: tpref = " << tpref << " rtref = " << rtref << endl; + return; + } + + //loop over the reco track rec hits, associate the simhits + trackingRecHit_iterator iter; + std::vector measurements =traj_iterator->measurements(); + std::vector::iterator traj_mes_iterator; + + for(traj_mes_iterator=measurements.begin();traj_mes_iterator!=measurements.end();traj_mes_iterator++){ + const TrackingRecHit* ttrh=traj_mes_iterator->recHit()->hit(); + + const SiTrackerMultiRecHit* mrh = dynamic_cast(ttrh); + const TrackingRecHit* rechit=0; + float maxweight = 0; + if (mrh){ + vector components = mrh->recHits(); + vector::const_iterator icomp; + int hitcounter=0; + for (icomp = components.begin(); icomp != components.end(); icomp++) { + if((*icomp)->isValid()) + { + //extract the hit with the max weight from the multirechit + weight = mrh->weight(hitcounter); + if(weight > maxweight) { + rechit=*icomp; + maxweight=weight; + } + } + + hitcounter++; + } + } + + else{ + if(ttrh->isValid()){ + rechit=ttrh; + maxweight=1; + } + } + if(rechit){ + + if (getType(rechit)==2.) + { + std::vector hits = rechit->recHits(); + + for(std::vector::iterator iterhits=hits.begin();iterhits!=hits.end();iterhits++) + { + const TrackingRecHit* rechit1 = *iterhits; + + LocalPoint pos; + if(rechit1->isValid()) pos=rechit1->localPosition(); + //unsigned int detid=rechit->geographicalId().rawId(); + + TrajectoryStateOnSurface tsos = traj_mes_iterator->updatedState(); + + AlgebraicVector tsospos(2); + tsospos[0]=tsos.localPosition().x(); + tsospos[1]=tsos.localPosition().y(); + + AlgebraicVector hitposition(2); + hitposition[0]=pos.x(); + hitposition[1]=pos.y(); + + AlgebraicVector tsoserr(3); + tsoserr[0] = tsos.localError().positionError().xx(); + tsoserr[1] = tsos.localError().positionError().yy(); + tsoserr[2] = tsos.localError().positionError().xy(); + + AlgebraicVector hiterr(3); + hiterr[0] = rechit1->localPositionError().xx(); + hiterr[1] = rechit1->localPositionError().yy(); + hiterr[2] = rechit1->localPositionError().xy(); + + tsoslocalx = tsospos[0]; + tsoslocaly = tsospos[1]; + + hitlocalx = hitposition[0]; + hitlocaly = hitposition[1]; + + tsoslocalsigmax = tsoserr[0]; + tsoslocalsigmay = tsoserr[1]; + tsoslocalcov = tsoserr[2]; + + hitlocalsigmax = hiterr[0]; + hitlocalsigmay = hiterr[1]; + hitlocalcov = hiterr[2]; + + nevent=event; + weight=maxweight; + GlobalPoint point=getGlobalPosition(rechit1,geom); + r=point.perp(); + zeta=point.z(); + phi=point.phi(); + hittype=getType(rechit1); + detId=rechit->geographicalId().rawId(); + + //ERICA :: fixed hit associator !! + //do the association between rechits and simhits + vector matchedhits; + vector simhitids; + matchedhits = hitassociator.associateHit(*rechit1); + simhitids = hitassociator.associateHitId(*rechit1); + fillDAFHistos(matchedhits, maxweight, rechit1, geom); + fillPHistos(matchedhits); + + if(matchedhits.size()!=1){ + notmergedtype=0; + mergedtype=fillMergedHisto(simhitids,matchedhits,tpref,maxweight,geom); + + } + + else{ + + mergedtype=0; + notmergedtype=fillNotMergedHisto(simhitids,matchedhits,tpref,maxweight,geom); + + } + + mrhit->Fill(); + } + } + + else { + LocalPoint pos; + if(rechit->isValid()) pos=rechit->localPosition(); + //unsigned int detid=rechit->geographicalId().rawId(); + + TrajectoryStateOnSurface tsos = traj_mes_iterator->updatedState(); + + AlgebraicVector tsospos(2); + tsospos[0]=tsos.localPosition().x(); + tsospos[1]=tsos.localPosition().y(); + + AlgebraicVector hitposition(2); + hitposition[0]=pos.x(); + hitposition[1]=pos.y(); + + AlgebraicVector tsoserr(3); + tsoserr[0] = tsos.localError().positionError().xx(); + tsoserr[1] = tsos.localError().positionError().yy(); + tsoserr[2] = tsos.localError().positionError().xy(); + + AlgebraicVector hiterr(3); + hiterr[0] = rechit->localPositionError().xx(); + hiterr[1] = rechit->localPositionError().yy(); + hiterr[2] = rechit->localPositionError().xy(); + + tsoslocalx = tsospos[0]; + tsoslocaly = tsospos[1]; + + hitlocalx = hitposition[0]; + hitlocaly = hitposition[1]; + + tsoslocalsigmax = tsoserr[0]; + tsoslocalsigmay = tsoserr[1]; + tsoslocalcov = tsoserr[2]; + + hitlocalsigmax = hiterr[0]; + hitlocalsigmay = hiterr[1]; + hitlocalcov = hiterr[2]; + + nevent=event; + weight=maxweight; + GlobalPoint point=getGlobalPosition(rechit,geom); + r=point.perp(); + zeta=point.z(); + phi=point.phi(); + hittype=getType(rechit); + detId=rechit->geographicalId().rawId(); + + //ERICA :: fixed hit associator !! + //do the association between rechits and simhits + vector matchedhits; + vector simhitids; + matchedhits = hitassociator.associateHit(*rechit); + simhitids = hitassociator.associateHitId(*rechit); + fillDAFHistos(matchedhits, maxweight, rechit, geom); + fillPHistos(matchedhits); + + if(matchedhits.size()!=1){ + notmergedtype=0; + mergedtype=fillMergedHisto(simhitids,matchedhits,tpref,maxweight,geom); + } + + else{ + mergedtype=0; + notmergedtype=fillNotMergedHisto(simhitids,matchedhits,tpref,maxweight,geom); + } + + mrhit->Fill(); + + } + + } + + } +} + +// ------------ method called once each job just before starting event loop ------------ +void DAFValidator::beginJob() +{ + +} + +// ------------ method called once each job just after ending the event loop ------------ +void DAFValidator::endJob() +{ + +} + +// ------------ method called when starting to processes a run ------------ +void DAFValidator::beginRun(edm::Run const&, edm::EventSetup const&) +{ + int bufsize = 64000; + mrhit = new TTree("Ntuple","Ntuple"); + mrhit->Branch("mergedtype" , &mergedtype , "mergedtype/I" , bufsize); + mrhit->Branch("notmergedtype" , ¬mergedtype , "notmergedtype/I" , bufsize); + mrhit->Branch("weight" , &weight , "weight/F" , bufsize); + mrhit->Branch("detId" , &detId , "detId/I" , bufsize); + mrhit->Branch("r" , &r , "r/F" , bufsize); + mrhit->Branch("zeta" , &zeta , "zeta/F" , bufsize); + mrhit->Branch("phi" , &phi , "phi/F" , bufsize); + mrhit->Branch("hittyipe" , &hittype , "hittype/F" , bufsize); + mrhit->Branch("event" , &nevent , "nevent/I" , bufsize); + + + + mrhit->Branch("hitlocalx" , &hitlocalx , "hitlocalx/F" , bufsize); + mrhit->Branch("hitlocaly" , &hitlocaly , "hitlocaly/F" , bufsize); + mrhit->Branch("hitlocalsigmax" , &hitlocalsigmax , "hitlocalsigmax/F" , bufsize); + mrhit->Branch("hitlocalsigmay" , &hitlocalsigmay , "hitlocalsigmay/F" , bufsize); + mrhit->Branch("hitlocalcov" , &hitlocalcov , "hitlocalcov/F" , bufsize); + mrhit->Branch("tsoslocalx" , &tsoslocalx , "tsoslocalx/F" , bufsize); + mrhit->Branch("tsoslocaly" , &tsoslocaly , "tsoslocaly/F" , bufsize); + mrhit->Branch("tsoslocalsigmax" , &tsoslocalsigmax , "tsoslocalsigmax/F" , bufsize); + mrhit->Branch("tsoslocalsigmay" , &tsoslocalsigmay , "tsoslocalsigmay/F" , bufsize); + mrhit->Branch("tsoslocalcov" , &tsoslocalcov , "tsoslocalcov/F" , bufsize); + mrhit->Branch("RecoTracknum" , &tsoslocalcov , "tsoslocalcov/F" , bufsize); + mrhit->Branch("SimTracknum" , &tsoslocalcov , "tsoslocalcov/F" , bufsize); + + event=0; + mergedtype=0; + notmergedtype=0; + nHitsAnn1=0; + nHitsAnn2=0; + nHitsAnn3=0; + nHitsAnn4=0; + nHitsAnn5=0; + nHitsAnn6=0; + +} + + +// ------------ method called when ending the processing of a run ------------ +void DAFValidator::endRun(edm::Run const&, edm::EventSetup const&) +{ + //drawing + TCanvas* c = new TCanvas(); + c -> cd(); + c -> SetGridx(); + c -> SetGridy(); + + annealing_weight_tgraph1 -> SetMarkerColor(2); + annealing_weight_tgraph1 -> SetLineColor(2); + annealing_weight_tgraph1 -> SetMarkerStyle(10); + annealing_weight_tgraph2 -> SetMarkerColor(3); + annealing_weight_tgraph2 -> SetLineColor(3); + annealing_weight_tgraph2 -> SetMarkerStyle(10); + annealing_weight_tgraph3 -> SetMarkerColor(4); + annealing_weight_tgraph3 -> SetLineColor(4); + annealing_weight_tgraph3 -> SetMarkerStyle(10); + annealing_weight_tgraph4 -> SetMarkerColor(7); + annealing_weight_tgraph4 -> SetLineColor(7); + annealing_weight_tgraph4 -> SetMarkerStyle(10); + annealing_weight_tgraph4 -> SetMarkerSize(3); + annealing_weight_tgraph5 -> SetMarkerColor(6); + annealing_weight_tgraph5 -> SetLineColor(6); + annealing_weight_tgraph5 -> SetMarkerStyle(10); + annealing_weight_tgraph5 -> SetMarkerSize(2); + annealing_weight_tgraph6 -> SetMarkerColor(97); + annealing_weight_tgraph6 -> SetLineColor(97); + annealing_weight_tgraph6 -> SetMarkerStyle(10); + + annealing_weight_tot -> SetTitle(" ;weights;annealing value"); + annealing_weight_tot -> Add(annealing_weight_tgraph1); + annealing_weight_tot -> Add(annealing_weight_tgraph2); + annealing_weight_tot -> Add(annealing_weight_tgraph3); + annealing_weight_tot -> Add(annealing_weight_tgraph4); + annealing_weight_tot -> Add(annealing_weight_tgraph5); + annealing_weight_tot -> Add(annealing_weight_tgraph6); + annealing_weight_tot -> Draw("ap"); + +// c->Print("annweighttgraphPlot.pdf", "pdf"); +// c->SaveAs("annweighttgraphPlot.C"); + + +} + +// ------------ method fills 'descriptions' with the allowed parameters for the module ------------ +void DAFValidator::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + //The following says we do not know what parameters are allowed so do no validation + // Please change this to state exactly what you do use, even if it is no parameters + edm::ParameterSetDescription desc; + desc.setUnknown(); + descriptions.addDefault(desc); + + //Specify that only 'tracks' is allowed + //To use, remove the default given above and uncomment below + //ParameterSetDescription desc; + //desc.addUntracked("tracks","ctfWithMaterialTracks"); + //descriptions.addDefault(desc); +} +//------------------------------------------------------------------------------------------------------ +void DAFValidator::fillDAFHistos(std::vector& matched, + float weight, + const TrackingRecHit* rechit, + const TrackerGeometry* geom){ + //this could be filled without matching + histo_maxweight->Fill(weight); + + //check the hit validity + if (!matched.size()){ + edm::LogError("DAFValidator") << "fillDAFHistos: this multirechit has no corresponding simhits"; + return; + } + + unsigned short ptype; + + if (matched.size()==1) + { + + float pull=calculatepull(rechit, matched.front(), geom); + pull_vs_weight->Fill(pull,weight); + + ptype = matched.front().processType(); + processtype_withassociatedsimhit->Fill(ptype); + weight_vs_processtype_notmerged->Fill(ptype, weight); + + } + + else if (matched.size()>1) + { + + for(vector::iterator imatched=matched.begin(); imatched!=matched.end(); imatched++ ) + { + float pull=calculatepull(rechit, (*imatched), geom); + pull_vs_weight->Fill(pull,weight); + + ptype = imatched->processType(); + processtype_withassociatedsimhit_merged->Fill(ptype); + weight_vs_processtype_merged->Fill(ptype, weight); + } + } + + +} +//------------------------------------------------------------------------------------------------------ +float DAFValidator::calculatepull(const TrackingRecHit* hit, + PSimHit simhit, + const TrackerGeometry* geom){ + + //perform the calculation of the pull + AlgebraicVector reccoor(2); + AlgebraicVector simcoor(2); + AlgebraicVector diffcoor(2); + + //reccoor[0] = getGlobalPositionRec(hit, geom).x(); + //reccoor[1] = getGlobalPositionRec(hit, geom).y(); + + //simcoor[0] = getGlobalPositionSim(simhit, geom).x(); + //simcoor[1] = getGlobalPositionSim(simhit, geom).y(); + + reccoor[0] = hit->localPosition().x(); + reccoor[1] = hit->localPosition().y(); + + simcoor[0] = simhit.localPosition().x(); + simcoor[1] = simhit.localPosition().y(); + + diffcoor = reccoor-simcoor; + float diff = sqrt(diffcoor[0]*diffcoor[0]+diffcoor[1]*diffcoor[1]); + + float sigma = sqrt((hit->localPositionError().xx() + hit->localPositionError().yy()+ hit->localPositionError().xy())); + float pull = diff/sigma; + + return pull; + //return diff; +} +//------------------------------------------------------------------------------------------------------ +void DAFValidator::fillPHistos(std::vector& components){ + //check the hit validity + if (!components.size()){ + edm::LogError("DAFValidator") << "fillPHistos: this multirechit has no hits"; + return; + } + + for(vector::iterator icomp=components.begin(); icomp!=components.end(); icomp++ ) + { + float pabs = icomp->pabs(); + Hit_Histo->Fill(pabs); + } +} +//------------------------------------------------------------------------------------------------------ +int DAFValidator::fillMergedHisto(const std::vector& simhitids, const std::vector& simhits, + const TrackingParticle* tpref, float weight, const TrackerGeometry* geom) const +{ + + if (simhitids.empty()) {cout << "something wrong" << endl;} + GlobalPoint point; + //unsigned int simcount=0; + for (TrackingParticle::g4t_iterator g4T = tpref -> g4Track_begin(); g4T != tpref -> g4Track_end(); ++g4T){ + //vector::const_iterator isimid; + vector::const_iterator isimid; + // unsigned int simcount=0; + //for (isimid = simhitids.begin(); isimid != simhitids.end(); isimid++){ + //in case of merged hits we have to make a for cicle + for(isimid = simhits.begin(); isimid != simhits.end(); isimid++){ + + if (((*g4T).trackId() == (*isimid).trackId()) || (isimid->processType() == 2)){ + return 2; + } + else continue; + } + } + return 1; +} +//------------------------------------------------------------------------------------------------------ +int DAFValidator::fillNotMergedHisto(const std::vector& simhitids, const std::vector& simhits, + const TrackingParticle* tpref, float weight, const TrackerGeometry* geom) const +{ + if (simhitids.empty()) {cout << "something wrong" << endl;} + + vector::const_iterator isimid = simhits.begin(); + //int simcount=0; + if ( isimid->processType() == 2) + { + for (TrackingParticle::g4t_iterator g4T = tpref -> g4Track_begin(); g4T != tpref -> g4Track_end(); ++g4T){ + //vector::const_iterator isimid; + // int simcount=0; + if ((*g4T).trackId()==isimid->trackId()) return 3; + } + } + + else { + for (TrackingParticle::g4t_iterator g4T = tpref -> g4Track_begin(); g4T != tpref -> g4Track_end(); ++g4T){ + //vector::const_iterator isimid; + // int simcount=0; + if ((*g4T).trackId()==isimid->trackId()) return 2; + } + } + + return 1; +} +//------------------------------------------------------------------------------------------------------ + + +float DAFValidator::getType(const TrackingRecHit* hit) const { + if (!hit->isValid()){ + throw cms::Exception("DAFValidator") << "This hit is invalid, cannot be casted as any type of tracker hit (strip or pixel)! "; + } + const SiPixelRecHit* pixhit = dynamic_cast(hit); + const SiStripRecHit2D* stripmono = dynamic_cast(hit); + const SiStripMatchedRecHit2D* stripmatched = dynamic_cast(hit); + const ProjectedSiStripRecHit2D* stripprojected = dynamic_cast(hit); + if(pixhit) return 0.; + else if (stripmono) return 1.; + else if (stripmatched) return 2.; + else if (stripprojected) return 3.; + else throw cms::Exception("DAFValidator") << "Rec Hits of type " << typeid(*hit).name() << " should not be present at this stage "; +} +//--------------------------------------------------------------------------------------------------------- +GlobalPoint DAFValidator::getGlobalPositionSim(const PSimHit hit, const TrackerGeometry* geom) const{ + + cout << "detid" << hit << endl; + DetId detid = DetId(hit.detUnitId()); + + //const GeomDet* gdet = geom->idToDet(hit.detUnitId()); + const GeomDet* gdet = geom->idToDet(detid); + GlobalPoint global = gdet->toGlobal(hit.localPosition()); + return global; +} +//--------------------------------------------------------------------------------------------------------- +GlobalPoint DAFValidator::getGlobalPosition(const TrackingRecHit* hit, const TrackerGeometry* geom) const{ + const GeomDet* gdet = geom->idToDet(hit->geographicalId()); + GlobalPoint global = gdet->toGlobal(hit->localPosition()); + return global; +} + +//--------------------------------------------------------------------------------------------------------- +std::pair > DAFValidator::getAnnealingWeight( const TrackingRecHit& aRecHit ) const { + + TSiTrackerMultiRecHit const & mHit = dynamic_cast(aRecHit); + return make_pair(mHit.getAnnealingFactor(), mHit.weights()); + +} +// +DEFINE_FWK_MODULE(DAFValidator); + + diff --git a/DAFTest/DAFValidator/plugins/DAFValidator.h b/DAFTest/DAFValidator/plugins/DAFValidator.h new file mode 100644 index 0000000000000..9fb1fcff80f39 --- /dev/null +++ b/DAFTest/DAFValidator/plugins/DAFValidator.h @@ -0,0 +1,147 @@ +/** \class DAFValidator + * An analyzer suitable for multitrack + * fitting algorithm like DAF, MTF and EA + * + * \author tropiano, genta (?) + * \review in May 2014 by brondolin + */ + +#ifndef DAFValidator_h +#define DAFValidator_h + +#include +#include +#include + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/GeometryVector/interface/GlobalPoint.h" +#include "DataFormats/TrackingRecHit/interface/TrackingRecHitFwd.h" +#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticleFwd.h" +#include "DataFormats/TrackReco/interface/Track.h" +#include "DataFormats/TrackReco/interface/TrackFwd.h" +#include "TrackingTools/PatternTools/interface/Trajectory.h" +#include "SimTracker/TrackerHitAssociation/interface/TrackerHitAssociator.h" + +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "CommonTools/UtilAlgos/interface/TFileService.h" +#include "TH1.h" +#include "TH2F.h" +#include "TTree.h" +#include "TFile.h" +#include "TGraph.h" +#include "TMultiGraph.h" +#include "TCanvas.h" + +class TrackerHitAssociator; +class TrackerGeometry; +class PSimHit; + +class DAFValidator : public edm::EDAnalyzer +{ + public: + explicit DAFValidator(const edm::ParameterSet& conf); + ~DAFValidator(); + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + virtual void beginJob() override; + virtual void beginRun(edm::Run const&, edm::EventSetup const&) override; + virtual void analyze(const edm::Event&, const edm::EventSetup&) override; + virtual void endRun(edm::Run const&, edm::EventSetup const&) override; + virtual void endJob() override; + + void analyzeHits(const TrackingParticle* tpref, const reco::Track* rtref, + TrackerHitAssociator& hitassociator, + const edm::Ref > traj_iterator, + const TrackerGeometry* geom, + int event); + GlobalPoint getGlobalPositionSim(const PSimHit hit, const TrackerGeometry* geom) const; + GlobalPoint getGlobalPosition(const TrackingRecHit* hit, const TrackerGeometry* geom) const; + void fillDAFHistos(std::vector& matched, float weight, + const TrackingRecHit* rechit, const TrackerGeometry* geom); + float calculatepull(const TrackingRecHit* hit, PSimHit simhit, const TrackerGeometry* geom); + void fillPHistos(std::vector& components); + int fillMergedHisto(const std::vector& simhitids, const std::vector& simhits, + const TrackingParticle* tpref, float weight, const TrackerGeometry* geom) const; + int fillNotMergedHisto(const std::vector& simhitids, const std::vector& simhits, + const TrackingParticle* tpref, float weight, const TrackerGeometry* geom) const; + float getType(const TrackingRecHit* hit) const; + std::pair > getAnnealingWeight( const TrackingRecHit& aRecHit ) const; + + private: + edm::ParameterSet theConf_; + edm::InputTag tracksTag_; + edm::InputTag trackingParticleTag_; + std::string associatorTag_; + TH1F* histo_maxweight; + + TH2F* weight_withassociatedsimhit_vs_type; + TH2F* weight_withassociatedsimhit_vs_r; + TH2F* weight_withassociatedsimhit_vs_eta; + TH1F* weight_partially_unmatched; + TH2F* weight_vs_type_partially_unmatched; + TH2F* weight_vs_r_partially_unmatched; + TH2F* weight_vs_eta_partially_unmatched; + TH1F* weight_totally_unmatched; + TH2F* weight_vs_type_totally_unmatched; + TH2F* weight_vs_r_totally_unmatched; + TH2F* weight_vs_eta_totally_unmatched; + TH1F* processtype_withassociatedsimhit_merged; + TH1F* processtype_withassociatedsimhit; + TH1F* Hit_Histo; + TH1F* MergedHisto; + TH1F* NotMergedHisto; + TH2F* weight_vs_processtype_merged; + TH2F* weight_vs_processtype_notmerged; + TH2F* pull_vs_weight; + TH2F* Merged_vs_weight; + TH2F* NotMerged_vs_weight; + TH2F* NotMergedPos; + TH2F* MergedPos; + TTree* mrhit; + // TTree* mrhit2; + int mergedtype; + int notmergedtype; + float weight; + uint32_t detId; + float r; + float zeta; + float phi; + float hittype; + int nevent; + float hitlocalx; + float hitlocaly; + float hitlocalsigmax; + float hitlocalsigmay; + float hitlocalcov; + float tsoslocalx; + float tsoslocaly; + float tsoslocalsigmax; + float tsoslocalsigmay; + float tsoslocalcov; + float SimTracknum; + float RecoTracknum; + + //ERICA + TH2F* annealing_weight; + int nHitsAnn1, nHitsAnn2, nHitsAnn3; + int nHitsAnn4, nHitsAnn5, nHitsAnn6; + TGraph* annealing_weight_tgraph1; + TGraph* annealing_weight_tgraph2; + TGraph* annealing_weight_tgraph3; + TGraph* annealing_weight_tgraph4; + TGraph* annealing_weight_tgraph5; + TGraph* annealing_weight_tgraph6; + TMultiGraph *annealing_weight_tot; + +}; +#endif + diff --git a/DAFTest/DAFValidator/plugins/DAFValidator_v1.cc b/DAFTest/DAFValidator/plugins/DAFValidator_v1.cc new file mode 100644 index 0000000000000..7ba6700737672 --- /dev/null +++ b/DAFTest/DAFValidator/plugins/DAFValidator_v1.cc @@ -0,0 +1,186 @@ +// -*- C++ -*- +// +// Package: DAFTest/DAFValidator_v1 +// Class: DAFValidator_v1 +// +/**\class DAFValidator_v1 DAFValidator_v1.cc DAFTest/DAFValidator_v1/plugins/DAFValidator_v1.cc + + Description: [one line class summary] + + Implementation: + [Notes on implementation] +*/ +// +// Original Author: Erica Brondolin +// Created: Wed, 07 May 2014 10:31:58 GMT +// +// + + +// system include files +#include + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "DataFormats/TrackReco/interface/Track.h" +#include "DataFormats/TrackReco/interface/TrackFwd.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "CommonTools/UtilAlgos/interface/TFileService.h" +#include "TH1.h" +// +// class declaration +// + +class DAFValidator_v1 : public edm::EDAnalyzer { + public: + explicit DAFValidator_v1(const edm::ParameterSet&); + ~DAFValidator_v1(); + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + + private: + virtual void beginJob() override; + virtual void analyze(const edm::Event&, const edm::EventSetup&) override; + virtual void endJob() override; + + //virtual void beginRun(edm::Run const&, edm::EventSetup const&) override; + //virtual void endRun(edm::Run const&, edm::EventSetup const&) override; + //virtual void beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override; + //virtual void endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override; + + // ----------member data --------------------------- + edm::InputTag tracksTag_; //used to select what tracks to read from configuration file + TH1F * h_track_q, *h_track_pt, *h_track_nlayers, *h_track_missoutlay; + +}; + +// +// constants, enums and typedefs +// + +// +// static data member definitions +// + +// +// constructors and destructor +// +DAFValidator_v1::DAFValidator_v1(const edm::ParameterSet& iConfig): + tracksTag_(iConfig.getUntrackedParameter("tracks")) +{ + //now do what ever initialization is needed + edm::Service fs; + h_track_q = fs->make("track_charge" , "track_charge" , 200 , -2 , 2 ); + h_track_pt = fs->make("track_pt", "track_pt", 100, 8., 12.); + h_track_nlayers = fs->make("track_nlayers","track_nlayers",20,-0.5,19.5); + h_track_missoutlay = fs->make("track_missoutlay","track_missoutlay",10,-0.5,9.5); + +} + + +DAFValidator_v1::~DAFValidator_v1() +{ + + // do anything here that needs to be done at desctruction time + // (e.g. close files, deallocate resources etc.) + +} + + +// +// member functions +// + +// ------------ method called for each event ------------ +void +DAFValidator_v1::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) +{ + using namespace edm; + using namespace reco; + using namespace std; + + Handle tracks; + iEvent.getByLabel(tracksTag_,tracks); + for(TrackCollection::const_iterator itTrack = tracks->begin(); itTrack != tracks->end(); ++itTrack) { + h_track_q->Fill( itTrack->charge() ); + h_track_pt->Fill(itTrack->pt()); + //hit pattern + HitPattern track_hitpatt = itTrack->hitPattern(); + h_track_nlayers->Fill(track_hitpatt.trackerLayersWithMeasurement()); + HitPattern track_missoutlay = itTrack->trackerExpectedHitsOuter(); + h_track_missoutlay->Fill(track_missoutlay.numberOfHits()); + } + +} + + +// ------------ method called once each job just before starting event loop ------------ +void +DAFValidator_v1::beginJob() +{ +} + +// ------------ method called once each job just after ending the event loop ------------ +void +DAFValidator_v1::endJob() +{ +} + +// ------------ method called when starting to processes a run ------------ +/* +void +DAFValidator_v1::beginRun(edm::Run const&, edm::EventSetup const&) +{ +} +*/ + +// ------------ method called when ending the processing of a run ------------ +/* +void +DAFValidator_v1::endRun(edm::Run const&, edm::EventSetup const&) +{ +} +*/ + +// ------------ method called when starting to processes a luminosity block ------------ +/* +void +DAFValidator_v1::beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) +{ +} +*/ + +// ------------ method called when ending the processing of a luminosity block ------------ +/* +void +DAFValidator_v1::endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) +{ +} +*/ + +// ------------ method fills 'descriptions' with the allowed parameters for the module ------------ +void +DAFValidator_v1::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + //The following says we do not know what parameters are allowed so do no validation + // Please change this to state exactly what you do use, even if it is no parameters + edm::ParameterSetDescription desc; + desc.setUnknown(); + descriptions.addDefault(desc); + + //Specify that only 'tracks' is allowed + //To use, remove the default given above and uncomment below + //ParameterSetDescription desc; + //desc.addUntracked("tracks","ctfWithMaterialTracks"); + //descriptions.addDefault(desc); +} + +//define this as a plug-in +DEFINE_FWK_MODULE(DAFValidator_v1); diff --git a/DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_SingleMu_cfg.py b/DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_SingleMu_cfg.py new file mode 100644 index 0000000000000..0c08466759a84 --- /dev/null +++ b/DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_SingleMu_cfg.py @@ -0,0 +1,126 @@ +import FWCore.ParameterSet.Config as cms + +process = cms.Process("MULTITRACKVALIDATOR") + +# message logger +process.MessageLogger = cms.Service("MessageLogger", + default = cms.untracked.PSet( limit = cms.untracked.int32(10) ) +) + +# source +readFiles = cms.untracked.vstring() +secFiles = cms.untracked.vstring() +source = cms.Source ("PoolSource",fileNames = readFiles, secondaryFileNames = secFiles) +readFiles.extend( [ + '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-RECO/POSTLS171_V1-v1/00000/980D6268-26B6-E311-AA4D-0025905A6136.root' ] ); + +secFiles.extend( [ + '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/0AD53A78-F5B5-E311-BF6A-00248C55CC9D.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/1CB3FB16-F6B5-E311-842C-0025905A613C.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/AA4515DD-F5B5-E311-834B-0025905A6076.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/AE114155-F5B5-E311-9837-002618943874.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/F85DDD54-F5B5-E311-98E0-002354EF3BCE.root' ] ); + +process.source = source +process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(100) ) + +### conditions +process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") +#from Configuration.AlCa.GlobalTag import GlobalTag +#process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:startup', '') +process.GlobalTag.globaltag = 'POSTLS171_V1::All' + +### standard includes +process.load('Configuration/StandardSequences/Services_cff') +process.load('Configuration.StandardSequences.Geometry_cff') +process.load("Configuration.StandardSequences.RawToDigi_cff") +process.load("Configuration.EventContent.EventContent_cff") +process.load("Configuration.StandardSequences.Reconstruction_cff") +process.load("Configuration.StandardSequences.MagneticField_cff") + +## includes for DAF +import RecoTracker.CkfPattern.CkfTrajectoryBuilderESProducer_cfi +import TrackingTools.TrajectoryCleaning.TrajectoryCleanerBySharedSeeds_cfi + +process.load("RecoTracker.TrackProducer.TrackRefitters_cff") +process.load("RecoTracker.TrackProducer.CTFFinalFitWithMaterialDAF_cff") +process.load("SimGeneral.MixingModule.mixNoPU_cfi") +# replace this with whatever track type you want to look at +process.TrackRefitter.TrajectoryInEvent = True +process.RKFittingSmoother.MinNumberOfHits=3 +process.TrackRefitter.Fitter = "RKFittingSmoother" +process.load("RecoTracker.TransientTrackingRecHit.TransientTrackingRecHitBuilderWithoutRefit_cfi") + +from RecoTracker.FinalTrackSelectors.TracksWithQuality_cff import * +process.ctfWithMaterialTracksDAF.TrajectoryInEvent = True +process.ctfWithMaterialTracksDAF.src = 'TrackRefitter' +process.MRHFittingSmoother.EstimateCut = -1 +process.MRHFittingSmoother.MinNumberOfHits = 3 + +import copy +from TrackingTools.KalmanUpdators.Chi2MeasurementEstimatorESProducer_cfi import * +# Chi2MeasurementEstimatorESProducer +RelaxedChi2 = copy.deepcopy(Chi2MeasurementEstimator) +RelaxedChi2.ComponentName = 'RelaxedChi2' +RelaxedChi2.MaxChi2 = 100. + +### validation-specific includes +process.load("SimTracker.TrackAssociation.quickTrackAssociatorByHits_cfi") +process.load("SimTracker.TrackAssociation.trackingParticleRecoTrackAsssociation_cfi") +process.load("Validation.RecoTrack.cuts_cff") +process.load("Validation.RecoTrack.MultiTrackValidator_cff") +process.load("DQMServices.Components.EDMtoMEConverter_cff") +process.load("Validation.Configuration.postValidation_cff") + +process.quickTrackAssociatorByHits.SimToRecoDenominator = cms.string('reco') + +process.load("SimTracker.TrackAssociation.TrackAssociatorByChi2_cfi") +process.TrackAssociatorByChi2ESProducer.chi2cut = cms.double(500.0) +process.TrackAssociatorByPullESProducer = process.TrackAssociatorByChi2ESProducer.clone( chi2cut = 50.0, + onlyDiagonal = True, + ComponentName = 'TrackAssociatorByPull') + +########### configuration MultiTrackValidator ######## +process.multiTrackValidator.outputFile = 'multiprova.root'#multitrackvalidator_DAF_SingleMuPt10_100evts_v3_AssocByPull.root' +#process.multiTrackValidator.associators = ['quickTrackAssociatorByHits'] +process.multiTrackValidator.associators = ['quickTrackAssociatorByHits','TrackAssociatorByChi2','TrackAssociatorByPull'] +process.multiTrackValidator.skipHistoFit=cms.untracked.bool(False) +process.multiTrackValidator.label = ['ctfWithMaterialTracksDAF'] +process.multiTrackValidator.UseAssociators = cms.bool(True) +process.multiTrackValidator.runStandalone = cms.bool(True) + +process.quickTrackAssociatorByHits.useClusterTPAssociation = cms.bool(True) +process.load("SimTracker.TrackerHitAssociation.clusterTpAssociationProducer_cfi") + +### DAF Validator +process.load('SimTracker.TrackAssociation.TrackAssociatorByHits_cfi') +process.load('SimGeneral.TrackingAnalysis.trackingParticles_cfi') + +process.demo = cms.EDAnalyzer('DAFValidator', + tracks = cms.untracked.InputTag('ctfWithMaterialTracksDAF'), + trackingParticleLabel = cms.InputTag("mix","MergedTrackTruth"), + associator = cms.untracked.string("TrackAssociatorByChi2"), + associatePixel = cms.bool(True), + associateStrip = cms.bool(True), + associateRecoTracks = cms.bool(True) +) + +process.TFileService = cms.Service("TFileService", + fileName = cms.string('prova.root')#DAFValidator_SingleMuPt10_100evts_v3_TrackAssocByPull.root') +) + +process.validation = cms.Sequence( +# process.tpClusterProducer * ##it does not compile with DAF::why? + process.multiTrackValidator +) + +# paths +process.p = cms.Path( + process.MeasurementTrackerEvent * process.TrackRefitter + * process.ctfWithMaterialTracksDAF + #* process.validation + * process.demo +) + + + diff --git a/DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_TTbar_cfg.py b/DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_TTbar_cfg.py new file mode 100644 index 0000000000000..495cced8a7553 --- /dev/null +++ b/DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_TTbar_cfg.py @@ -0,0 +1,133 @@ +import FWCore.ParameterSet.Config as cms + +process = cms.Process("MULTITRACKVALIDATOR") + +# message logger +process.MessageLogger = cms.Service("MessageLogger", + default = cms.untracked.PSet( limit = cms.untracked.int32(10) ) +) + +# source +readFiles = cms.untracked.vstring() +secFiles = cms.untracked.vstring() +source = cms.Source ("PoolSource",fileNames = readFiles, secondaryFileNames = secFiles) +readFiles.extend( [ + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-RECO/POSTLS171_V1-v1/00000/3E806F9A-4BB6-E311-A4D2-002618943935.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-RECO/POSTLS171_V1-v1/00000/66797485-44B6-E311-9924-002618943939.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-RECO/POSTLS171_V1-v1/00000/B4F97AB1-25B6-E311-A16B-003048FFD760.root' ] ); + +secFiles.extend( [ + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/0466F34F-2FB6-E311-B125-0026189438EA.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/40408552-2FB6-E311-B773-0025905A60A0.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/48164C0F-00B6-E311-8EEB-0025905A60CE.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/680935B9-FFB5-E311-9750-003048FFD71A.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/80154D86-32B6-E311-A72A-002618943858.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/AAFCD423-01B6-E311-A08C-003048FFD75C.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/E03BC81A-01B6-E311-9608-00261894385A.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/F2FC75BE-04B6-E311-BBAC-0025905A48BA.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/F44896B7-06B6-E311-96AC-0026189438D7.root' ] ); + +process.source = source +process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(10) ) + +### conditions +process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") +#from Configuration.AlCa.GlobalTag import GlobalTag +#process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:startup', '') +process.GlobalTag.globaltag = 'POSTLS171_V1::All' + +### standard includes +process.load('Configuration/StandardSequences/Services_cff') +process.load('Configuration.StandardSequences.Geometry_cff') +process.load("Configuration.StandardSequences.RawToDigi_cff") +process.load("Configuration.EventContent.EventContent_cff") +process.load("Configuration.StandardSequences.Reconstruction_cff") +process.load("Configuration.StandardSequences.MagneticField_cff") + +## includes for DAF +import RecoTracker.CkfPattern.CkfTrajectoryBuilderESProducer_cfi +import TrackingTools.TrajectoryCleaning.TrajectoryCleanerBySharedSeeds_cfi + +process.load("RecoTracker.TrackProducer.TrackRefitters_cff") +process.load("RecoTracker.TrackProducer.CTFFinalFitWithMaterialDAF_cff") +process.load("SimGeneral.MixingModule.mixNoPU_cfi") +# replace this with whatever track type you want to look at +process.TrackRefitter.TrajectoryInEvent = True +process.RKFittingSmoother.MinNumberOfHits=3 +process.TrackRefitter.Fitter = "RKFittingSmoother" +process.load("RecoTracker.TransientTrackingRecHit.TransientTrackingRecHitBuilderWithoutRefit_cfi") + +from RecoTracker.FinalTrackSelectors.TracksWithQuality_cff import * +process.ctfWithMaterialTracksDAF.TrajectoryInEvent = True +process.ctfWithMaterialTracksDAF.src = 'TrackRefitter' +process.MRHFittingSmoother.EstimateCut = -1 +process.MRHFittingSmoother.MinNumberOfHits = 3 + +import copy +from TrackingTools.KalmanUpdators.Chi2MeasurementEstimatorESProducer_cfi import * +# Chi2MeasurementEstimatorESProducer +RelaxedChi2 = copy.deepcopy(Chi2MeasurementEstimator) +RelaxedChi2.ComponentName = 'RelaxedChi2' +RelaxedChi2.MaxChi2 = 100. + +### validation-specific includes +process.load("SimTracker.TrackAssociation.quickTrackAssociatorByHits_cfi") +process.load("SimTracker.TrackAssociation.trackingParticleRecoTrackAsssociation_cfi") +process.load("Validation.RecoTrack.cuts_cff") +process.load("Validation.RecoTrack.MultiTrackValidator_cff") +process.load("DQMServices.Components.EDMtoMEConverter_cff") +process.load("Validation.Configuration.postValidation_cff") + +process.quickTrackAssociatorByHits.SimToRecoDenominator = cms.string('reco') + +process.load("SimTracker.TrackAssociation.TrackAssociatorByChi2_cfi") +process.TrackAssociatorByChi2ESProducer.chi2cut = cms.double(500.0) +process.TrackAssociatorByPullESProducer = process.TrackAssociatorByChi2ESProducer.clone( chi2cut = 50.0, + onlyDiagonal = True, + ComponentName = 'TrackAssociatorByPull') + +########### configuration MultiTrackValidator ######## +process.multiTrackValidator.outputFile = 'multitrackvalidator_DAF_TTbar_10evts_v3_AssocByPull.root' +process.multiTrackValidator.associators = ['quickTrackAssociatorByHits', 'TrackAssociatorByChi2','TrackAssociatorByPull'] +process.multiTrackValidator.skipHistoFit=cms.untracked.bool(False) +process.multiTrackValidator.label = ['ctfWithMaterialTracksDAF'] +process.multiTrackValidator.UseAssociators = cms.bool(True) +process.multiTrackValidator.runStandalone = cms.bool(True) + +process.quickTrackAssociatorByHits.useClusterTPAssociation = cms.bool(True) +process.load("SimTracker.TrackerHitAssociation.clusterTpAssociationProducer_cfi") + +### DAF Validator +process.load('SimTracker.TrackAssociation.TrackAssociatorByHits_cfi') +process.load('SimGeneral.TrackingAnalysis.trackingParticles_cfi') + +process.demo = cms.EDAnalyzer('DAFValidator', + tracks = cms.untracked.InputTag('ctfWithMaterialTracksDAF'), + trackingParticleLabel = cms.InputTag("mix","MergedTrackTruth"), + associator = cms.untracked.string("TrackAssociatorByChi2"), + associatePixel = cms.bool(True), + associateStrip = cms.bool(True), + associateRecoTracks = cms.bool(True) +) + +process.TFileService = cms.Service("TFileService", + fileName = cms.string('DAFValidator_TTbar_10evts_v3_TrackAssocByPull.root') +) + +process.validation = cms.Sequence( +# process.tpClusterProducer * ##it does not compile with DAF::why? + process.multiTrackValidator +) + +# paths +process.p = cms.Path( + process.MeasurementTrackerEvent * process.TrackRefitter + * process.ctfWithMaterialTracksDAF + #* process.validation + * process.demo +) +process.schedule = cms.Schedule( + process.p +) + + diff --git a/DAFTest/DAFValidator/test/MultiTrackValidator_SingleMu_cfg.py b/DAFTest/DAFValidator/test/MultiTrackValidator_SingleMu_cfg.py new file mode 100644 index 0000000000000..eb1ef5859fc44 --- /dev/null +++ b/DAFTest/DAFValidator/test/MultiTrackValidator_SingleMu_cfg.py @@ -0,0 +1,83 @@ +import FWCore.ParameterSet.Config as cms + +process = cms.Process("MULTITRACKVALIDATOR") + +# message logger +process.MessageLogger = cms.Service("MessageLogger", + default = cms.untracked.PSet( limit = cms.untracked.int32(10) ) +) + +# source +readFiles = cms.untracked.vstring() +secFiles = cms.untracked.vstring() +source = cms.Source ("PoolSource",fileNames = readFiles, secondaryFileNames = secFiles) +readFiles.extend( [ + '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-RECO/POSTLS171_V1-v1/00000/980D6268-26B6-E311-AA4D-0025905A6136.root' ] ); + +secFiles.extend( [ + '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/0AD53A78-F5B5-E311-BF6A-00248C55CC9D.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/1CB3FB16-F6B5-E311-842C-0025905A613C.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/AA4515DD-F5B5-E311-834B-0025905A6076.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/AE114155-F5B5-E311-9837-002618943874.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/F85DDD54-F5B5-E311-98E0-002354EF3BCE.root' ] ); + +process.source = source +process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(100) ) + +### conditions +process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") +#from Configuration.AlCa.GlobalTag import GlobalTag +#process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:startup', '') +process.GlobalTag.globaltag = 'POSTLS171_V1::All' + +### standard includes +process.load('Configuration/StandardSequences/Services_cff') +process.load('Configuration.StandardSequences.Geometry_cff') +process.load("Configuration.StandardSequences.RawToDigi_cff") +process.load("Configuration.EventContent.EventContent_cff") +process.load("Configuration.StandardSequences.Reconstruction_cff") +process.load("Configuration.StandardSequences.MagneticField_cff") + +### validation-specific includes +process.load("SimTracker.TrackAssociation.quickTrackAssociatorByHits_cfi") +process.load("SimTracker.TrackAssociation.trackingParticleRecoTrackAsssociation_cfi") +process.load("Validation.RecoTrack.cuts_cff") +process.load("Validation.RecoTrack.MultiTrackValidator_cff") +process.load("DQMServices.Components.EDMtoMEConverter_cff") +process.load("Validation.Configuration.postValidation_cff") + +process.quickTrackAssociatorByHits.SimToRecoDenominator = cms.string('reco') + +process.load("SimTracker.TrackAssociation.TrackAssociatorByChi2_cfi") +process.TrackAssociatorByChi2ESProducer.chi2cut = cms.double(500.0) +process.TrackAssociatorByPullESProducer = process.TrackAssociatorByChi2ESProducer.clone( + chi2cut = 50.0,onlyDiagonal = True, + ComponentName = 'TrackAssociatorByPull') + +########### configuration MultiTrackValidator ######## +process.multiTrackValidator.outputFile = 'multitrackvalidator_SingleMuPt10_100evts_AssociatorByPull.root' +#process.multiTrackValidator.associators = ['quickTrackAssociatorByHits'] +process.multiTrackValidator.associators = ['TrackAssociatorByPull'] +process.multiTrackValidator.skipHistoFit=cms.untracked.bool(False) +process.multiTrackValidator.label = ['cutsRecoTracks'] +process.multiTrackValidator.UseAssociators = cms.bool(True) +process.multiTrackValidator.runStandalone = cms.bool(True) + +process.quickTrackAssociatorByHits.useClusterTPAssociation = cms.bool(True) +process.load("SimTracker.TrackerHitAssociation.clusterTpAssociationProducer_cfi") + +process.validation = cms.Sequence( +# process.tpClusterProducer * #associate the hits trought an association map between cluster and tp + process.multiTrackValidator +) + +# paths +process.p = cms.Path( + process.cutsRecoTracks * + process.validation +) +process.schedule = cms.Schedule( + process.p +) + + diff --git a/DAFTest/DAFValidator/test/MultiTrackValidator_TTbar_cfg.py b/DAFTest/DAFValidator/test/MultiTrackValidator_TTbar_cfg.py new file mode 100644 index 0000000000000..8d62832e7a0b1 --- /dev/null +++ b/DAFTest/DAFValidator/test/MultiTrackValidator_TTbar_cfg.py @@ -0,0 +1,89 @@ +import FWCore.ParameterSet.Config as cms + +process = cms.Process("MULTITRACKVALIDATOR") + +# message logger +process.MessageLogger = cms.Service("MessageLogger", + default = cms.untracked.PSet( limit = cms.untracked.int32(10) ) +) + +# source +readFiles = cms.untracked.vstring() +secFiles = cms.untracked.vstring() +source = cms.Source ("PoolSource",fileNames = readFiles, secondaryFileNames = secFiles) +readFiles.extend( [ + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-RECO/POSTLS171_V1-v1/00000/3E806F9A-4BB6-E311-A4D2-002618943935.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-RECO/POSTLS171_V1-v1/00000/66797485-44B6-E311-9924-002618943939.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-RECO/POSTLS171_V1-v1/00000/B4F97AB1-25B6-E311-A16B-003048FFD760.root' ] ); + +secFiles.extend( [ + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/0466F34F-2FB6-E311-B125-0026189438EA.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/40408552-2FB6-E311-B773-0025905A60A0.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/48164C0F-00B6-E311-8EEB-0025905A60CE.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/680935B9-FFB5-E311-9750-003048FFD71A.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/80154D86-32B6-E311-A72A-002618943858.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/AAFCD423-01B6-E311-A08C-003048FFD75C.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/E03BC81A-01B6-E311-9608-00261894385A.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/F2FC75BE-04B6-E311-BBAC-0025905A48BA.root', + '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/F44896B7-06B6-E311-96AC-0026189438D7.root' ] ); + +process.source = source +process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(10) ) + +### conditions +process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") +#from Configuration.AlCa.GlobalTag import GlobalTag +#process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:startup', '') +process.GlobalTag.globaltag = 'POSTLS171_V1::All' + +### standard includes +process.load('Configuration/StandardSequences/Services_cff') +process.load('Configuration.StandardSequences.Geometry_cff') +process.load("Configuration.StandardSequences.RawToDigi_cff") +process.load("Configuration.EventContent.EventContent_cff") +process.load("Configuration.StandardSequences.Reconstruction_cff") +process.load("Configuration.StandardSequences.MagneticField_cff") + +### validation-specific includes +process.load("SimTracker.TrackAssociation.quickTrackAssociatorByHits_cfi") +process.load("SimTracker.TrackAssociation.trackingParticleRecoTrackAsssociation_cfi") +process.load("Validation.RecoTrack.cuts_cff") +process.load("Validation.RecoTrack.MultiTrackValidator_cff") +process.load("DQMServices.Components.EDMtoMEConverter_cff") +process.load("Validation.Configuration.postValidation_cff") + +process.quickTrackAssociatorByHits.SimToRecoDenominator = cms.string('reco') + +process.load("SimTracker.TrackAssociation.TrackAssociatorByChi2_cfi") +process.TrackAssociatorByChi2ESProducer.chi2cut = cms.double(500.0) +process.TrackAssociatorByPullESProducer = process.TrackAssociatorByChi2ESProducer.clone( chi2cut = 50.0, + onlyDiagonal = True, + ComponentName = 'TrackAssociatorByPull') + +########### configuration MultiTrackValidator ######## +process.multiTrackValidator.outputFile = 'multitrackvalidator_TTbar_10evts_AssociatorByPull.root' +process.multiTrackValidator.associators = ['quickTrackAssociatorByHits', 'TrackAssociatorByChi2','TrackAssociatorByPull'] +process.multiTrackValidator.skipHistoFit=cms.untracked.bool(False) +process.multiTrackValidator.label = ['cutsRecoTracks'] +process.multiTrackValidator.useLogPt=cms.untracked.bool(True) +process.multiTrackValidator.UseAssociators = cms.bool(True) +process.multiTrackValidator.runStandalone = cms.bool(True) + +process.quickTrackAssociatorByHits.useClusterTPAssociation = cms.bool(True) +process.load("SimTracker.TrackerHitAssociation.clusterTpAssociationProducer_cfi") + +process.validation = cms.Sequence( +# process.tpClusterProducer * #associate the hits trought an association map between cluster and tp + process.multiTrackValidator +) + +# paths +process.p = cms.Path( + process.cutsRecoTracks + * process.validation +) +process.schedule = cms.Schedule( + process.p +) + + diff --git a/RecoTracker/MeasurementDet/plugins/TkPixelMeasurementDet.cc b/RecoTracker/MeasurementDet/plugins/TkPixelMeasurementDet.cc index eb8cda6e659a4..ab84968ff4a14 100644 --- a/RecoTracker/MeasurementDet/plugins/TkPixelMeasurementDet.cc +++ b/RecoTracker/MeasurementDet/plugins/TkPixelMeasurementDet.cc @@ -27,7 +27,6 @@ TkPixelMeasurementDet::TkPixelMeasurementDet( const GeomDet* gdet, bool TkPixelMeasurementDet::measurements( const TrajectoryStateOnSurface& stateOnThisDet, const MeasurementEstimator& est, const MeasurementTrackerEvent & data, TempMeasurements & result) const { - if (!isActive(data)) { result.add(InvalidTransientRecHit::build(&geomDet(), TrackingRecHit::inactive), 0.F); return true; diff --git a/RecoTracker/SiTrackerMRHTools/.admin/CVS/Entries b/RecoTracker/SiTrackerMRHTools/.admin/CVS/Entries new file mode 100644 index 0000000000000..921311b5ab61c --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/.admin/CVS/Entries @@ -0,0 +1,2 @@ +/developers/1.3/Tue Jul 8 10:54:26 2008//TCMSSW_3_1_2 +D diff --git a/RecoTracker/SiTrackerMRHTools/.admin/CVS/Repository b/RecoTracker/SiTrackerMRHTools/.admin/CVS/Repository new file mode 100644 index 0000000000000..445157be358ec --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/.admin/CVS/Repository @@ -0,0 +1 @@ +CMSSW/RecoTracker/SiTrackerMRHTools/.admin diff --git a/RecoTracker/SiTrackerMRHTools/.admin/CVS/Root b/RecoTracker/SiTrackerMRHTools/.admin/CVS/Root new file mode 100644 index 0000000000000..18147e885e317 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/.admin/CVS/Root @@ -0,0 +1 @@ +:ext:ebrondol@lxplus5.cern.ch:/afs/cern.ch/user/c/cvscmssw/public/CMSSW diff --git a/RecoTracker/SiTrackerMRHTools/.admin/CVS/Tag b/RecoTracker/SiTrackerMRHTools/.admin/CVS/Tag new file mode 100644 index 0000000000000..27c493f6a303a --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/.admin/CVS/Tag @@ -0,0 +1 @@ +NCMSSW_3_1_2 diff --git a/RecoTracker/SiTrackerMRHTools/.admin/developers b/RecoTracker/SiTrackerMRHTools/.admin/developers new file mode 100644 index 0000000000000..58caa0b36fc16 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/.admin/developers @@ -0,0 +1,50 @@ +# Names of Developers with write access to this module +# +# There are two types of developers: +# 1) Administrators - entitled to edit all files in the module , +# in particular the .admin directory. (Including this file) +# 2) Regular Developers - entitled to edit all files in the module +# except those in the .admin directory. +# +# Entries must have the following format: +# +# [logname] : [Firstname Familyname] : [emailaddress] +# +# where [logname] is the login name of the user (in lower case) +# [Firstname Familyname] is the fullname of the user in free format +# [emailaddress] any email address of the user +# +# IMPORTANT: The only entry that uniqely identifies the user +# is the [loginname]. The rest of the entries are +# used for information and clarity purposes. +# +# You can find the information required to add a user, using the "phone" +# command from any CERN machine. "phone user -A" will give you a list of his +# accounts and lognames too. +# A safe assumption is to look for his ZH account on AFS/LXPLUS +# Please remember to use lower case for the logname. +# In case of doubts, please contact cvsadmin.cern.ch +# +# Important +# --------- +# --- Put names of regular developers after the >Developers Tag +# --- Put names of administrators after the >Administrators Tag +# +# NB: This file was automatically generated by CreateCVSPackage.pl. +# +>Developers +adamwo : Wolfgang Adam : Wolfgang.Adam@cern.ch +burkett : Kevin Burkett : burkett@fnal.gov +genta : Chiara Genta : Chiara.Genta@cern.ch +lenzip : Piergiulio Lenzi : Piergiulio.Lenzi@cern.ch +mangano : Boris Mangano : Boris.Mangano@cern.ch +tropiano : Antonio Tropiano : Antonio.Tropiano@cern.ch + +>Administrators +adamwo : Wolfgang Adam : Wolfgang.Adam@cern.ch +burkett : Kevin Burkett : burkett@fnal.gov +genta : Chiara Genta : Chiara.Genta@cern.ch +lenzip : Piergiulio Lenzi : Piergiulio.Lenzi@cern.ch +mangano : Boris Mangano : Boris.Mangano@cern.ch +tropiano : Antonio Tropiano : Antonio.Tropiano@cern.ch + diff --git a/RecoTracker/SiTrackerMRHTools/BuildFile.xml b/RecoTracker/SiTrackerMRHTools/BuildFile.xml new file mode 100644 index 0000000000000..82cec149978e0 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/BuildFile.xml @@ -0,0 +1,21 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/RecoTracker/SiTrackerMRHTools/interface/GenericProjectedRecHit2D.h b/RecoTracker/SiTrackerMRHTools/interface/GenericProjectedRecHit2D.h new file mode 100644 index 0000000000000..ee384f7fe1a19 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/interface/GenericProjectedRecHit2D.h @@ -0,0 +1,85 @@ +#ifndef RECOTRACKER_TRANSIENTRACKINGRECHIT_GenericProjectedRecHit2D_H +#define RECOTRACKER_TRANSIENTRACKINGRECHIT_GenericProjectedRecHit2D_H + +#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h" +#include "TrackingTools/TransientTrackingRecHit/interface/HelpertRecHit2DLocalPos.h" +#include "TrackingTools/KalmanUpdators/interface/TrackingRecHitPropagator.h" + +class GenericProjectedRecHit2D : public TransientTrackingRecHit { +public: + + GenericProjectedRecHit2D( const LocalPoint& pos, const LocalError& err, + const GeomDet* det, const GeomDet* originaldet, + const TransientTrackingRecHit::ConstRecHitPointer originalHit, + const TrackingRecHitPropagator* propagator); + + virtual AlgebraicSymMatrix parametersError() const { + return HelpertRecHit2DLocalPos().parError( localPositionError(), *det()); + } + + //virtual ~GenericProjectedRecHit2D(){delete theOriginalTransientHit;} + + virtual AlgebraicVector parameters() const ; + + virtual LocalPoint localPosition() const {return theLp;} + + virtual LocalError localPositionError() const {return theLe;} + + virtual AlgebraicMatrix projectionMatrix() const {return theProjectionMatrix;} + + virtual DetId geographicalId() const {return det() ? det()->geographicalId() : DetId();} + + virtual int dimension() const {return theDimension;} + + //this hit lays on the original surface, NOT on the projection surface + virtual const TrackingRecHit * hit() const { return theOriginalTransientHit->hit(); } + + virtual TrackingRecHit * cloneHit() const { return theOriginalTransientHit->cloneHit(); } + + virtual bool isValid() const{return true;} + + virtual std::vector recHits() const { + //return theOriginalTransientHit->hit()->recHits(); + return std::vector(); + } + + virtual std::vector recHits() { + //should it do something different? + return std::vector(); + } + + const TrackingRecHitPropagator* propagator() const {return thePropagator;} + + virtual bool canImproveWithTrack() const {return true;} + + const GeomDet* originalDet() const {return theOriginalDet;} + + static RecHitPointer build( const LocalPoint& pos, const LocalError& err, + const GeomDet* det, const GeomDet* originaldet, + const TransientTrackingRecHit::ConstRecHitPointer originalHit, + const TrackingRecHitPropagator* propagator) { + return RecHitPointer( new GenericProjectedRecHit2D( pos, err, det, originaldet, originalHit, propagator)); + } + + RecHitPointer clone( const TrajectoryStateOnSurface& ts) const; + +private: + + const GeomDet* theOriginalDet; + TransientTrackingRecHit::ConstRecHitPointer theOriginalTransientHit; + LocalPoint theLp; + LocalError theLe; + AlgebraicMatrix theProjectionMatrix; + const TrackingRecHitPropagator* thePropagator; + //const TrackingRecHit* theOriginalHit; + int theDimension; + + virtual GenericProjectedRecHit2D* clone() const { + return new GenericProjectedRecHit2D(*this); + } + +}; + + + +#endif diff --git a/RecoTracker/SiTrackerMRHTools/interface/GroupedDAFHitCollector.h b/RecoTracker/SiTrackerMRHTools/interface/GroupedDAFHitCollector.h new file mode 100644 index 0000000000000..f9efc1a0fb019 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/interface/GroupedDAFHitCollector.h @@ -0,0 +1,56 @@ +/** \class GroupedDAFHitCollector + * Returns a collection of TSiTrackerMultiRecHits and InvalidTransientRecHits given a Trajectory. + * Builds a TSiTrackerMultiRecHit for each detGroup + * (i.e. a group of detectors mutually exclusive for the track's crossing point) + * + * \author tropiano, genta + * \review in May 2014 by brondolin + */ + +#ifndef SiTrackerMRHTools_GroupedDAFHitCollector_h +#define SiTrackerMRHTools_GroupedDAFHitCollector_h + +#include "TrackingTools/MeasurementDet/interface/LayerMeasurements.h" +#include "RecoTracker/SiTrackerMRHTools/interface/MultiRecHitCollector.h" +#include + +class Propagator; +class MeasurementEstimator; +class MeasurementTracker; +class SiTrackerMultiRecHitUpdator; + +class GroupedDAFHitCollector :public MultiRecHitCollector { + +public: + explicit GroupedDAFHitCollector(const MeasurementTracker* measurementTracker, + const SiTrackerMultiRecHitUpdator* updator, + const MeasurementEstimator* est, + const Propagator* propagator, + const Propagator* reversePropagator): + MultiRecHitCollector(measurementTracker), theUpdator(updator), + theEstimator(est), thePropagator(propagator), theReversePropagator(reversePropagator){} + + + virtual ~GroupedDAFHitCollector(){} + + virtual std::vector recHits(const Trajectory&, + const MeasurementTrackerEvent *theMT) const; + + const SiTrackerMultiRecHitUpdator* getUpdator() const {return theUpdator;} + const MeasurementEstimator* getEstimator() const {return theEstimator;} + const Propagator* getPropagator() const {return thePropagator;} + const Propagator* getReversePropagator() const {return theReversePropagator;} + +private: + void buildMultiRecHits(const std::vector& measgroup, + std::vector& result) const; + + const SiTrackerMultiRecHitUpdator* theUpdator; + const MeasurementEstimator* theEstimator; + const Propagator* thePropagator; + const Propagator* theReversePropagator; + +}; + + +#endif diff --git a/RecoTracker/SiTrackerMRHTools/interface/MeasurementByLayerGrouper.h b/RecoTracker/SiTrackerMRHTools/interface/MeasurementByLayerGrouper.h new file mode 100644 index 0000000000000..50559453ada36 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/interface/MeasurementByLayerGrouper.h @@ -0,0 +1,39 @@ +#ifndef SiTrackerMRHTools_MeasurementByLayerGrouper_H +#define SiTrackerMRHTools_MeasurementByLayerGrouper_H + +class DetLayer; +class TrajectoryMeasurement; +class GeometricSearchTracker; + +#include +#include + +//groups the TrajectoryMeasurements on a layer by layer basis + +class MeasurementByLayerGrouper { + +private: + + typedef TrajectoryMeasurement TM; + const GeometricSearchTracker* theGeomSearch; + + const DetLayer* getDetLayer(const TM& tm) const; + +public: + + explicit MeasurementByLayerGrouper(const GeometricSearchTracker* search = 0):theGeomSearch(search){}; + + std::vector > > operator()(const std::vector&) const; + + +//to be ported later if needed +/* + vector + operator()(const vector > >&) const; + + vector > > > + operator()(const map >&) const; +*/ + +}; +#endif diff --git a/RecoTracker/SiTrackerMRHTools/interface/MultiRecHitCollector.h b/RecoTracker/SiTrackerMRHTools/interface/MultiRecHitCollector.h new file mode 100644 index 0000000000000..3f6072fe939b3 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/interface/MultiRecHitCollector.h @@ -0,0 +1,26 @@ +#ifndef SiTrackerMRHTools_MultiRecHitCollector_h +#define SiTrackerMRHTools_MultiRecHitCollector_h + +#include "RecoTracker/MeasurementDet/interface/MeasurementTracker.h" +#include + +class Trajectory; +class TrajectoryMeasurement; + +class MultiRecHitCollector { + + public: + MultiRecHitCollector(const MeasurementTracker* meas): theMeasurementTracker(meas){} + + virtual std::vector recHits(const Trajectory&, const MeasurementTrackerEvent *theMTE) const = 0; + + const MeasurementTracker* getMeasurementTracker() const {return theMeasurementTracker;} + + + private: + const MeasurementTracker* theMeasurementTracker; + +}; + +#endif + diff --git a/RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h b/RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h new file mode 100644 index 0000000000000..665db45e952b1 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h @@ -0,0 +1,83 @@ +/** \class SiTrackerMultiRecHitUpdator + * Builds a TSiTrackerMultiRecHit out of a vector of TrackingRecHit + * or updates an existing TSiTrackerMultiRecHit given a tsos. + * + * \author tropiano, genta + * \review in May 2014 by brondolin + */ + +#ifndef SiTrackerMultiRecHitUpdator_h +#define SiTrackerMultiRecHitUpdator_h + +#include "DataFormats/GeometryVector/interface/LocalPoint.h" +#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h" +#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h" + +#include + +class SiTrackerMultiRecHit; +class TrajectoryStateOnSurface; +class TrackingRecHit; +class TransientTrackingRecHitBuilder; +class LocalError; +class TrackingRecHitPropagator; + + +class SiTrackerMultiRecHitUpdator{ + +public: + + typedef std::pair LocalParameters; + SiTrackerMultiRecHitUpdator(const TransientTrackingRecHitBuilder* builder, + const TrackingRecHitPropagator* hitpropagator, + const float Chi2Cut, + const std::vector& anAnnealingProgram); + virtual ~SiTrackerMultiRecHitUpdator(){}; + + //calls the update method in order to build a TSiTrackerMultiRecHit + virtual TransientTrackingRecHit::RecHitPointer buildMultiRecHit(const std::vector& rhv, + TrajectoryStateOnSurface tsos, + float annealing=1.) const; + + //updates an existing TSiTrackerMultiRecHit + //in case a different kind of rechit is passed it returns clone(tsos) + virtual TransientTrackingRecHit::RecHitPointer update( TransientTrackingRecHit::ConstRecHitPointer original, + TrajectoryStateOnSurface tsos, + double annealing=1.) const; + + //returns a TSiTrackerMultiRecHit out of the transient components + TransientTrackingRecHit::RecHitPointer update( TransientTrackingRecHit::ConstRecHitContainer& tcomponents, + TrajectoryStateOnSurface tsos, + double annealing=1.) const; + + //computes weights or the cut-off value (depending on CutWeight variable) + double ComputeWeight(const TrajectoryStateOnSurface& tsos, const TransientTrackingRecHit& aRecHit, + bool CutWeight, double annealing=1.) const; + template double ComputeWeight(const TrajectoryStateOnSurface& tsos, + const TransientTrackingRecHit& aRecHit, + bool CutWeight, double annealing=1.) const; + + //computes parameters for 2 dim hits + std::pair ComputeParameters2dim(const TrajectoryStateOnSurface& tsos, + const TransientTrackingRecHit& aRecHit) const; + template std::pair ComputeParameters2dim (const TrajectoryStateOnSurface& tsos, + const TransientTrackingRecHit& aRecHit ) const; + + const std::vector& annealingProgram() const {return theAnnealingProgram;} + const std::vector& getAnnealingProgram() const {return theAnnealingProgram;} + +private: + //Obsolete methods + //LocalError calcParametersError(TransientTrackingRecHit::ConstRecHitContainer& map) const; + //LocalPoint calcParameters(TransientTrackingRecHit::ConstRecHitContainer& map, const LocalError& er) const; + + LocalParameters calcParameters(const TrajectoryStateOnSurface& tsos, + TransientTrackingRecHit::ConstRecHitContainer& map) const; + + const TransientTrackingRecHitBuilder* theBuilder; + const TrackingRecHitPropagator* theHitPropagator; + double theChi2Cut; + const std::vector theAnnealingProgram; + +}; +#endif diff --git a/RecoTracker/SiTrackerMRHTools/interface/SimpleDAFHitCollector.h b/RecoTracker/SiTrackerMRHTools/interface/SimpleDAFHitCollector.h new file mode 100644 index 0000000000000..291f613869a27 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/interface/SimpleDAFHitCollector.h @@ -0,0 +1,48 @@ +#ifndef SiTrackerMRHTools_SimpleDAFHitCollector_h +#define SiTrackerMRHTools_SimpleDAFHitCollector_h +#include "RecoTracker/SiTrackerMRHTools/interface/MultiRecHitCollector.h" +#include + +class Propagator; +class MeasurementEstimator; +class SiTrackerMultiRecHitUpdator; + +class SimpleDAFHitCollector :public MultiRecHitCollector { + public: + explicit SimpleDAFHitCollector(const MeasurementTracker* measurementTracker, + const SiTrackerMultiRecHitUpdator* updator, + const MeasurementEstimator* est, + const Propagator* propagator + ):MultiRecHitCollector(measurementTracker), theUpdator(updator), theEstimator(est), thePropagator(propagator){} + + + virtual ~SimpleDAFHitCollector(){} + + //given a trajectory it returns a collection + //of TSiTrackerMultiRecHits and InvalidTransientRecHits. + //For each measurement in the trajectory, measurements are looked for according to the + //MeasurementDet::fastMeasurements method only in the detector where the original measurement lays. + //If measurements are found a TSiTrackerMultiRecHit is built. + //All the components will lay on the same detector + + virtual std::vector recHits(const Trajectory&, const MeasurementTrackerEvent *theMTE) const; + + const SiTrackerMultiRecHitUpdator* getUpdator() const {return theUpdator;} + const MeasurementEstimator* getEstimator() const {return theEstimator;} + const Propagator* getPropagator() const {return thePropagator;} + + private: + //TransientTrackingRecHit::ConstRecHitContainer buildMultiRecHits(const std::vector& measgroup) const; + void buildMultiRecHits(const std::vector& measgroup, std::vector& result) const; + + private: + const SiTrackerMultiRecHitUpdator* theUpdator; + const MeasurementEstimator* theEstimator; + //this actually is not used in the fastMeasurement method + const Propagator* thePropagator; + + +}; + + +#endif diff --git a/RecoTracker/SiTrackerMRHTools/plugins/BuildFile.xml b/RecoTracker/SiTrackerMRHTools/plugins/BuildFile.xml new file mode 100644 index 0000000000000..b126ca46b6392 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/plugins/BuildFile.xml @@ -0,0 +1,6 @@ + + + + + + diff --git a/RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.cc b/RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.cc new file mode 100644 index 0000000000000..0dd443507bd63 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.cc @@ -0,0 +1,74 @@ +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" + + +#include "RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h" +#include "RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.h" +#include "TrackingTools/GeomPropagators/interface/Propagator.h" +#include "TrackingTools/KalmanUpdators/interface/Chi2MeasurementEstimatorBase.h" +#include "RecoTracker/MeasurementDet/interface/MeasurementTracker.h" +#include "RecoTracker/SiTrackerMRHTools/interface/GroupedDAFHitCollector.h" +#include "RecoTracker/SiTrackerMRHTools/interface/SimpleDAFHitCollector.h" + +#include "FWCore/Framework/interface/EventSetup.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/Framework/interface/ModuleFactory.h" +#include "FWCore/Framework/interface/ESProducer.h" + +#include +#include + +using namespace edm; + +MultiRecHitCollectorESProducer::MultiRecHitCollectorESProducer(const edm::ParameterSet& iConfig) +{ + std::string myname = iConfig.getParameter("ComponentName"); + setConf(iConfig); + setWhatProduced(this,myname); +} + +MultiRecHitCollectorESProducer::~MultiRecHitCollectorESProducer() {} + +boost::shared_ptr +MultiRecHitCollectorESProducer::produce(const MultiRecHitRecord& iRecord){ + std::string mode = "Grouped"; + if (conf_.getParameter("Mode")=="Simple") mode = "Simple"; + + std::string mrhupdator = conf_.getParameter("MultiRecHitUpdator"); + std::string propagatorAlongName = conf_.getParameter("propagatorAlong"); + std::string estimatorName = conf_.getParameter("estimator"); + std::string measurementTrackerName = conf_.getParameter("MeasurementTrackerName"); + + + ESHandle mrhuhandle; + iRecord.get(mrhupdator, mrhuhandle); + ESHandle propagatorhandle; + iRecord.getRecord().getRecord().get(propagatorAlongName, propagatorhandle); + ESHandle estimatorhandle; + iRecord.getRecord().getRecord().get(estimatorName, estimatorhandle); + ESHandle measurementhandle; + iRecord.getRecord().get(measurementTrackerName, measurementhandle); + + if (mode == "Grouped"){ + std::string propagatorOppositeName = conf_.getParameter("propagatorOpposite"); + ESHandle propagatorOppositehandle; + iRecord.getRecord().getRecord().get(propagatorOppositeName, propagatorOppositehandle); + _collector = boost::shared_ptr(new GroupedDAFHitCollector(measurementhandle.product(), + mrhuhandle.product(), + estimatorhandle.product(), + propagatorhandle.product(), + propagatorOppositehandle.product())); + } + else { + _collector = boost::shared_ptr(new SimpleDAFHitCollector(measurementhandle.product(), + mrhuhandle.product(), + estimatorhandle.product(), + propagatorhandle.product())); + } + + return _collector; + +} + + diff --git a/RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.h b/RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.h new file mode 100644 index 0000000000000..d520f19b10434 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.h @@ -0,0 +1,39 @@ +#ifndef RecoLocalTracker_ESProducers_MultiRecHitCollectorESProducer_h +#define RecoLocalTracker_ESProducers_ESProducers_MultiRecHitCollectorESProducer_h + +#include "FWCore/Framework/interface/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "FWCore/Framework/interface/ESHandle.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Utilities/interface/InputTag.h" + +#include "FWCore/Framework/interface/ESProducer.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "RecoTracker/Record/interface/MultiRecHitRecord.h" +#include "RecoTracker/SiTrackerMRHTools/interface/MultiRecHitCollector.h" + +#include + +class MultiRecHitCollectorESProducer: public edm::ESProducer{ + public: + MultiRecHitCollectorESProducer(const edm::ParameterSet& iConfig); + virtual ~MultiRecHitCollectorESProducer(); + boost::shared_ptr produce(const MultiRecHitRecord &); + + // Set parameter set + void setConf(const edm::ParameterSet& conf){ conf_ = conf; } + + private: + boost::shared_ptr _collector; + edm::ParameterSet conf_; + +}; + + +#endif + + + + diff --git a/RecoTracker/SiTrackerMRHTools/plugins/SiTrackerMultiRecHitUpdatorESProducer.cc b/RecoTracker/SiTrackerMRHTools/plugins/SiTrackerMultiRecHitUpdatorESProducer.cc new file mode 100644 index 0000000000000..8d16ced13b3a0 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/plugins/SiTrackerMultiRecHitUpdatorESProducer.cc @@ -0,0 +1,42 @@ +#include "RecoTracker/SiTrackerMRHTools/plugins/SiTrackerMultiRecHitUpdatorESProducer.h" +#include "TrackingTools/Records/interface/TransientRecHitRecord.h" +#include "RecoTracker/Record/interface/CkfComponentsRecord.h" + +#include "FWCore/Framework/interface/EventSetup.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/Framework/interface/ModuleFactory.h" +#include "FWCore/Framework/interface/ESProducer.h" + +#include +#include + +using namespace edm; + +SiTrackerMultiRecHitUpdatorESProducer::SiTrackerMultiRecHitUpdatorESProducer(const edm::ParameterSet & p) +{ + std::string myname = p.getParameter("ComponentName"); + pset_ = p; + setWhatProduced(this,myname); +} + +SiTrackerMultiRecHitUpdatorESProducer::~SiTrackerMultiRecHitUpdatorESProducer() {} + +boost::shared_ptr +SiTrackerMultiRecHitUpdatorESProducer::produce(const MultiRecHitRecord & iRecord){ + std::vector annealingProgram = pset_.getParameter >("AnnealingProgram"); + float Chi2Cut=pset_.getParameter("ChiSquareCut"); + + edm::ESHandle hbuilder; + std::string sname = pset_.getParameter("TTRHBuilder"); + iRecord.getRecord().get(sname, hbuilder); + std::string hitpropagator = pset_.getParameter("HitPropagator"); + edm::ESHandle hhitpropagator; + iRecord.getRecord().getRecord().get(hitpropagator, hhitpropagator); + + //_updator = boost::shared_ptr(new SiTrackerMultiRecHitUpdator(pDD.product(), pp, sp, mp, annealingProgram)); + _updator = boost::shared_ptr(new SiTrackerMultiRecHitUpdator(hbuilder.product(),hhitpropagator.product(), Chi2Cut, annealingProgram)); + // _updator = boost::shared_ptr(new SiTrackerMultiRecHitUpdator(hhitpropagator.product(),annealingProgram)); + return _updator; +} + + diff --git a/RecoTracker/SiTrackerMRHTools/plugins/SiTrackerMultiRecHitUpdatorESProducer.h b/RecoTracker/SiTrackerMRHTools/plugins/SiTrackerMultiRecHitUpdatorESProducer.h new file mode 100644 index 0000000000000..d534956b4ec37 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/plugins/SiTrackerMultiRecHitUpdatorESProducer.h @@ -0,0 +1,26 @@ +#ifndef RecoLocalTracker_ESProducers_SiTrackerMultiRecHitUpdatorESProducer_h +#define RecoLocalTracker_ESProducers_ESProducers_SiTrackerMultiRecHitUpdatorESProducer_h + +#include "FWCore/Framework/interface/ESProducer.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "RecoTracker/Record/interface/MultiRecHitRecord.h" +#include "RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h" + +#include + +class SiTrackerMultiRecHitUpdatorESProducer: public edm::ESProducer{ + public: + SiTrackerMultiRecHitUpdatorESProducer(const edm::ParameterSet & p); + virtual ~SiTrackerMultiRecHitUpdatorESProducer(); + boost::shared_ptr produce(const MultiRecHitRecord &); + private: + boost::shared_ptr _updator; + edm::ParameterSet pset_; +}; + + +#endif + + + + diff --git a/RecoTracker/SiTrackerMRHTools/plugins/module.cc b/RecoTracker/SiTrackerMRHTools/plugins/module.cc new file mode 100644 index 0000000000000..0aa90fb47201f --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/plugins/module.cc @@ -0,0 +1,17 @@ +#include "FWCore/PluginManager/interface/ModuleDef.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "RecoTracker/SiTrackerMRHTools/plugins/SiTrackerMultiRecHitUpdatorESProducer.h" +#include "RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.h" +//#include "RecoTracker/SiTrackerMRHTools/plugins/SiTrackerMultiRecHitUpdatorMTFESProducer.h" +//#include "RecoTracker/SiTrackerMRHTools/plugins/MultiTrackFilterCollectorESProducer.h" + +#include "FWCore/Framework/interface/ModuleFactory.h" +#include "FWCore/Framework/interface/ESProducer.h" +#include "FWCore/Utilities/interface/typelookup.h" + + +DEFINE_FWK_EVENTSETUP_MODULE(SiTrackerMultiRecHitUpdatorESProducer); +DEFINE_FWK_EVENTSETUP_MODULE(MultiRecHitCollectorESProducer); +//DEFINE_FWK_EVENTSETUP_MODULE(SiTrackerMultiRecHitUpdatorMTFESProducer); +//DEFINE_FWK_EVENTSETUP_MODULE(MultiTrackFilterCollectorESProducer); diff --git a/RecoTracker/SiTrackerMRHTools/python/GroupedMultiRecHitCollector_cff.py b/RecoTracker/SiTrackerMRHTools/python/GroupedMultiRecHitCollector_cff.py new file mode 100644 index 0000000000000..60ea5e474732b --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/python/GroupedMultiRecHitCollector_cff.py @@ -0,0 +1,16 @@ +import FWCore.ParameterSet.Config as cms + +import copy +from TrackingTools.KalmanUpdators.Chi2MeasurementEstimatorESProducer_cfi import * +# Chi2MeasurementEstimatorESProducer +RelaxedChi2 = copy.deepcopy(Chi2MeasurementEstimator) +RelaxedChi2.ComponentName = 'RelaxedChi2' +RelaxedChi2.MaxChi2 = 100. +#replace RelaxedChi2.nSigma = 3. +# MeasurementTracker +from RecoTracker.MeasurementDet.MeasurementTrackerESProducer_cfi import * +# MultiRecHitUpdator +from RecoTracker.SiTrackerMRHTools.SiTrackerMultiRecHitUpdator_cff import * +#MultiRecHitCollector +from RecoTracker.SiTrackerMRHTools.GroupedMultiRecHitCollector_cfi import * + diff --git a/RecoTracker/SiTrackerMRHTools/python/GroupedMultiRecHitCollector_cfi.py b/RecoTracker/SiTrackerMRHTools/python/GroupedMultiRecHitCollector_cfi.py new file mode 100644 index 0000000000000..4de0a0aa9465e --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/python/GroupedMultiRecHitCollector_cfi.py @@ -0,0 +1,13 @@ +import FWCore.ParameterSet.Config as cms + +groupedMultiRecHitCollector = cms.ESProducer("MultiRecHitCollectorESProducer", + propagatorAlong = cms.string('RungeKuttaTrackerPropagator'), + MultiRecHitUpdator = cms.string('SiTrackerMultiRecHitUpdator'), + ComponentName = cms.string('groupedMultiRecHitCollector'), + propagatorOpposite = cms.string('OppositeRungeKuttaTrackerPropagator'), + MeasurementTrackerName = cms.string(''), + estimator = cms.string('RelaxedChi2'), + Mode = cms.string('Grouped') +) + + diff --git a/RecoTracker/SiTrackerMRHTools/python/SiTrackerMultiRecHitUpdator_cff.py b/RecoTracker/SiTrackerMRHTools/python/SiTrackerMultiRecHitUpdator_cff.py new file mode 100644 index 0000000000000..a11b565952167 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/python/SiTrackerMultiRecHitUpdator_cff.py @@ -0,0 +1,6 @@ +import FWCore.ParameterSet.Config as cms + +from RecoTracker.TransientTrackingRecHit.TransientTrackingRecHitBuilder_cfi import * +from TrackingTools.KalmanUpdators.TrackingRecHitPropagatorESProducer_cff import * +from RecoTracker.SiTrackerMRHTools.SiTrackerMultiRecHitUpdator_cfi import * + diff --git a/RecoTracker/SiTrackerMRHTools/python/SiTrackerMultiRecHitUpdator_cfi.py b/RecoTracker/SiTrackerMRHTools/python/SiTrackerMultiRecHitUpdator_cfi.py new file mode 100644 index 0000000000000..412cf57fab0d9 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/python/SiTrackerMultiRecHitUpdator_cfi.py @@ -0,0 +1,11 @@ +import FWCore.ParameterSet.Config as cms + +siTrackerMultiRecHitUpdator = cms.ESProducer("SiTrackerMultiRecHitUpdatorESProducer", + ComponentName = cms.string('SiTrackerMultiRecHitUpdator'), + TTRHBuilder = cms.string('WithAngleAndTemplate'), + HitPropagator = cms.string('trackingRecHitPropagator'), + AnnealingProgram = cms.vdouble(80.0, 9.0, 4.0, 1.0, 1.0, 1.0), + ChiSquareCut =cms.double(15.0) +) + + diff --git a/RecoTracker/SiTrackerMRHTools/python/SimpleMultiRecHitCollector_cff.py b/RecoTracker/SiTrackerMRHTools/python/SimpleMultiRecHitCollector_cff.py new file mode 100644 index 0000000000000..eabd564f13a09 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/python/SimpleMultiRecHitCollector_cff.py @@ -0,0 +1,20 @@ +import FWCore.ParameterSet.Config as cms + +import copy +from TrackingTools.KalmanUpdators.Chi2MeasurementEstimatorESProducer_cfi import * +# Chi2MeasurementEstimatorESProducer +RelaxedChi2Simple = copy.deepcopy(Chi2MeasurementEstimator) +RelaxedChi2Simple.ComponentName = 'RelaxedChi2Simple' +RelaxedChi2Simple.MaxChi2 = 100. +#replace RelaxedChi2.nSigma = 3. +# PropagatorWithMaterialESProducer +from TrackingTools.MaterialEffects.MaterialPropagator_cfi import * +# PropagatorWithMaterialESProducer +from TrackingTools.MaterialEffects.OppositeMaterialPropagator_cfi import * +# MeasurementTracker +from RecoTracker.MeasurementDet.MeasurementTrackerESProducer_cfi import * +# MultiRecHitUpdator +from RecoTracker.SiTrackerMRHTools.SiTrackerMultiRecHitUpdator_cff import * +#MultiRecHitCollector +from RecoTracker.SiTrackerMRHTools.SimpleMultiRecHitCollector_cfi import * + diff --git a/RecoTracker/SiTrackerMRHTools/python/SimpleMultiRecHitCollector_cfi.py b/RecoTracker/SiTrackerMRHTools/python/SimpleMultiRecHitCollector_cfi.py new file mode 100644 index 0000000000000..0db85e8f0c873 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/python/SimpleMultiRecHitCollector_cfi.py @@ -0,0 +1,12 @@ +import FWCore.ParameterSet.Config as cms + +simpleMultiRecHitCollector = cms.ESProducer("MultiRecHitCollectorESProducer", + propagatorAlong = cms.string('RungeKuttaTrackerPropagator'), + MultiRecHitUpdator = cms.string('SiTrackerMultiRecHitUpdator'), + ComponentName = cms.string('simpleMultiRecHitCollector'), + MeasurementTrackerName = cms.string(''), + estimator = cms.string('RelaxedChi2Simple'), + Mode = cms.string('Simple') +) + + diff --git a/RecoTracker/SiTrackerMRHTools/src/.__afs4007 b/RecoTracker/SiTrackerMRHTools/src/.__afs4007 new file mode 100644 index 0000000000000000000000000000000000000000..9780c6011c053e7dc2dd5781ec4d1d2fa288e325 GIT binary patch literal 32768 zcmeI4dyr(+UB@rzf|C#pBo#y{a%O;`r>CcTX4n<%ogLiFJ_)nC>?|`0NXDM-J2TDp zYj1b&gWVF)bDkKg&7-}$}HT^gU?J*%!sjyoK0cbvti3UiU0#2Rtoj%#*O32tm~DM+0`~T-{BXSnwg!OTgZ5B#(Z16W^rP1e6ixW zn^ILTo7(SY%Llwn_Mq#f=JNL2?EYN`%H={;-w~dz7ixL#-<7Z3RLNy(WiOe{wyD2= zx=(>OEd}be<*{qu=3G5Fp{M%gLxbua7v1!xB}c#GeG2p`(5FD30(}bfDbS}tp8|af zycsD_tDNV2kdB{gJ3nJT&uRMne*61+`?;;@`Ud;kfBv4P>*v|uH`>oHHeEm8{+_p= zL$(2aJHF4JPuS0+P1o(|{zsnzeG2p`(5FD30(}bfDbS}tp8|af^eND%K%WAA3bdd= zCg(Vc^Si{JCjRf+@1Oc1$N2zwJ9zR39p`p%CHUgo9Oo`@BluD9!Uc}=JU9xrf-As_ zZ*`o%1`mV#z$&;A{5ZH4Tmv3`i{rcpTmn8m;5fH}mw&)x0`Y`I=jQ&Vb4 z&14FNd}&2>$YV&S>ypsmj*hA$`P!=5S}M62d1yx_OPWKPQlzYme_DR%THI2uuvsbS z;vb45SFSG=-0=1hl`WU5wd0OlJe^}e9wtZQHdmT;Y_3L|_m<}B-f|}Es#>*NO*mXG zRr8QV=W@^old+Lbo6mjae5vMo-B2SYRkbc_M*3q4K*{_G z$F{vG;9tMV;hot6EFP1Q9g#MsQrT5Edr*q2m6g7z@>Nw^brmgGt?`W!H&vdLsugFv z@)4CSR@3S2N3(9FmM@oLLmei=(1@NlgM))=c1^~QKT~4K9EP<7P}eb>UPg7dkhOzsh;ZDYe!fyuBuY5=7o;Pg@$?xqqby(hu?To_fBJbG@9B^u$7?#mzMld>X*zT%MI)!Io*}6M&{G>S_=xTE{w-Os4NjS3RxxwjuUU>!S zAIp@QPe~E_-kH_>2!yScA%)Il@e&X z9#^*S4AkZMQnpafxoT*~!c5t7Q?qWhnptsK(pE?>){3WSs*UH9t3#0|w`FRX9c8bW zsZ~?6nc8aPDY_`k%2_XewCktxrNgdQV^QAbE}!brMv_LVe(&;3U~TLwi==C;-+$0# zO}C*~q&%y&1UDMldU|F0ZLo6M5Q`k`2J-qh1r3c(|40M5FM1^~G8#*Z4wf$2^-S%P z+ahJPVzI_@c&I}XddN3BUF?i})-r;d^DAp#8m(%@yph%&ICITwRg#}6&nSrf|4-P` zk78Sk{V$?Tj(f2CkAVNh=6?=63vLA$gMY#9e-Vf;U=h3@8~~%>D)7%2IL=4GN5DN` z1Nc{L{^x-B0!G1$*!_=#-v_@2CP4yR1zy7!@CEQR_#}83+zXC_ESLlvz?W$A-vDX* zBhvo<(WgM40(}bfDbS}tp90^b6o}(ZZ+k?2tT!0P7n)iu^tFjGrXoKlMzlv@Yhi`W ziJ5$MUONOPBe!7i&o5T%#duNvi<2&u3T~e}Ry6v%xhGPQb?WKT_4Bcb#KZ`Np{5@r zE+7S&^W(w!qfO_>?fplO%KhRxU0d_h(uy zs8YFR{k20=Q(+WC*NbO1kDF5AWPu>!Rk00fNsNWqd=g6rx2mfj^E=w|=J{BrI%fuO zYH~UxRmdRzFzWG&(BJ11Z20P&`O&5X9Lf4&oK8IkFV^~>7$G>Qn5jhkPjU{@$VuP- zB&TpdX;w8P8? z8;YX2&Pic4>t+mZS~IQ26OGf@jFL>G=;StMW!mWh2znn(TINpENJHHPp-CePHO(!3 zN1M5|U>SvO`1A3MP8Qv#H_nU^rtgVOUO%3Xj=CN};tKJQ$9my>!&p7_Ygi^|$mprK z+PhRO7l{8Tft-gL^;{+kO~a2{wR-u;JeazJ~4oGvGM5 z9c%{YgJ*ZrK!N9o^*;#jUqga3V>$p% zFxW0csnlL^4J*-zBsyFsN>5}yTh6&@Qba`Q6ZOF)B;-P-iz*YoE+Nu98X{@S)z;lx z)?QNLXki3Rs%uqS5Km(=1?;R@c*{6igYfVcpV^~L=#nMXG%BW7gqRIEbCdtXy9!^_0`o&!$TF3b#a-ls$COVKUJ!XsXjLa!DQg*Ozq` z5X~@0F9CcRB2(Ou^uru$`6Cny=4Q)pCfI9EMI*h(ZBgCvjBNm{V#Bs$)4Iqo>jYV5 z5;OdQC4FISwJjLCMZ;~|dZm&d&~kGDrF!iibCKaAcwj?%W78BWQI4s0afN9^k%Wq` zxaA@u&SVZje%%Wp!?0K~66_wE=6Z~es!7Mf78%?!tcjQmPw7at2-kL1N;*%y%Hl(Q z4=?G_O?7o`sTB2zJn`JD@J+7lR<$v=x$v+oR~5)7)bjOO%I!^(Jl!6EHPw_zu|!Em_*(C@w7Ly{eF0 zb5JEywVWoGIz+EjA#+Tzpyl$*daP>xP*n%hwgT>`$}RpF>Vea|5-@*c(1hqi5~nr^ z6ZAcwGh^L6o1hfo`^st_gLpS7A4xBBL_SRkEo*HqqE!QYX}i8DthrqtHCZZTz(f{v zyS)1D6P>)!NcUo$F=(2#IVt}412i0l?68CN&i&16^A;Tl}1q!%XRV<$3nn_G*k zko&co5na8zlj+lIml_#R{)~{bUX9jK_HA-=#rRv_HLJ~ZFs{^<3?|mv}XK7zF6uY zl6-=9MO{ftZAIR*+X9LI??>mp{T%*9^8fz~`~PN;1Y_Vk*!}l|6!=f<{Q`I=cn5eK zTmJ!Y2vorJU^n=0Z2n&WG4OZT`_F=9a0Pe)yZ^J`5#Y!85AuB;yo&Ar3V0q=Kp9*B zK7{>$Cm04_#_qolTn~1Gm$CJ~3H}58J9r740GETOvGqR>ZUir2-~TB%1g->M#e<;USeiTX#O5CxED~gs`r1(J&a>f`^Bgqn?*sd=>SqhX* z9z>;JnIzq~?y4gh`?P&5nad;n#OgDTB8oU#FX2?Amp;UN-exZcPpg=?=O+@AiK`PE z6PreKGPWr!(uHh>Ea^?iW0T?DVB1e^n$}8Z!nQ0yW}7jY5~1<#FMqUAm$k7?SsT|; z*41swx_TXDO|~hE0D^X5^wP(PHf2q8UsjdfAuMb@uS5r3mV2u@>Y&hoF-k+rv8!C| zhLO}O=^V>O!MbglElyh>LOdAbkuy*&KAEzvJ1DieVn0pMtm|#oY%(0pluD>2UM8x7 z(h|N4E#ya|AslzC%c`T?Z=g|_qu4TCjXf!{DMm3gXWQE=ncPfVJ4IV&nfaQC)rS&l z*qZ)$_Zr=j4K6ZCh}HSKT8Xxg1iK43X-_2^tTf|D*LrirX(24ssB+w-cS7Y_>~m;Y zEaFbY(|{a$*Ts-u{W@FJ+YSh|j^^rl+KR>emYWz@Qrk*4$d#;;qFBn|39!DcCNETS znfLc%{+oxaFCgJN!kTW@is$JzpmUAJMUhIaw-(#W=1QiU&9R`1x=+3XRLcdguJ_K# zBxuzNJ#g%;BeIQY7lt}bm=MdDv(X5snaEA^!q%!ic{~#M9mT_9ZI<0g8|@~km+;ME z4Pyx(S;e(r_f6Gn`9dB&6!!@?*0_>{qiM8RZ>|4-bd;n3!{f&C)cXXFXm7evBk*=M z+~C^XKFmkmyjyHZxB4v7YIZgj;X64@1znV4Cu6sJh(vyfG}XH(wMwEDqo`ICZ&hoc zBk4Q|NR0sK>d*pfE#-uw5t$@|*Hv+HlP+?7wC<%EQ_ngE#4&wol(9;OW7bP{nNfHK z8dr!&=*T3YSXWZaPf4k|wZLa?wzaY)!ftcb(@2T`7nh8i;2*#rf!_kZ3NqlQz-8cD_yk@B ze*jK^64(!J1lIz|8IT+S@eh0!zrde>KL&?D1>6iafG6=0{3UnZ^7_$0Uv{2cy* zp9L#m7Tf^-9y&e(gr0|lrfUu}g@R-xKf2p}B3VR_VAoHpz^xq6yb%z14WZ#G+aB^s;I! z{DFbUd4?~@muR22AW|K3J+y_@h-y~~3#}A{+1y3eg%#kD2I+>{(^3u%RQvbtJ&;b5 zgt;mk|BCrS#zXauNmwUAHXZWK-YI922gqMth|5=5r;R$?rGJ++)Op^TF*P;Mw-&F{ zn3@W7k2N`{-B;0(J4F}=2``uY<9a?VTx4a*Gb#M~1nl>Ra){w796dsgI% zjPHDs@XDl4#SsUe9ejdo@+$=w<$QO9E|nL{W%`{X9_C6fWvWny7bXVDvtm<;PdOCW zG7a}G>CA&YWbBw_Nk7e`6*iKvOyDkCv+Mc%t35;#dK<7nI0@LCFQjag;=amf|8 z7TwSqTh%*SwJK=7CPj|G5Sse+%G93e*szCtY98zYm1X{Uvqb&mr1?CWP&2xSXwhb` ztTLqTW0VK^@;G!%P|9o~=sc7O8O)$93SwE( zEcC(#&{uzGSfe?iDoHPS(Y2%t(=RhDp3qCpW!7%^6nTo z+MjHG=1Dk4YezF&3{-Gnh5O7E44xrb*X}%uXwKP?P)N3{c_Jw+e#)qcLM$%v-X~ty z#G$8B&_uqpZe`OnF=D*)3~Wq`IgMsIB&?GGd7RH4*Vi?~GF}^bt4@PsDNK;*rAuuK zYa*6VSLO|lky|Ei-4dBX!Ao$GcB4&r<9M4J_0AhZ5Rrg;wrrUkVIT7M0BKIqV>+wo z?S!Jc(%;TvCR{Nr<;~2t6I;%O8CyA*wI^p&Hble*v(sOsu{>l#_jUxTJ`qnAe02KA z%UpVo`=H8LU8Q@4sk^|B6D(v?4O!iLrV$Qj(VUQ~wEcfEHtL7PR>l7J-@pGjcK?UK zo!~kk@&9jw&w+zr87zSeNP`Q(Ip9I-3mD|{GVl%T|4)G1Kpy-Amw z4UU2BU;}st+x~8F7uX5n;Op4*Pk=uMp87)- zCFuAi@EP!j;3ME3a2F67|2$}SL}PQ>rBlotbQi_Z7b{LONfHb4A7z2Lp}+cD3KxW< z^bei%=wH*@2mNbg7OCJl**}GLVXny!u5nS<64SdBJw9X(n^XF3PiH4_F3?m0y@CXH zU8y_~Tn#)M(rP0QRIz+m`)kW;PdM#a@5^d3@>|+smYyEB8Fn*O!>Eq5t4Aa3%vKOJ zqD*RDU^+26t!xq*Xgw}^=(q{n0Al%iPG5;`+{gR6E739@!rI-gj&BG>TJ>~vx9)~p z-@>>y-jj(HP%Y*t&nu?maux2T&cwM~%}%teweiX}n8z`+<&Y zBSE!|9`5ng@q6o4GO>_oj92nk8rl)F>ty4}3A1=MpVZ4Hp)Nx1l+%ip8w+o`&tENd zu|8Q;i~og5ca6AHiE)$(tn{M)2P(#IWpi}tJ?F6XtDEh;ty8k^jvG`(`T z*~EFpY2$z}VOv~mMI|bNJ#;nXx|yRftFLjo$;Nk4@%`*Rzp>qArZo<3cW*{+IqTab zg!%pH<+CT5cHH^y5ou@DfRK1ZyV>n$B_wnj1RTMgHv})_2#vulk+YF){%u~d|A2$v)|8*MjZUFzgyb&OL{f6euU~2kPE+QY+yz7HzpLtERF-Vm*4b(zRzc+ZW z@f{dO6h@~>=M?lvW5BcPz z&2WpixS|u`{N25s-pJ76S(~JwnGz4Bbqj^nqF1++FhMw>v{ICtweight(), originalHit->getAnnealingFactor()) +{ + theOriginalDet = originalDet; + thePropagator = propagator; + theOriginalTransientHit = originalHit; + theLp = pos; + theLe = err; + theProjectionMatrix = originalHit->projectionMatrix(); + theDimension = originalHit->dimension(); + //theOriginalHit = originalTransientHit.hit()->clone(); +} + +AlgebraicVector GenericProjectedRecHit2D::parameters() const{ + AlgebraicVector result(2); + result[0] = theLp.x(); + result[1] = theLp.y(); + return result; +} + +TransientTrackingRecHit::RecHitPointer +GenericProjectedRecHit2D::clone( const TrajectoryStateOnSurface& ts) const +{ + return thePropagator->project(theOriginalTransientHit, *det(), ts); +} + diff --git a/RecoTracker/SiTrackerMRHTools/src/GroupedDAFHitCollector.cc b/RecoTracker/SiTrackerMRHTools/src/GroupedDAFHitCollector.cc new file mode 100644 index 0000000000000..e51ceaaa4df10 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/src/GroupedDAFHitCollector.cc @@ -0,0 +1,235 @@ +#include "RecoTracker/SiTrackerMRHTools/interface/GroupedDAFHitCollector.h" +#include "RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h" +#include "RecoTracker/SiTrackerMRHTools/interface/MeasurementByLayerGrouper.h" +#include "RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h" +#include "TrackingTools/GeomPropagators/interface/Propagator.h" +#include "TrackingTools/DetLayers/interface/MeasurementEstimator.h" +#include "TrackingTools/DetLayers/interface/DetLayer.h" +#include "TrackingTools/PatternTools/interface/Trajectory.h" +#include "TrackingTools/MeasurementDet/interface/TrajectoryMeasurementGroup.h" +#include "TrackingTools/TransientTrackingRecHit/interface/InvalidTransientRecHit.h" +#include "RecoTracker/MeasurementDet/interface/MeasurementTrackerEvent.h" +#include "TrackingTools/PatternTools/interface/TrajMeasLessEstim.h" + +#include +#include + +#define _debug_GroupedDAFHitCollector_ + +using namespace std; + +vector GroupedDAFHitCollector::recHits(const Trajectory& traj, + const MeasurementTrackerEvent *theMTE) const +{ + + std::cout << " Calling GroupedDAFHitCollector::recHits" << std::endl; + LayerMeasurements theLM (theMTE->measurementTracker(), *theMTE); + + //WARNING: At the moment the trajectories has the measurements with reversed sorting after the track smoothing + const vector& meas = traj.measurements(); + const Propagator* forwardPropagator = getPropagator(); + const Propagator* backwardPropagator = getReversePropagator(); + if (traj.direction() == alongMomentum){ + forwardPropagator = getReversePropagator(); + backwardPropagator = getPropagator(); + } + if (meas.empty()) //return TransientTrackingRecHit::ConstRecHitContainer(); + return vector(); + + //groups the TrajectoryMeasurements on a layer by layer + vector > > mol; + mol = MeasurementByLayerGrouper(getMeasurementTracker()->geometricSearchTracker())(meas); + + vector result; + + //add a protection if all the measurement are on the same layer + if(mol.size()<2)return vector(); + + //first layer + // cout<<"DAFHitCollectionFromRecTrack: first layer"<::const_iterator ibeg = (mol.at(iLay)).second.begin(); + vector::const_iterator iend = (mol.at(iLay)).second.end(); + for (vector::const_iterator imeas = ibeg; imeas != iend; ++imeas){ + if (imeas->recHit()->isValid()){ + std::cout << " Valid Hit with DetId " << imeas->recHit()->geographicalId().rawId() + << " local position " << imeas->recHit()->hit()->localPosition() + << " global position " << imeas->recHit()->hit()->globalPosition() << "\n"; + LogTrace("MultiRecHitCollector") << "Valid Hit with DetId " << imeas->recHit()->geographicalId().rawId() + << " local position " << imeas->recHit()->hit()->localPosition(); + } else { + std::cout << " Invalid Hit with DetId " << imeas->recHit()->geographicalId().rawId() << std::endl; + LogTrace("MultiRecHitCollector") << "Invalid Hit with DetId " << imeas->recHit()->geographicalId().rawId(); + } + } + } + + //ERICA: I have to understand how are set the TM now. REPLACE THIS PART!! + std::cout << " Grouped measurements are:\n"; + vector groupedMeas; + if (mol.back().first) + groupedMeas = theLM.groupedMeasurements(*(mol.back().first), current, + *backwardPropagator, *(getEstimator())); + + //Since we have passed the backwardPropagator, we have to sort the detGroups in the opposite way + //(according the forward propagator, not the backward one) + vector sortedgroupedMeas; + for (vector::reverse_iterator iter = groupedMeas.rbegin(); + iter != groupedMeas.rend(); iter++){ + + sortedgroupedMeas.push_back(*iter); + + } + + //for the first layer + buildMultiRecHits(sortedgroupedMeas, result); + + + //for other layers + current = mol.back().second.front().updatedState(); + //if (current.isValid()) current.rescaleError(10); + + for( vector > >::reverse_iterator imol = + mol.rbegin() + 1; imol != mol.rend(); imol++) { + + const DetLayer* lay = (*imol).first; + LogDebug("MultiRecHitCollector") << "Layer " << lay << " has " << (*imol).second.size() << " measurements"; + //debug + vector currentLayerMeas; + if (lay) { + currentLayerMeas = theLM.groupedMeasurements(*lay, current, *forwardPropagator, *(getEstimator())); + } + + buildMultiRecHits(currentLayerMeas, result); + current = (*imol).second.front().updatedState(); + //if (current.isValid()) current.rescaleError(10); + } + + std::cout << " Ending GroupedDAFHitCollector::recHits >> Original Measurement size " << meas.size() + << "\n >> GroupedDAFHitCollector returned " << result.size() << " measurements" << std::endl; + LogTrace("MultiRecHitCollector") << "Original Measurement size " << meas.size() << " GroupedDAFHitCollector returned " << result.size() << " measurements"; + //results are sorted in the fitting direction + + // adding a protection against too few hits and invalid hits (due to failed propagation on the same surface of the original hits) + if (result.size()>2) + { + int hitcounter=0; + //check if the vector result has more than 3 valid hits + for (vector::const_iterator iimeas = result.begin(); iimeas != result.end(); ++iimeas) + { + if(iimeas->recHit()->isValid()) hitcounter++; + } + + if(hitcounter>2) + { + return result; + } + + else return vector(); + } + + else{return vector();} + +} + +void GroupedDAFHitCollector::buildMultiRecHits(const vector& measgroup, vector& result) const { + + unsigned int initial_size = result.size(); + + //TransientTrackingRecHit::ConstRecHitContainer rhits; + if (measgroup.empty()) { + LogTrace("MultiRecHitCollector") << "No TrajectoryMeasurementGroups found for this layer\n" ; + //should we do something? + //result.push_back(InvalidTransientRecHit::build(0,TrackingRecHit::missing)); + return; + } + + //we build a MultiRecHit out of each group + //groups are sorted along momentum or opposite to momentum, + //measurements in groups are sorted with increating chi2 + LogTrace("MultiRecHitCollector") << "Found " << measgroup.size() << " groups for this layer"; + + //trajectory state to store the last valid TrajectoryState (if present) to be used + //to add an invalid Measurement in case no valid state or no valid hits are found in any group + for ( vector::const_iterator igroup = measgroup.begin(); + igroup != measgroup.end(); igroup++ ){ + + //the TrajectoryState is the first one + TrajectoryStateOnSurface state = igroup->measurements().front().predictedState(); + if (!state.isValid()){ + LogTrace("MultiRecHitCollector") << "Something wrong! no valid TSOS found in current group "; + continue; + } + + LogTrace("MultiRecHitCollector") << "This group has " << igroup->measurements().size() << " measurements"; + LogTrace("MultiRecHitCollector") << "This group has the following " << igroup->detGroup().size() + << " detector ids: " << endl; + for (DetGroup::const_iterator idet = igroup->detGroup().begin(); idet != igroup->detGroup().end(); ++idet){ + LogTrace("MultiRecHitCollector") << idet->det()->geographicalId().rawId(); + } + + vector hits; + for (vector::const_iterator imeas = igroup->measurements().begin(); + imeas != igroup->measurements().end(); imeas++){ + + //collect the non missing hits to build the MultiRecHits + //we use the recHits method; anyway only simple hits, not MultiHits should be present + if (imeas->recHit()->getType() != TrackingRecHit::missing) { + LogTrace("MultiRecHitCollector") << "This hit is valid "; + hits.push_back(imeas->recHit()->hit()); + } + else{ + std::cout << " This hit is not valid and will not enter in the MRH. " << std::endl; + } + } + + if (hits.empty()){ + LogTrace("MultiRecHitCollector") << "No valid hits found in current group "; + continue; + } + + LogTrace("MultiRecHitCollector") << "The best TSOS in this group is " << state << " it lays on surface located at " << state.surface().position(); +#ifdef _debug_GroupedDAFHitCollector_ + LogTrace("MultiRecHitCollector") << "For the MRH on this group the following hits will be used"; + for (vector::iterator iter = hits.begin(); iter != hits.end(); iter++){ + string validity = "valid"; + if ((*iter)->getType() == TrackingRecHit::missing ) validity = "missing !should not happen!"; + else if ((*iter)->getType() == TrackingRecHit::inactive) validity = "inactive"; + else if ((*iter)->getType() == TrackingRecHit::bad) validity = "bad"; + LogTrace("MultiRecHitCollector") << "DetId " << (*iter)->geographicalId().rawId() + << " validity: " << validity + << " surface position " << getMeasurementTracker()->geomTracker()->idToDet((*iter)->geographicalId())->position() + << " hit local position " << (*iter)->localPosition(); + } +#endif + //ERICA: Why I pass all the hits and only the TSOS of igroup->measurements().front().predictedState() + result.push_back(TrajectoryMeasurement(state,theUpdator->buildMultiRecHit(hits, state))); + } + //can this happen? it means that the measgroup was not empty but no valid measurement was found inside + //in this case we add an invalid measuremnt for this layer + if (result.size() == initial_size){ + LogTrace("MultiRecHitCollector") << "no valid measuremnt or no valid TSOS in none of the groups"; + //measgroup has been already checked for size != 0 + if (measgroup.back().measurements().size() != 0){ + result.push_back(measgroup.back().measurements().back()); + } + } +} + diff --git a/RecoTracker/SiTrackerMRHTools/src/MeasurementByLayerGrouper.cc b/RecoTracker/SiTrackerMRHTools/src/MeasurementByLayerGrouper.cc new file mode 100644 index 0000000000000..7e7d2a3f14884 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/src/MeasurementByLayerGrouper.cc @@ -0,0 +1,72 @@ +#include "RecoTracker/SiTrackerMRHTools/interface/MeasurementByLayerGrouper.h" +#include "TrackingTools/DetLayers/interface/DetLayer.h" +#include "TrackingTools/PatternTools/interface/TrajectoryMeasurement.h" +#include "RecoTracker/TkDetLayers/interface/GeometricSearchTracker.h" +#include "FWCore/Utilities/interface/Exception.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" + +using namespace std; + +vector > > MeasurementByLayerGrouper::operator()(const vector& vtm) const{ + + if(vtm.empty()) + return vector > >(); + + vector > > result; + result.reserve(vtm.size()); + + vector::const_iterator start = vtm.begin(); + //here we assume that the TM on the same detLayer are consecutive (as it should) + while(start != vtm.end()) { + vector::const_iterator ipart = start; + do {ipart++;} + while(ipart != vtm.end() && + getDetLayer(*start)==getDetLayer(*ipart) && + getDetLayer(*start) != 0 //the returned pointer will be 0 in case + //the measurement contains an invalid hit with no associated detid. + //This kind of hits are at most one per layer. + //this last condition avoids that 2 consecutive measurements of this kind + //are grouped in the same layer. + //it would be useful if invalid hit out of the active area were + //given the detid reserved for the whole layer instead of 0 + ) ; + + vector group(start, ipart); + result.push_back(pair >(getDetLayer(*start), + group)); + start = ipart; + } +#ifdef debug_MeasurementByLayerGrouper_ + for (vector > >::const_iterator iter = result.begin(); iter != result.end(); iter++){ + LogTrace("MeasurementByLayerGrouper|SiTrackerMultiRecHitUpdator") << "DetLayer " << iter->first << " has " << iter->second.size() << " measurements"; + } +#endif + + + return result; +} + +const DetLayer* MeasurementByLayerGrouper::getDetLayer(const TM& tm) const { + // if the DetLayer is set in the TM... + if (tm.layer()) return tm.layer(); + + //if it corresponds to an invalid hit with no geomdet associated + //we can't retrieve the DetLayer + //because unfortunately the detlayer is not set in these cases + //returns 0 for the moment + //to be revisited + + if (tm.recHit()->det()==0){ + LogDebug("MeasurementByLayerGrouper") <<"This hit has no geomdet associated skipping... "; + return 0; + } + + //now the cases in which the detid is set + + if (!theGeomSearch) { + throw cms::Exception("MeasurementByLayerGrouper") << "Impossible to retrieve the det layer because it's not set in the TM and the pointer to the GeometricSearchTracker is 0 "; + return 0; + } + + return theGeomSearch->detLayer(tm.recHit()->det()->geographicalId()); +} diff --git a/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc b/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc new file mode 100644 index 0000000000000..147059db10779 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc @@ -0,0 +1,379 @@ +#include "RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h" +#include "RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h" +#include "RecoTracker/SiTrackerMRHTools/interface/GenericProjectedRecHit2D.h" +#include "DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h" +#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h" +#include "TrackingTools/TransientTrackingRecHit/interface/TrackingRecHitProjector.h" +#include "TrackingTools/TransientTrackingRecHit/interface/InvalidTransientRecHit.h" +#include "DataFormats/TrackingRecHit/interface/KfComponentsHolder.h" +#include "DataFormats/Math/interface/invertPosDefMatrix.h" +#include "DataFormats/Math/interface/ProjectMatrix.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" + +SiTrackerMultiRecHitUpdator::SiTrackerMultiRecHitUpdator(const TransientTrackingRecHitBuilder* builder, + const TrackingRecHitPropagator* hitpropagator, + const float Chi2Cut, + const std::vector& anAnnealingProgram): + theBuilder(builder), + theHitPropagator(hitpropagator), + theChi2Cut(Chi2Cut), + theAnnealingProgram(anAnnealingProgram){} + + +TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::buildMultiRecHit(const std::vector& rhv, + TrajectoryStateOnSurface tsos, + float annealing) const{ + TransientTrackingRecHit::ConstRecHitContainer tcomponents; + for (std::vector::const_iterator iter = rhv.begin(); iter != rhv.end(); iter++){ + TransientTrackingRecHit::RecHitPointer transient = theBuilder->build(*iter); + if (transient->isValid()) tcomponents.push_back(transient); + } + return update(tcomponents, tsos, annealing); + +} + +TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( TransientTrackingRecHit::ConstRecHitPointer original, + TrajectoryStateOnSurface tsos, + double annealing) const{ + LogTrace("SiTrackerMultiRecHitUpdator") << "Calling SiTrackerMultiRecHitUpdator::update with AnnealingFactor: " << annealing; + if (original->isValid()) + LogTrace("SiTrackerMultiRecHitUpdator") << "Original Hit position " << original->localPosition() << " original error " + << original->parametersError(); + else LogTrace("SiTrackerMultiRecHitUpdator") << "Invalid hit"; + + if(!tsos.isValid()) { + //return original->clone(); + throw cms::Exception("SiTrackerMultiRecHitUpdator") << "!!! MultiRecHitUpdator::update(..): tsos NOT valid!!! "; + } + + //check if to clone is the right thing + if (original->transientHits().empty()) return original->clone(tsos); + + TransientTrackingRecHit::ConstRecHitContainer tcomponents = original->transientHits(); + return update(tcomponents, tsos, annealing); +} + +/*------------------------------------------------------------------------------------------------------------------------*/ +TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( TransientTrackingRecHit::ConstRecHitContainer& tcomponents, + TrajectoryStateOnSurface tsos, + double annealing) const{ + + + if (tcomponents.empty()){ + LogTrace("SiTrackerMultiRecHitUpdator") << "Empty components vector passed to SiTrackerMultiRecHitUpdator::update, returning an InvalidTransientRecHit "; + return InvalidTransientRecHit::build(0); + } + + if(!tsos.isValid()) { + LogTrace("SiTrackerMultiRecHitUpdator")<<"SiTrackerMultiRecHitUpdator::update: tsos NOT valid!!!, returning an InvalidTransientRecHit"; + return InvalidTransientRecHit::build(0); + } + + std::vector updatedcomponents; + const GeomDet* geomdet = 0; + + //running on all over the MRH components + for (TransientTrackingRecHit::ConstRecHitContainer::const_iterator iter = tcomponents.begin(); iter != tcomponents.end(); iter++){ + + //the first rechit must belong to the same surface of TSOS + if (iter == tcomponents.begin()) { + + if (&((*iter)->det()->surface())!=&(tsos.surface())){ + throw cms::Exception("SiTrackerMultiRecHitUpdator") << "the Trajectory state and the first rechit passed to the SiTrackerMultiRecHitUpdator lay on different surfaces!: state lays on surface " << tsos.surface().position() << " hit with detid " << (*iter)->det()->geographicalId().rawId() << " lays on surface " << (*iter)->det()->surface().position(); + } + + geomdet = (*iter)->det(); + + LogTrace("SiTrackerMultiRecHitUpdator") << "Current reference surface located at " << geomdet->surface().position(); + LogTrace("SiTrackerMultiRecHitUpdator")<< "TSOS position " << tsos.localPosition(); + } + + //if the rechit does not belong to the surface of the tsos + //GenericProjectedRecHit2D is used to prepagate + if (&((*iter)->det()->surface())!=&(tsos.surface())){ + + TransientTrackingRecHit::RecHitPointer cloned = theHitPropagator->project(*iter, *geomdet, tsos); + //if it is used a sensor by sensor grouping this should not appear + LogTrace("SiTrackerMultiRecHitUpdator") << "hit propagated"; + if (cloned->isValid()) updatedcomponents.push_back(cloned); + + } else { + + TransientTrackingRecHit::RecHitPointer cloned = (*iter)->clone(tsos); + if (cloned->isValid()){ + updatedcomponents.push_back(cloned); + LogTrace("SiTrackerMultiRecHitUpdator") << "hit cloned"; + } + } + } + + std::vector > mymap; + std::vector > normmap; + + double a_sum=0, c_sum=0; + + + for(std::vector::iterator ihit = updatedcomponents.begin(); + ihit != updatedcomponents.end(); ihit++) { + + double a_i = ComputeWeight(tsos, *(*ihit), false, annealing); //exp(-0.5*Chi2)/(2.*M_PI*sqrt(det)); + double c_i = ComputeWeight(tsos, *(*ihit), true, annealing); //exp(-0.5*theChi2Cut/annealing)/(2.*M_PI*sqrt(det)); + mymap.push_back(std::pair((*ihit)->hit(), a_i)); + + a_sum += a_i; + c_sum += c_i; + } + double total_sum = a_sum + c_sum; + + unsigned int counter = 0; + TransientTrackingRecHit::ConstRecHitContainer finalcomponents; + for(std::vector::iterator ihit = updatedcomponents.begin(); + ihit != updatedcomponents.end(); ihit++) { + + double p = ((mymap[counter].second)/total_sum > 1.e-6 ? (mymap[counter].second)/total_sum : 1.e-6); + //ORCA: float p = ((mymap[counter].second)/total_sum > 0.01 ? (mymap[counter].second)/total_sum : 1.e-6); + normmap.push_back(std::pair(mymap[counter].first, p)); + + //storing the weight in the component TransientTrackingRecHit + (*ihit)->setWeight(p); + (*ihit)->setAnnealingFactor(annealing); + + finalcomponents.push_back(*ihit); + + LogTrace("SiTrackerMultiRecHitUpdator")<< "Component hit type " << typeid(*mymap[counter].first).name() + << " position " << mymap[counter].first->localPosition() + << " error " << mymap[counter].first->localPositionError() + << " with weight " << p; + counter++; + } + + //mymap = normmap; + SiTrackerMultiRecHitUpdator::LocalParameters param = calcParameters(tsos, finalcomponents); + + //CMSSW531 constructor: + //SiTrackerMultiRecHit updated(param.first, param.second, normmap.front().first->>geographicalId(), normmap); + + SiTrackerMultiRecHit updated(param.first, param.second, *normmap.front().first->det(), normmap); + LogTrace("SiTrackerMultiRecHitUpdator") << " Updated Hit position " << updated.localPosition() + << " updated error " << updated.localPositionError() << std::endl; + + return TSiTrackerMultiRecHit::build(geomdet, &updated, finalcomponents, annealing); + +} + + +//--------------------------------------------------------------------------------------------------------------- +double SiTrackerMultiRecHitUpdator::ComputeWeight(const TrajectoryStateOnSurface& tsos, + const TransientTrackingRecHit& aRecHit, bool CutWeight, double annealing) const{ + + switch (aRecHit.dimension()) { + case 1: return ComputeWeight<1>(tsos,aRecHit,CutWeight,annealing); + case 2: return ComputeWeight<2>(tsos,aRecHit,CutWeight,annealing); + case 3: return ComputeWeight<3>(tsos,aRecHit,CutWeight,annealing); + case 4: return ComputeWeight<4>(tsos,aRecHit,CutWeight,annealing); + case 5: return ComputeWeight<5>(tsos,aRecHit,CutWeight,annealing); + } + throw cms::Exception("Rec hit of invalid dimension (not 1,2,3,4,5)") << + "The value was " << aRecHit.dimension() << + ", type is " << typeid(aRecHit).name() << "\n"; +} + +//--------------------------------------------------------------------------------------------------------------- +template +double SiTrackerMultiRecHitUpdator::ComputeWeight(const TrajectoryStateOnSurface& tsos, + const TransientTrackingRecHit& aRecHit, bool CutWeight, double annealing) const { + + //define tsos position depending on the dimension of the hit + typename AlgebraicROOTObject::Vector tsospos; + if( N==1 ){ + tsospos[0]=tsos.localPosition().x(); + if(!CutWeight) + LogTrace("SiTrackerMultiRecHitUpdator")<< "TSOS position " << tsos.localPosition(); + } + else if(N==2){ + tsospos[0]=tsos.localPosition().x(); + tsospos[1]=tsos.localPosition().y(); + if(!CutWeight) + LogTrace("SiTrackerMultiRecHitUpdator")<< "TSOS position " << tsos.localPosition(); + } + else{ + if(!CutWeight) + LogTrace("SiTrackerMultiRecHitUpdator")<< "TSOS position not correct. Rec hit of invalid dimension (not 1, 2) but " + << aRecHit.dimension(); + } + + // define variables that will be used to setup the KfComponentsHolder + ProjectMatrix pf; + typename AlgebraicROOTObject::Matrix H; + typename AlgebraicROOTObject::Vector r, rMeas; + typename AlgebraicROOTObject::SymMatrix V, VMeas, W; + AlgebraicVector5 x = tsos.localParameters().vector(); + const AlgebraicSymMatrix55 &C = (tsos.localError().matrix()); + + // setup the holder with the correct dimensions and get the values + KfComponentsHolder holder; + holder.template setup(&r, &V, &H, &pf, &rMeas, &VMeas, x, C); + aRecHit.getKfComponents(holder); + + typename AlgebraicROOTObject::Vector diff; + diff = r - tsospos; + + //assume that TSOS is smoothed one + V *= annealing; + W = V; + //V += me.measuredError(*ihit);// result = b*V + H*C*H.T() + + //ierr will be set to true when inversion is successfull + bool ierr = invertPosDefMatrix(W); + + //Det2 method will preserve the content of the Matrix + //and return true when the calculation is successfull + double det; + bool ierr2 = V.Det2(det); + + if( !ierr || !ierr2) { + LogTrace("SiTrackerMultiRecHitUpdator")<<"SiTrackerMultiRecHitUpdator::ComputeWeight: W not valid!"< PositionAndError22; + PositionAndError22 = ComputeParameters2dim(tsos, *(*ihit)); + + W_sum += ((*ihit)->weight()*PositionAndError22.second); + m_sum += ((*ihit)->weight()*(PositionAndError22.second*PositionAndError22.first)); + + } + + AlgebraicSymMatrix22 V_sum = W_sum; + bool ierr = invertPosDefMatrix(V_sum); + if( !ierr ) { + edm::LogError("SiTrackerMultiRecHitUpdator")<<"SiTrackerMultiRecHitUpdator::calcParameters: V_sum not valid!"< SiTrackerMultiRecHitUpdator::ComputeParameters2dim(const TrajectoryStateOnSurface& tsos, + const TransientTrackingRecHit& aRecHit) const{ + + switch (aRecHit.dimension()) { + case 2: return ComputeParameters2dim<2>(tsos,aRecHit); + //avoiding the not-2D hit due to the matrix final sum + case ( 1 || 3 || 4 || 5 ):{ + AlgebraicVector2 dummyVector2D (0.0,0.0); + AlgebraicSymMatrix22 dummyMatrix2D; + dummyMatrix2D(0,0) = dummyMatrix2D(1,0) = dummyMatrix2D(1,1) = 0.0; + return std::make_pair(dummyVector2D,dummyMatrix2D); + } + } + throw cms::Exception("Rec hit of invalid dimension (not 1,2,3,4,5)") << + "The value was " << aRecHit.dimension() << + ", type is " << typeid(aRecHit).name() << "\n"; +} + +//--------------------------------------------------------------------------------------------------------------- +template +std::pair SiTrackerMultiRecHitUpdator::ComputeParameters2dim(const TrajectoryStateOnSurface& tsos, + const TransientTrackingRecHit& aRecHit) const { + + // define variables that will be used to setup the KfComponentsHolder + ProjectMatrix pf; + typename AlgebraicROOTObject::Matrix H; + typename AlgebraicROOTObject::Vector r, rMeas; + typename AlgebraicROOTObject::SymMatrix V, VMeas, Wtemp; + AlgebraicVector5 x = tsos.localParameters().vector(); + const AlgebraicSymMatrix55 &C = (tsos.localError().matrix()); + + // setup the holder with the correct dimensions and get the values + KfComponentsHolder holder; + holder.template setup(&r, &V, &H, &pf, &rMeas, &VMeas, x, C); + aRecHit.getKfComponents(holder); + + Wtemp = V; + bool ierr = invertPosDefMatrix(Wtemp); + if( !ierr ) { + edm::LogError("SiTrackerMultiRecHitUpdator")<<"SiTrackerMultiRecHitUpdator::ComputeParameters2dim: W not valid!"<((*ihit)->parametersError())); + AlgebraicSymMatrix22 W(V.Inverse(ierr)); + + if(ierr != 0) { + edm::LogError("SiTrackerMultiRecHitUpdator")<<"MultiRecHit::checkParametersError: W not valid!"<weight()*W); + } + AlgebraicSymMatrix22 parametersError = W_sum.Inverse(ierr); + return LocalError(parametersError(0,0), parametersError(0,1), parametersError(1,1)); +} + +LocalPoint SiTrackerMultiRecHitUpdator::calcParameters(TransientTrackingRecHit::ConstRecHitContainer& map, const LocalError& er) const { + AlgebraicVector2 m_sum; + int ierr; + for( TransientTrackingRecHit::ConstRecHitContainer::const_iterator ihit = map.begin(); ihit != map.end(); ihit ++) { + AlgebraicVector2 m(asSVector<2>((*ihit)->parameters())); + AlgebraicSymMatrix22 V(asSMatrix<2>((*ihit)->parametersError())); + AlgebraicSymMatrix22 W(V.Inverse(ierr)); + + if(ierr != 0) { + edm::LogError("SiTrackerMultiRecHitUpdator")<<"MultiRecHit::checkParameters: W not valid!"<weight()*(W*m); + else m_sum += ((*ihit)->weight()*(W*m)); + } + AlgebraicSymMatrix22 V_sum; + + V_sum(0,0) = er.xx(); + V_sum(0,1) = er.xy(); + V_sum(1,1) = er.yy(); + //AlgebraicSymMatrix V_sum(parametersError()); + AlgebraicVector2 parameters = V_sum*m_sum; + return LocalPoint(parameters(0), parameters(1)); +} +*/ diff --git a/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc~ b/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc~ new file mode 100644 index 0000000000000..1c07ebab67609 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc~ @@ -0,0 +1,240 @@ +#include "RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h" +#include "RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h" +//#include "RecoTracker/SiTrackerMRHTools/interface/GenericProjectedRecHit2D.h" +//#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h" +#include "DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h" +#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h" +#include "TrackingTools/TransientTrackingRecHit/interface/TrackingRecHitProjector.h" +#include "TrackingTools/TransientTrackingRecHit/interface/InvalidTransientRecHit.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" + +//ERICA: All the input parameter are in RecoTracker/SiTrackerMRHTools/python/SiTrackerMultiRecHitUpdator_cfi.py +SiTrackerMultiRecHitUpdator::SiTrackerMultiRecHitUpdator(const TransientTrackingRecHitBuilder* builder, + const TrackingRecHitPropagator* hitpropagator, + const float Chi2Cut, + const std::vector& anAnnealingProgram): + theBuilder(builder), + theHitPropagator(hitpropagator), + theChi2Cut(Chi2Cut), + theAnnealingProgram(anAnnealingProgram){} +//theAnnealingStep(0), +//theIsUpdating(true){} + +/* +TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::buildMultiRecHit(const std::vector& rhv, + TrajectoryStateOnSurface tsos, + float annealing) const{ + std::cout << "Calling SiTrackerMultiRecHitUpdator::buildMultiRecHit with AnnealingFactor: " << annealing << std::endl; + TransientTrackingRecHit::ConstRecHitContainer tcomponents; + for (std::vector::const_iterator iter = rhv.begin(); iter != rhv.end(); iter++){ + TransientTrackingRecHit::RecHitPointer transient = theBuilder->build(*iter); + if (transient->isValid()) tcomponents.push_back(transient); + } + + return update(tcomponents, tsos, annealing); + +} +*/ +TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( TransientTrackingRecHit::ConstRecHitPointer original, + TrajectoryStateOnSurface tsos, + double annealing) const{ + std::cout << "Calling SiTrackerMultiRecHitUpdator::update with AnnealingFactor: " << annealing << std::endl; + LogTrace("SiTrackerMultiRecHitUpdator") << "Calling SiTrackerMultiRecHitUpdator::update with AnnealingFactor: " << annealing; + if (original->isValid()) + LogTrace("SiTrackerMultiRecHitUpdator") << "Original Hit position " << original->localPosition() << " original error " + << original->parametersError(); + else LogTrace("SiTrackerMultiRecHitUpdator") << "Invalid hit"; + + if(!tsos.isValid()) { + //return original->clone(); + throw cms::Exception("SiTrackerMultiRecHitUpdator") << "!!! MultiRecHitUpdator::update(..): tsos NOT valid!!! "; + } + + //check if to clone is the right thing + if (original->transientHits().empty()) return original->clone(tsos); + + TransientTrackingRecHit::ConstRecHitContainer tcomponents = original->transientHits(); + return update(tcomponents, tsos, annealing); +} + +TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( TransientTrackingRecHit::ConstRecHitContainer& tcomponents, + TrajectoryStateOnSurface tsos, + double annealing) const{ + + if (tcomponents.empty()){ + LogTrace("SiTrackerMultiRecHitUpdator") << "Empty components vector passed to SiTrackerMultiRecHitUpdator::update, returning an InvalidTransientRecHit "; + return InvalidTransientRecHit::build(0); + } + + if(!tsos.isValid()) { + LogTrace("SiTrackerMultiRecHitUpdator")<<"SiTrackerMultiRecHitUpdator::update: tsos NOT valid!!!, returning an InvalidTransientRecHit"; + return InvalidTransientRecHit::build(0); + } + + std::vector updatedcomponents; + const GeomDet* geomdet = 0; + + //ERICA: running on all over the measurements for each vtraj + for (TransientTrackingRecHit::ConstRecHitContainer::const_iterator iter = tcomponents.begin(); iter != tcomponents.end(); iter++){ + + //ERICA: the first rechit must belong to the same surface of TSOS + setting geomdet variable + if (iter == tcomponents.begin()) { + + if (&((*iter)->det()->surface())!=&(tsos.surface())){ + throw cms::Exception("SiTrackerMultiRecHitUpdator") << "the Trajectory state and the first rechit passed to the SiTrackerMultiRecHitUpdator lay on different surfaces!: state lays on surface " << tsos.surface().position() << " hit with detid " << (*iter)->det()->geographicalId().rawId() << " lays on surface " << (*iter)->det()->surface().position(); + } + + geomdet = (*iter)->det(); + LogTrace("SiTrackerMultiRecHitUpdator") << "Current reference surface located at " << geomdet->surface().position(); + LogTrace("SiTrackerMultiRecHitUpdator")<< "TSOS position " << tsos.localPosition(); + } + + //ERICA::WARNING you have to fix GenericProjectedRecHit2D.h + if (&((*iter)->det()->surface())!=&(tsos.surface())){ +// TransientTrackingRecHit::RecHitPointer cloned = theHitPropagator->project(*iter, *geomdet, tsos); +// LogTrace("SiTrackerMultiRecHitUpdator") << "hit propagated"; + +// if (cloned->isValid()) updatedcomponents.push_back(cloned); + } else { + TransientTrackingRecHit::RecHitPointer cloned = (*iter)->clone(tsos); + if (cloned->isValid()) updatedcomponents.push_back(cloned); + } + } + LogTrace("SiTrackerMultiRecHitUpdator") << "hit cloned"; + //ERICA: ierr will be set to 0 when inversion is successfull + int ierr; + + std::vector > mymap; + std::vector > normmap; + + double a_sum=0, c_sum=0; + + AlgebraicVector2 tsospos; + tsospos[0]=tsos.localPosition().x(); + tsospos[1]=tsos.localPosition().y(); + LogTrace("SiTrackerMultiRecHitUpdator")<< "TSOS position " << tsos.localPosition(); + + for(std::vector::iterator ihit = updatedcomponents.begin(); ihit != updatedcomponents.end(); ihit++) { + AlgebraicVector2 r(asSVector<2>((*ihit)->parameters()) - tsospos); + AlgebraicSymMatrix22 V(asSMatrix<2>((*ihit)->parametersError())); + V *= annealing;//assume that TSOS is smoothed one + //V += me.measuredError(*ihit);// result = b*V + H*C*H.T() + AlgebraicSymMatrix22 W(V.Inverse(ierr)); + + //ERICA: the Det2 method will preserve the content of the Matrix and return true when the calculation is successfull + double det; + bool ierr2=!(V.Det2(det)); + + if(ierr != 0|| ierr2) { + LogTrace("SiTrackerMultiRecHitUpdator")<<"MultiRecHitUpdator::update: W not valid!"<((*ihit)->hit(), a_i)); + double c_i = exp(-0.5*theChi2Cut/annealing)/(2.*M_PI*sqrt(det)); + a_sum += a_i; + c_sum += c_i; + } + double total_sum = a_sum + c_sum; + + unsigned int counter = 0; + TransientTrackingRecHit::ConstRecHitContainer finalcomponents; + for(std::vector::iterator ihit = updatedcomponents.begin(); ihit != updatedcomponents.end(); ihit++) { + //uncomment lines below to have like ORCA + double p = ((mymap[counter].second)/total_sum > 1.e-6 ? (mymap[counter].second)/total_sum : 1.e-6); + //float p = ((mymap[counter].second)/total_sum > 0.01 ? (mymap[counter].second)/total_sum : 1.e-6); + normmap.push_back(std::pair(mymap[counter].first, p)); + //let's store the weight in the component TransientTrackingRecHit too +// (*ihit)->setWeight(p); +// (*ihit)->setAnnealingFactor(annealing); + finalcomponents.push_back(*ihit); + LogTrace("SiTrackerMultiRecHitUpdator")<< "Component hit type " << typeid(*mymap[counter].first).name() + << " position " << mymap[counter].first->localPosition() + << " error " << mymap[counter].first->localPositionError() + << " with weight " << p; + counter++; + } + + //ERICA: I do not understand what is the utility to do that. + mymap = normmap; + // LocalError er = calcParametersError(finalcomponents); + // LocalPoint p = calcParameters(finalcomponents, er); + SiTrackerMultiRecHitUpdator::LocalParameters param=calcParameters(finalcomponents); +// SiTrackerMultiRecHit updated(param.first, param.second, normmap.front().first->>geographicalId(), normmap); + SiTrackerMultiRecHit updated(param.first, param.second, normmap.front().first->det(), normmap); + LogTrace("SiTrackerMultiRecHitUpdator") << "Updated Hit position " << updated.localPosition() << " updated error " << updated.parametersError() << std::endl; + //return new SiTrackerMultiRecHit(normmap); + return TSiTrackerMultiRecHit::build(geomdet, &updated, finalcomponents, annealing); + +} + + +SiTrackerMultiRecHitUpdator::LocalParameters SiTrackerMultiRecHitUpdator::calcParameters(TransientTrackingRecHit::ConstRecHitContainer& map)const{ + AlgebraicSymMatrix22 W_sum; + AlgebraicVector2 m_sum; + int ierr; + for(TransientTrackingRecHit::ConstRecHitContainer::const_iterator ihit = map.begin(); ihit != map.end(); ihit ++) { + AlgebraicVector2 m(asSVector<2>((*ihit)->parameters())); + AlgebraicSymMatrix22 V(asSMatrix<2>((*ihit)->parametersError())); + AlgebraicSymMatrix22 W(V.Inverse(ierr)); + + if(ierr != 0) { + edm::LogError("SiTrackerMultiRecHitUpdator")<<"MultiRecHit::checkParameters: W not valid!"<weight()*W); + m_sum += ((*ihit)->weight()*(W*m)); + } + } + AlgebraicSymMatrix22 V_sum= W_sum.Inverse(ierr); + AlgebraicVector2 parameters = V_sum*m_sum; + LocalError error=LocalError(V_sum(0,0), V_sum(0,1), V_sum(1,1)); + LocalPoint position=LocalPoint(parameters(0), parameters(1)); + return std::make_pair(position,error); +} + +LocalError SiTrackerMultiRecHitUpdator::calcParametersError(TransientTrackingRecHit::ConstRecHitContainer& map) const { + AlgebraicSymMatrix22 W_sum; + int ierr; + for(TransientTrackingRecHit::ConstRecHitContainer::const_iterator ihit = map.begin(); ihit != map.end(); ihit ++) { + AlgebraicSymMatrix22 V(asSMatrix<2>((*ihit)->parametersError())); + AlgebraicSymMatrix22 W(V.Inverse(ierr)); + + if(ierr != 0) { + edm::LogError("SiTrackerMultiRecHitUpdator")<<"MultiRecHit::checkParametersError: W not valid!"<weight()*W); + } + AlgebraicSymMatrix22 parametersError = W_sum.Inverse(ierr); + return LocalError(parametersError(0,0), parametersError(0,1), parametersError(1,1)); +} + +LocalPoint SiTrackerMultiRecHitUpdator::calcParameters(TransientTrackingRecHit::ConstRecHitContainer& map, const LocalError& er) const { + AlgebraicVector2 m_sum; + int ierr; + for( TransientTrackingRecHit::ConstRecHitContainer::const_iterator ihit = map.begin(); ihit != map.end(); ihit ++) { + AlgebraicVector2 m(asSVector<2>((*ihit)->parameters())); + AlgebraicSymMatrix22 V(asSMatrix<2>((*ihit)->parametersError())); + AlgebraicSymMatrix22 W(V.Inverse(ierr)); + + if(ierr != 0) { + edm::LogError("SiTrackerMultiRecHitUpdator")<<"MultiRecHit::checkParameters: W not valid!"<weight()*(W*m); + else m_sum += ((*ihit)->weight()*(W*m)); + } + AlgebraicSymMatrix22 V_sum; + + V_sum(0,0) = er.xx(); + V_sum(0,1) = er.xy(); + V_sum(1,1) = er.yy(); + //AlgebraicSymMatrix V_sum(parametersError()); + AlgebraicVector2 parameters = V_sum*m_sum; + return LocalPoint(parameters(0), parameters(1)); +} + diff --git a/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc b/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc new file mode 100644 index 0000000000000..20f6c3add8f15 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc @@ -0,0 +1,193 @@ +#include "RecoTracker/SiTrackerMRHTools/interface/SimpleDAFHitCollector.h" +#include "RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h" +#include "RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h" +#include "TrackingTools/DetLayers/interface/MeasurementEstimator.h" +#include "TrackingTools/PatternTools/interface/Trajectory.h" +#include "TrackingTools/TransientTrackingRecHit/interface/InvalidTransientRecHit.h" +#include "TrackingTools/MeasurementDet/interface/MeasurementDet.h" +#include "RecoTracker/MeasurementDet/interface/MeasurementTrackerEvent.h" + +#include +#include + +#define _debug_SimpleDAFHitCollector_ + +using namespace std; + +vector SimpleDAFHitCollector::recHits(const Trajectory& traj, const MeasurementTrackerEvent *theMTE) const{ + +// std::cout << " Calling SimpleDAFHitCollector::recHits" << std::endl; + + //WARNING: At the moment the trajectories has the measurements + //with reversed sorting after the track smoothing + const vector& meas = traj.measurements(); + + if (meas.empty()) return vector(); + + //debug + LogTrace("MultiRecHitCollector") << "Original measurements are:"; + for(vector::const_iterator itrajmeas = meas.begin(); itrajmeas < meas.end(); + itrajmeas++) { + if (itrajmeas->recHit()->isValid()){ +// std::cout << " Valid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() +// << " local position " << itrajmeas->recHit()->hit()->localPosition() +// << " global position " << itrajmeas->recHit()->hit()->globalPosition() << "\n"; + LogTrace("MultiRecHitCollector") << "Valid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() + << " local position " << itrajmeas->recHit()->hit()->localPosition(); + } else { +// std::cout << " Invalid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() << std::endl; + LogTrace("MultiRecHitCollector") << "Invalid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId(); + } + } + + //groups the TrajectoryMeasurements on a sensor by sensor + //we have to sort the TrajectoryMeasurements in the opposite way in the fitting direction +// std::cout << " Sensor by sensor measurements are:\n"; + vector result; + for(vector::const_reverse_iterator itrajmeas = meas.rbegin(); itrajmeas < meas.rend(); + itrajmeas++) { + + DetId id = itrajmeas->recHit()->geographicalId(); + MeasurementDetWithData measDet = theMTE->idToDet(id); + tracking::TempMeasurements tmps; + std::vector hits; + + TrajectoryStateOnSurface current = itrajmeas->updatedState(); + //the error is scaled in order to take more "compatible" hits + if (current.isValid()) current.rescaleError(10); + + TrajectoryStateOnSurface state = itrajmeas->predictedState(); + if (!state.isValid()){ +// std::cout << "Something wrong! no valid TSOS found for this meas \n"; + LogTrace("MultiRecHitCollector") << "Something wrong! no valid TSOS found in current group "; + continue; + } + //collected hits compatible with the itrajmeas + if( measDet.measurements(current, *(getEstimator()), tmps)){ +// std::cout << " Found " << tmps.size() << " compatible measurements." << std::endl; + for (std::size_t i=0; i!=tmps.size(); ++i){ + DetId idtemps = tmps.hits[i]->geographicalId(); + + if( idtemps == id && tmps.hits[i]->hit()->isValid() ) { +// std::cout << " This hit is valid and has " << idtemps << " DetId."<< std::endl; + LogTrace("MultiRecHitCollector") << "This hit is valid "; + hits.push_back(tmps.hits[i]->hit()); + } + } + + //I will keep the Invalid hit, IF this is not the first one + if (hits.empty()){ +// std::cout << " No valid hits found in current group.\n "; + LogTrace("MultiRecHitCollector") << "No valid hits found in current group "; + + if( result.empty() ) continue; + + result.push_back(TrajectoryMeasurement(state, + InvalidTransientRecHit::build(&measDet.mdet().geomDet()))); + } else { + //measurements in groups are sorted with increating chi2 + //sort( *hits.begin(), *hits.end(), TrajMeasLessEstim()); + +// std::cout << " Found " << hits.size() << " valid hits for this sensor.\n"; + LogTrace("MultiRecHitCollector") << "Found " << hits.size() << " hits for this sensor"; + + //building a MultiRecHit out of each sensor group + result.push_back(TrajectoryMeasurement(state,theUpdator->buildMultiRecHit(hits, state))); + } + } else { +// std::cout << " No measurements found in current group.\n "; + LogTrace("MultiRecHitCollector") << "No valid hits found in current group "; + + if( result.empty() ) continue; + + result.push_back(TrajectoryMeasurement(state, + InvalidTransientRecHit::build(&measDet.mdet().geomDet()))); + } + + } +// std::cout << " Ending SimpleDAFHitCollector::recHits >> " << result.size() << std::endl; + LogTrace("MultiRecHitCollector") << "Original Measurement size " << meas.size() << " GroupedDAFHitCollector returned " << result.size() << " measurements"; + + //adding a protection against too few hits and invalid hits + //(due to failed propagation on the same surface of the original hits) + if (result.size()>2) + { + int hitcounter=0; + //check if the vector result has more than 3 valid hits + for (vector::const_iterator iimeas = result.begin(); iimeas != result.end(); ++iimeas) { + if(iimeas->recHit()->isValid()) hitcounter++; + } + + if(hitcounter>2) + return result; + else return vector(); + } + + else{return vector();} + +} + +/*vector SimpleDAFHitCollector::recHits(const Trajectory& traj, const MeasurementTrackerEvent *theMTE) const{ + + + //it assumes that the measurements are sorted in the smoothing direction + vector meas = traj.measurements(); + if (meas.empty()) //return TransientTrackingRecHit::ConstRecHitContainer(); + return vector(); + + + //TransientTrackingRecHit::ConstRecHitContainer result; + vector result; + + for(vector::reverse_iterator imeas = meas.rbegin(); imeas != meas.rend(); imeas++) { + //if the rechit is associated to a valid detId + if(imeas->recHit()->geographicalId().rawId()){ + MeasurementDetWithData md = theMTE->idToDet(imeas->recHit()->geographicalId()); + vector currentLayerMeas = md.fastMeasurements(imeas->updatedState(), imeas->updatedState(), *thePropagator, *(getEstimator())); + buildMultiRecHits(currentLayerMeas, result); + } else { + result.push_back(*imeas); + } + } + LogTrace("MultiRecHitCollector") << "Original Measurement size " << meas.size() << " SimpleDAFHitCollector returned " << result.size() << " rechits"; + //results are sorted in the fitting direction + return result; +} + +void SimpleDAFHitCollector::buildMultiRecHits(const vector& vmeas, vector& result) const { + + if (vmeas.empty()) { + LogTrace("MultiRecHitCollector") << "fastMeasurements returned an empty vector, should not happen " ; + //should we do something? + //result.push_back(InvalidTransientRecHit::build(0,TrackingRecHit::missing)); + return; + } + + TrajectoryStateOnSurface state = vmeas.front().predictedState(); + + if (state.isValid()==false){ + LogTrace("MultiRecHitCollector") << "first state is invalid; skipping "; + return; + } + + vector hits; + // TransientTrackingRecHit::ConstRecHitContainer hits; + + for (vector::const_iterator imeas = vmeas.begin(); imeas != vmeas.end(); imeas++){ + if (imeas->recHit()->getType() != TrackingRecHit::missing) { + LogTrace("MultiRecHitCollector") << "This hit is valid "; + hits.push_back(imeas->recHit()->hit()); + } + } + + if (hits.empty()){ + LogTrace("MultiRecHitCollector") << "No valid hits found "; + return; + } + + result.push_back(TrajectoryMeasurement(state,theUpdator->buildMultiRecHit(hits, state))); + // result.push_back(TrajectoryMeasurement(state,theUpdator->update(hits, state))); + +} + +*/ diff --git a/RecoTracker/SiTrackerMRHTools/src/module.cc b/RecoTracker/SiTrackerMRHTools/src/module.cc new file mode 100644 index 0000000000000..96f633a0da9bd --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/src/module.cc @@ -0,0 +1,10 @@ + +#include "RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h" +//#include "RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdatorMTF.h" +#include "RecoTracker/SiTrackerMRHTools/interface/MultiRecHitCollector.h" +//#include "RecoTracker/SiTrackerMRHTools/interface/MultiTrackFilterHitCollector.h" + +#include "FWCore/Utilities/interface/typelookup.h" + +TYPELOOKUP_DATA_REG(SiTrackerMultiRecHitUpdator); +TYPELOOKUP_DATA_REG(MultiRecHitCollector); diff --git a/RecoTracker/SiTrackerMRHTools/test/DAFRecoTrack_cfg.py b/RecoTracker/SiTrackerMRHTools/test/DAFRecoTrack_cfg.py new file mode 100644 index 0000000000000..23d00c0452f32 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/test/DAFRecoTrack_cfg.py @@ -0,0 +1,56 @@ +import FWCore.ParameterSet.Config as cms + +# inspired from RecoTracker/TrackProducer/test/TrackRefit.py + +process = cms.Process("Refitting") + +### standard MessageLoggerConfiguration +process.load("FWCore.MessageService.MessageLogger_cfi") + +### Standard Configurations +process.load("Configuration.StandardSequences.Services_cff") +process.load('Configuration/StandardSequences/Geometry_cff') +process.load('Configuration/StandardSequences/Reconstruction_cff') +process.load('Configuration/StandardSequences/MagneticField_cff') + +### Conditions +process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:startup', '') + +### Track Refitter +process.load("RecoTracker.TrackProducer.TrackRefitters_cff") +process.load("RecoTracker.TrackProducer.CTFFinalFitWithMaterialDAF_cff") +process.ctfWithMaterialTracksDAF.TrajectoryInEvent = True +process.ctfWithMaterialTracksDAF.src = 'TrackRefitter' +process.MRHFittingSmoother.EstimateCut = -1 +process.MRHFittingSmoother.MinNumberOfHits = 3 + +process.source = cms.Source("PoolSource", +# fileNames = cms.untracked.vstring('file:reco_trk_TTbar_13_5evts.root') + fileNames = cms.untracked.vstring('file:reco_trk_SingleMuPt10_UP15_10evts.root') +) +process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(-1)) + +process.out = cms.OutputModule("PoolOutputModule", + outputCommands = cms.untracked.vstring('drop *_*_*_*', + 'keep *_siPixelClusters_*_*', + 'keep *_siStripClusters_*_*', + 'keep *_siPixelDigis_*_*', + 'keep *_siStripDigis_*_*', + 'keep *_offlineBeamSpot_*_*', + 'keep *_pixelVertices_*_*', + 'keep *_siStripMatchedRecHits_*_*', + 'keep *_initialStepSeeds_*_*', + 'keep recoTracks_*_*_*', + 'keep recoTrackExtras_*_*_*', + 'keep TrackingRecHitsOwned_*_*_*'), + fileName = cms.untracked.string('refit_DAF_SingleMuPt10_UP15_100evts.root') + ) + +process.p = cms.Path(process.MeasurementTrackerEvent*process.TrackRefitter*process.ctfWithMaterialTracksDAF) +process.o = cms.EndPath(process.out) + +process.schedule = cms.Schedule(process.p,process.o) + + diff --git a/RecoTracker/TrackProducer/BuildFile.xml b/RecoTracker/TrackProducer/BuildFile.xml index d598e9aa3ba8a..30732fd9a3385 100644 --- a/RecoTracker/TrackProducer/BuildFile.xml +++ b/RecoTracker/TrackProducer/BuildFile.xml @@ -20,6 +20,7 @@ + diff --git a/RecoTracker/TrackProducer/interface/DAFTrackProducerAlgorithm.h b/RecoTracker/TrackProducer/interface/DAFTrackProducerAlgorithm.h new file mode 100644 index 0000000000000..19f6a6013b221 --- /dev/null +++ b/RecoTracker/TrackProducer/interface/DAFTrackProducerAlgorithm.h @@ -0,0 +1,95 @@ +/** \class DAFTrackProducerAlgorithm + * All is needed to run the deterministic annealing algorithm. Ported from ORCA. + * + * \author tropiano, genta + * \review in May 2014 by brondolin + */ + +#ifndef DAFTrackProducerAlgorithm_h +#define DAFTrackProducerAlgorithm_h + +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h" +#include "DataFormats/TrackCandidate/interface/TrackCandidateCollection.h" +#include "DataFormats/TrajectorySeed/interface/PropagationDirection.h" +#include "DataFormats/BeamSpot/interface/BeamSpot.h" + +class MagneticField; +class TrackingGeometry; +class TrajAnnealing; +class TrajectoryFitter; +class Trajectory; +class TrajectoryStateOnSurface; +class TransientTrackingRecHitBuilder; +class MultiRecHitCollector; +class SiTrackerMultiRecHitUpdator; +class MeasurementTrackerEvent; +namespace reco{ + class Track; +} + +class DAFTrackProducerAlgorithm { + + typedef std::pair > AlgoProduct; + typedef std::vector< AlgoProduct > AlgoProductCollection; + typedef std::vector TrajAnnealingCollection; + + public: + + DAFTrackProducerAlgorithm(const edm::ParameterSet& pset):conf_(pset){} + ~DAFTrackProducerAlgorithm() {} + + /// Run the Final Fit taking TrackCandidates as input + void runWithCandidate(const TrackingGeometry *, + const MagneticField *, + //const TrackCandidateCollection&, + const std::vector&, + const MeasurementTrackerEvent *measTk, + const TrajectoryFitter *, + const TransientTrackingRecHitBuilder*, + const MultiRecHitCollector* measurementTracker, + const SiTrackerMultiRecHitUpdator*, + const reco::BeamSpot&, + AlgoProductCollection &, + TrajAnnealingCollection &) const; + + private: + /// Construct Tracks to be put in the event + bool buildTrack(const Trajectory, + AlgoProductCollection& algoResults, + float, + const reco::BeamSpot&) const; + + /// accomplishes the fitting-smoothing step for each annealing value + Trajectory fit(const std::pair& hits, + const TrajectoryFitter * theFitter, + Trajectory vtraj) const; + + //calculates the ndof according to the DAF prescription + float calculateNdof(const Trajectory vtraj) const; + + //creates MultiRecHits out of a KF trajectory + std::pair collectHits( + const Trajectory vtraj, + const MultiRecHitCollector* measurementCollector, + const MeasurementTrackerEvent *measTk ) const; + + //updates the hits with the specified annealing factor + std::pair updateHits( + const Trajectory vtraj, + const SiTrackerMultiRecHitUpdator* updator, + double annealing) const; + + //removes from the trajectory isolated hits with very low weight + void filter(const TrajectoryFitter* fitter, + std::vector& input, + int minhits, std::vector& output) const; + + int checkHits( Trajectory iInitTraj, const Trajectory iFinalTraj) const; + + edm::ParameterSet conf_; + +}; + +#endif diff --git a/RecoTracker/TrackProducer/plugins/BuildFile.xml b/RecoTracker/TrackProducer/plugins/BuildFile.xml index c8b247d2e4b1e..67f546b8021f8 100644 --- a/RecoTracker/TrackProducer/plugins/BuildFile.xml +++ b/RecoTracker/TrackProducer/plugins/BuildFile.xml @@ -1,3 +1,5 @@ + + diff --git a/RecoTracker/TrackProducer/plugins/DAFTrackProducer.cc b/RecoTracker/TrackProducer/plugins/DAFTrackProducer.cc new file mode 100644 index 0000000000000..e24ccb2cbaf0c --- /dev/null +++ b/RecoTracker/TrackProducer/plugins/DAFTrackProducer.cc @@ -0,0 +1,134 @@ +#include + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h" +#include "RecoTracker/Record/interface/MultiRecHitRecord.h" +#include "RecoTracker/SiTrackerMRHTools/interface/MultiRecHitCollector.h" +#include "RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h" +#include "RecoTracker/TrackProducer/plugins/DAFTrackProducer.h" +#include "TrackingTools/GeomPropagators/interface/Propagator.h" +#include "TrackingTools/PatternTools/interface/Trajectory.h" +#include "TrackingTools/PatternTools/interface/TrajAnnealing.h" +#include "TrackingTools/PatternTools/interface/TrajTrackAssociation.h" +#include "TrackingTools/Records/interface/TrackingComponentsRecord.h" + + + +DAFTrackProducer::DAFTrackProducer(const edm::ParameterSet& iConfig): + KfTrackProducerBase(iConfig.getParameter("TrajectoryInEvent"),false), + theAlgo(iConfig) +{ + setConf(iConfig); + setSrc( consumes(iConfig.getParameter( "src" )), + consumes(iConfig.getParameter( "beamSpot" )), + consumes(iConfig.getParameter( "MeasurementTrackerEvent") )); + setAlias( iConfig.getParameter( "@module_label" ) ); + + //register your products + produces().setBranchAlias( alias_ + "Tracks" ); + produces().setBranchAlias( alias_ + "TrackExtras" ); + produces().setBranchAlias( alias_ + "RecHits" ); + produces >(); + produces(); + produces().setBranchAlias( alias_ + "TrajectoryAnnealing" ); +} + + +void DAFTrackProducer::produce(edm::Event& theEvent, const edm::EventSetup& setup) +{ +// std::cout << "Analyzing event number: " << theEvent.id() << "\n"; + edm::LogInfo("DAFTrackProducer") << "Analyzing event number: " << theEvent.id() << "\n"; + + //empty output collections + std::auto_ptr outputRHColl (new TrackingRecHitCollection); + std::auto_ptr outputTColl(new reco::TrackCollection); + std::auto_ptr outputTEColl(new reco::TrackExtraCollection); + std::auto_ptr > outputTrajectoryColl(new std::vector); + std::auto_ptr outputTrajAnnColl(new TrajAnnealingCollection); + + //declare and get stuff to be retrieved from ES + edm::ESHandle theG; + edm::ESHandle theMF; + edm::ESHandle theFitter; + edm::ESHandle thePropagator; + edm::ESHandle theMeasTk; + edm::ESHandle theBuilder; + getFromES(setup,theG,theMF,theFitter,thePropagator,theMeasTk,theBuilder); + + //get additional es_modules needed by the DAF + edm::ESHandle measurementCollectorHandle; + std::string measurementCollectorName = getConf().getParameter("MeasurementCollector"); + setup.get().get(measurementCollectorName, measurementCollectorHandle); + edm::ESHandle updatorHandle; + std::string updatorName = getConf().getParameter("UpdatorName"); + setup.get().get(updatorName, updatorHandle); + + //get MeasurementTrackerEvent + edm::Handle mte; + theEvent.getByToken(mteSrc_, mte); + + + //declare and get TrackColection + AlgoProductCollection algoResults; + reco::BeamSpot bs; + TrajAnnealingCollection trajannResults; + try{ + + edm::Handle > theTrajectoryCollection; + getFromEvt(theEvent,theTrajectoryCollection,bs); + + //obsolete? + //measurementCollectorHandle->updateEvent(theEvent); + + //run the algorithm + LogDebug("DAFTrackProducer") << "run the DAF algorithm" << "\n"; + theAlgo.runWithCandidate(theG.product(), theMF.product(), *theTrajectoryCollection, &*mte, + theFitter.product(), theBuilder.product(), + measurementCollectorHandle.product(), updatorHandle.product(), bs, + algoResults, trajannResults); + + } catch (cms::Exception &e){ + edm::LogInfo("DAFTrackProducer") << "cms::Exception caught!!!" << "\n" << e << "\n"; + throw; + } + + //put everything in the event + putInEvt(theEvent, thePropagator.product(), theMeasTk.product(), outputRHColl, + outputTColl, outputTEColl, + outputTrajectoryColl, algoResults); + putInEvtTrajAnn(theEvent, trajannResults, outputTrajAnnColl); + +// std::cout << "DAFTrackProducer: end the DAF algorithm." << "\n"; + LogDebug("DAFTrackProducer") << "end the DAF algorithm." << "\n"; +} + +void DAFTrackProducer::getFromEvt(edm::Event& theEvent,edm::Handle& theTrajectoryCollection, reco::BeamSpot& bs) +{ + + //get the TrajectoryCollection from the event + //WARNING: src has always to be redefined in cfg file + edm::InputTag src_=getConf().getParameter( "src" ); + theEvent.getByLabel(src_,theTrajectoryCollection ); + + //get the BeamSpot + edm::Handle recoBeamSpotHandle; + theEvent.getByToken(bsSrc_,recoBeamSpotHandle); + bs = *recoBeamSpotHandle; + +} + +void DAFTrackProducer::putInEvtTrajAnn(edm::Event& theEvent, TrajAnnealingCollection & trajannResults, + std::auto_ptr& outputTrajAnnColl){ + const int size = trajannResults.size(); + outputTrajAnnColl->reserve(size); + + for(unsigned int i = 0; i < trajannResults.size() ; i++){ +// trajannResults.at(i).Debug(); + outputTrajAnnColl->push_back(trajannResults.at(i)); + } + + theEvent.put( outputTrajAnnColl ); +} + diff --git a/RecoTracker/TrackProducer/plugins/DAFTrackProducer.h b/RecoTracker/TrackProducer/plugins/DAFTrackProducer.h new file mode 100644 index 0000000000000..fbbb6df84b588 --- /dev/null +++ b/RecoTracker/TrackProducer/plugins/DAFTrackProducer.h @@ -0,0 +1,33 @@ +/** \class DAFTrackProducer + * EDProducer for DAFTrackProducerAlgorithm. + * + * \author tropiano, genta + * \review in May 2014 by brondolin + */ + +#ifndef DAFTrackProducer_h +#define DAFTrackProducer_h + +#include "RecoTracker/TrackProducer/interface/KfTrackProducerBase.h" +#include "RecoTracker/TrackProducer/interface/DAFTrackProducerAlgorithm.h" +#include "TrackingTools/PatternTools/interface/Trajectory.h" +#include "TrackingTools/PatternTools/interface/TrajAnnealing.h" + +class DAFTrackProducer : public KfTrackProducerBase, public edm::EDProducer { +public: + + typedef std::vector TrajectoryCollection; +// typedef std::vector TrajAnnealingCollection; + explicit DAFTrackProducer(const edm::ParameterSet& iConfig); + + // Implementation of produce method + virtual void produce(edm::Event&, const edm::EventSetup&); + +private: + DAFTrackProducerAlgorithm theAlgo; + void getFromEvt(edm::Event&, edm::Handle&, reco::BeamSpot&); + void putInEvtTrajAnn(edm::Event& theEvent, TrajAnnealingCollection & trajannResults, + std::auto_ptr& selTrajAnn); +}; + +#endif diff --git a/RecoTracker/TrackProducer/plugins/SealModules.cc b/RecoTracker/TrackProducer/plugins/SealModules.cc index 6950872b7c83c..9c87e93069668 100644 --- a/RecoTracker/TrackProducer/plugins/SealModules.cc +++ b/RecoTracker/TrackProducer/plugins/SealModules.cc @@ -1,5 +1,6 @@ #include "FWCore/Framework/interface/MakerMacros.h" +#include "RecoTracker/TrackProducer/plugins/DAFTrackProducer.h" #include "RecoTracker/TrackProducer/plugins/TrackProducer.h" #include "RecoTracker/TrackProducer/plugins/TrackRefitter.h" #include "RecoTracker/TrackProducer/plugins/GsfTrackProducer.h" @@ -7,6 +8,7 @@ #include "RecoTracker/TrackProducer/plugins/ExtraFromSeeds.h" // +DEFINE_FWK_MODULE(DAFTrackProducer); DEFINE_FWK_MODULE(TrackProducer); DEFINE_FWK_MODULE(TrackRefitter); DEFINE_FWK_MODULE(GsfTrackProducer); diff --git a/RecoTracker/TrackProducer/plugins/TrackRefitter.cc b/RecoTracker/TrackProducer/plugins/TrackRefitter.cc index 8d9130fd71db8..53b39d5557898 100644 --- a/RecoTracker/TrackProducer/plugins/TrackRefitter.cc +++ b/RecoTracker/TrackProducer/plugins/TrackRefitter.cc @@ -74,6 +74,9 @@ void TrackRefitter::produce(edm::Event& theEvent, const edm::EventSetup& setup) { edm::Handle theTCollection; getFromEvt(theEvent,theTCollection,bs); + +// std::cout << "TrackRefitter::produce(none):Number of Trajectories:" << (*theTCollection).size() <& theTrajectoryCollection, + const MeasurementTrackerEvent *measTk, + const TrajectoryFitter * theFitter, + const TransientTrackingRecHitBuilder* builder, + const MultiRecHitCollector* measurementCollector, + const SiTrackerMultiRecHitUpdator* updator, + const reco::BeamSpot& bs, + AlgoProductCollection& algoResults, + TrajAnnealingCollection& trajann) const +{ + edm::LogInfo("TrackProducer") << "Number of Trajectories: " << theTrajectoryCollection.size() << "\n"; + int cont = 0; + + //running on src trajectory collection + for (std::vector::const_iterator ivtraj = theTrajectoryCollection.begin(); + ivtraj != theTrajectoryCollection.end(); ivtraj++) + { + + float ndof = 0; + Trajectory currentTraj; + + //getting trajectory + //no need to have std::vector vtraj ! + if ( (*ivtraj).isValid() ){ + + edm::LogInfo("TrackProducer") << "The trajectory is valid. \n"; + + //getting the MultiRecHit collection and the trajectory with a first fit-smooth round + std::pair hits = + collectHits(*ivtraj, measurementCollector, &*measTk); + currentTraj = fit(hits, theFitter, *ivtraj); + + //starting the annealing program + for (std::vector::const_iterator ian = updator->getAnnealingProgram().begin(); + ian != updator->getAnnealingProgram().end(); ian++){ + + if (currentTraj.isValid()){ + + LogDebug("DAFTrackProducerAlgorithm") << "Seed direction is " << currentTraj.seed().direction() + << ".Traj direction is " << currentTraj.direction(); + + //updating MultiRecHits and fit-smooth again + std::pair curiterationhits = + updateHits(currentTraj,updator,*ian); + currentTraj = fit(curiterationhits, theFitter, currentTraj); + + //saving trajectory for each annealing cycle ... + TrajAnnealing temp(currentTraj, *ian); + trajann.push_back(temp); + + LogDebug("DAFTrackProducerAlgorithm") << "done annealing value " << (*ian) ; + + } + else break; + + + } //end of annealing program + + //std::cout << (1.*checkHits(*ivtraj, currentTraj))/(1.*(*ivtraj).measurements().size())*100. << std::endl; + + LogDebug("DAFTrackProducerAlgorithm") << "Ended annealing program " << std::endl; + + //computing the ndof keeping into account the weights + ndof = calculateNdof(currentTraj); + + //checking if the trajectory has the minimum number of valid hits ( weight (>1e-6) ) + //in order to remove tracks with too many outliers. + + //std::vector filtered; + //filter(theFitter, vtraj, conf_.getParameter("MinHits"), filtered); + + if(currentTraj.foundHits() >= conf_.getParameter("MinHits")) { + + bool ok = buildTrack(currentTraj, algoResults, ndof, bs) ; + if(ok) cont++; + + } + else{ + LogDebug("DAFTrackProducerAlgorithm") << "Rejecting trajectory with " + << currentTraj.foundHits()<<" hits"; + } + } + else + LogDebug("DAFTrackProducerAlgorithm") << "Rejecting empty trajectory" << std::endl; + + } //end run on track collection + + LogDebug("TrackProducer") << "Number of Tracks found: " << cont << "\n"; + +} +/*------------------------------------------------------------------------------------------------------*/ +std::pair +DAFTrackProducerAlgorithm::collectHits(const Trajectory vtraj, + const MultiRecHitCollector* measurementCollector, + const MeasurementTrackerEvent *measTk) const +{ + + LogDebug("DAFTrackProducerAlgorithm") << "Calling DAFTrackProducerAlgorithm::collectHits"; + + //getting the traj measurements from the MeasurementCollector + int nHits = 0; + TransientTrackingRecHit::RecHitContainer hits; + std::vector collectedmeas = measurementCollector->recHits(vtraj, measTk); + + //if the MeasurementCollector is empty, make an "empty" pair + //else taking the collected measured hits and building the pair + if( collectedmeas.empty() ) + return std::make_pair(TransientTrackingRecHit::RecHitContainer(), TrajectoryStateOnSurface()); + + for( std::vector::const_iterator iter = collectedmeas.begin(); + iter!=collectedmeas.end(); iter++ ){ + + nHits++; + hits.push_back(iter->recHit()); + + } + + + //TrajectoryStateWithArbitraryError() == Creates a TrajectoryState with the same parameters + // as the input one, but with "infinite" errors, i.e. errors so big that they don't + // bias a fit starting with this state. + //return std::make_pair(hits,TrajectoryStateWithArbitraryError()(collectedmeas.front().predictedState())); + + // I do not have to rescale the error because it is already rescaled in the fit code + TrajectoryStateOnSurface initialStateFromTrack = collectedmeas.front().predictedState(); + + return std::make_pair(hits, initialStateFromTrack); + +} +/*------------------------------------------------------------------------------------------------------*/ +std::pair +DAFTrackProducerAlgorithm::updateHits(const Trajectory vtraj, + const SiTrackerMultiRecHitUpdator* updator, + double annealing) const +{ + TransientTrackingRecHit::RecHitContainer hits; + std::vector vmeas = vtraj.measurements(); + std::vector::reverse_iterator imeas; + + //I run inversely on the trajectory obtained and update the state + for (imeas = vmeas.rbegin(); imeas != vmeas.rend(); imeas++){ + TransientTrackingRecHit::RecHitPointer updated = updator->update(imeas->recHit(), + imeas->updatedState(), annealing); + hits.push_back(updated); + } + + TrajectoryStateOnSurface updatedStateFromTrack = vmeas.back().predictedState(); + //updatedStateFromTrack.rescaleError(10); + + //return std::make_pair(hits,TrajectoryStateWithArbitraryError()(vmeas.back().updatedState())); + return std::make_pair(hits,updatedStateFromTrack); +} +/*------------------------------------------------------------------------------------------------------*/ +Trajectory DAFTrackProducerAlgorithm::fit(const std::pair& hits, + const TrajectoryFitter * theFitter, + Trajectory vtraj) const { + + + //creating a new trajectory starting from the direction of the seed of the input one and the hits + Trajectory newVec = theFitter->fitOne(TrajectorySeed(PTrajectoryStateOnDet(), + BasicTrajectorySeed::recHitContainer(), + vtraj.seed().direction()), + hits.first, hits.second); + + if( newVec.isValid() ) return newVec; + else{ + //std::cout << "Fit no valid." << std::endl; + return Trajectory(); + } + +} +/*------------------------------------------------------------------------------------------------------*/ +bool DAFTrackProducerAlgorithm::buildTrack (const Trajectory vtraj, + AlgoProductCollection& algoResults, + float ndof, + const reco::BeamSpot& bs) const +{ + //variable declarations + reco::Track * theTrack; + Trajectory * theTraj; + + LogDebug("DAFTrackProducerAlgorithm") <<" BUILDER " << std::endl;; + TrajectoryStateOnSurface innertsos; + + if ( vtraj.isValid() ){ + + theTraj = new Trajectory( vtraj ); + + if (vtraj.direction() == alongMomentum) { + //if (theTraj->direction() == oppositeToMomentum) { + innertsos = vtraj.firstMeasurement().updatedState(); + //std::cout << "Inner momentum " << innertsos.globalParameters().momentum().mag() << std::endl; + } else { + innertsos = vtraj.lastMeasurement().updatedState(); + } + + TSCBLBuilderNoMaterial tscblBuilder; + TrajectoryStateClosestToBeamLine tscbl = tscblBuilder(*(innertsos.freeState()),bs); + + if (tscbl.isValid()==false) return false; + + GlobalPoint v = tscbl.trackStateAtPCA().position(); + math::XYZPoint pos( v.x(), v.y(), v.z() ); + GlobalVector p = tscbl.trackStateAtPCA().momentum(); + math::XYZVector mom( p.x(), p.y(), p.z() ); + + // LogDebug("TrackProducer") <& input, + int minhits, std::vector& output) const +{ + if (input.empty()) return; + + int ngoodhits = 0; + + std::vector vtm = input[0].measurements(); + + TransientTrackingRecHit::RecHitContainer hits; + + //count the number of non-outlier and non-invalid hits + for (std::vector::reverse_iterator tm=vtm.rbegin(); tm!=vtm.rend();tm++){ + //if the rechit is valid + if (tm->recHit()->isValid()) { + TransientTrackingRecHit::ConstRecHitContainer components = tm->recHit()->transientHits(); + bool isGood = false; + for (TransientTrackingRecHit::ConstRecHitContainer::iterator rechit = components.begin(); rechit != components.end(); rechit++){ + //if there is at least one component with weight higher than 1e-6 then the hit is not an outlier + if ((*rechit)->weight()>1e-6) {ngoodhits++; isGood = true; break;} + } + if (isGood) hits.push_back(tm->recHit()->clone(tm->updatedState())); + else hits.push_back(InvalidTransientRecHit::build(tm->recHit()->det(), TrackingRecHit::missing)); + } else { + hits.push_back(tm->recHit()->clone(tm->updatedState())); + } + } + + + LogDebug("DAFTrackProducerAlgorithm") << "Original number of valid hits " << input[0].foundHits() << "; after filtering " << ngoodhits; + //debug + if (ngoodhits>input[0].foundHits()) edm::LogError("DAFTrackProducerAlgorithm") << "Something wrong: the number of good hits from DAFTrackProducerAlgorithm::filter " << ngoodhits << " is higher than the original one " << input[0].foundHits(); + + if (ngoodhits < minhits) return; + + TrajectoryStateOnSurface curstartingTSOS = input.front().lastMeasurement().updatedState(); + LogDebug("DAFTrackProducerAlgorithm") << "starting tsos for final refitting " << curstartingTSOS ; + //curstartingTSOS.rescaleError(100); + + output = fitter->fit(TrajectorySeed(PTrajectoryStateOnDet(), + BasicTrajectorySeed::recHitContainer(), + input.front().seed().direction()), + hits, + TrajectoryStateWithArbitraryError()(curstartingTSOS)); + LogDebug("DAFTrackProducerAlgorithm") << "After filtering " << output.size() << " trajectories"; + +} +/*------------------------------------------------------------------------------------------------------*/ +float DAFTrackProducerAlgorithm::calculateNdof(const Trajectory vtraj) const +{ + + if (!vtraj.isValid()) return 0; + float ndof = 0; + const std::vector& meas = vtraj.measurements(); + for (std::vector::const_iterator iter = meas.begin(); iter != meas.end(); iter++){ + if (iter->recHit()->isValid()){ + TransientTrackingRecHit::ConstRecHitContainer components = iter->recHit()->transientHits(); + TransientTrackingRecHit::ConstRecHitContainer::const_iterator iter2; + + for (iter2 = components.begin(); iter2 != components.end(); iter2++){ + if ((*iter2)->isValid()) + ndof += ((*iter2)->dimension())*(*iter2)->weight(); + } + + } + } + + return ndof-5; + +} +//------------------------------------------------------------------------------------------------ +int DAFTrackProducerAlgorithm::checkHits( Trajectory iInitTraj, const Trajectory iFinalTraj) const { + + std::vector initmeasurements = iInitTraj.measurements(); + std::vector finalmeasurements = iFinalTraj.measurements(); + std::vector::iterator imeas; + std::vector::iterator jmeas; + int nSame = 0; + int ihit = 0; + + if ( initmeasurements.empty() || finalmeasurements.empty() || initmeasurements.size() != finalmeasurements.size() ){ + //std::cout << "Initial or Final Trajectory empty or with different size." << std::endl; + return 0; + } + + for(jmeas = initmeasurements.begin(); jmeas != initmeasurements.end(); jmeas++){ + + const TrackingRecHit* initHit = jmeas->recHit()->hit(); + + if(!initHit->isValid() && ihit == 0 ) continue; + + if(initHit->isValid()){ + + TrajectoryMeasurement imeas = finalmeasurements.at(ihit); + const TrackingRecHit* finalHit = imeas.recHit()->hit(); + const TrackingRecHit* MaxWeightHit=0; + float maxweight = 0; + + const SiTrackerMultiRecHit* mrh = dynamic_cast(finalHit); + if (mrh){ + std::vector components = mrh->recHits(); + std::vector::const_iterator icomp; + int hitcounter=0; + + for (icomp = components.begin(); icomp != components.end(); icomp++) { + if((*icomp)->isValid()) { + double weight = mrh->weight(hitcounter); + if(weight > maxweight) { + MaxWeightHit = *icomp; + maxweight = weight; + } + } + hitcounter++; + } + + auto myref1 = reinterpret_cast(initHit)->firstClusterRef(); + auto myref2 = reinterpret_cast(MaxWeightHit)->firstClusterRef(); + + if( myref1 == myref2 ){ + nSame++; + } + } + } else { + + TrajectoryMeasurement imeas = finalmeasurements.at(ihit); + const TrackingRecHit* finalHit = imeas.recHit()->hit(); + if(!finalHit->isValid()){ + nSame++; + } + } + + ihit++; + } + + return nSame; +} diff --git a/TrackingTools/KalmanUpdators/interface/MRHChi2MeasurementEstimator.h b/TrackingTools/KalmanUpdators/interface/MRHChi2MeasurementEstimator.h index 4e3052fbaf395..7836d8bd00ec5 100644 --- a/TrackingTools/KalmanUpdators/interface/MRHChi2MeasurementEstimator.h +++ b/TrackingTools/KalmanUpdators/interface/MRHChi2MeasurementEstimator.h @@ -17,8 +17,12 @@ class MRHChi2MeasurementEstimator GCC11_FINAL : public Chi2MeasurementEstimatorB explicit MRHChi2MeasurementEstimator(double maxChi2, double nSigma = 3.) : Chi2MeasurementEstimatorBase( maxChi2, nSigma) {} - virtual std::pair estimate(const TrajectoryStateOnSurface&, - const TrackingRecHit&) const; + std::pair estimate(const TrajectoryStateOnSurface& tsos, + const TrackingRecHit& aRecHit) const ; + template + std::pair estimate(const TrajectoryStateOnSurface& tsos, + const TrackingRecHit& aRecHit) const ; + virtual MRHChi2MeasurementEstimator* clone() const { return new MRHChi2MeasurementEstimator(*this); diff --git a/TrackingTools/KalmanUpdators/src/Chi2MeasurementEstimator.cc b/TrackingTools/KalmanUpdators/src/Chi2MeasurementEstimator.cc index ef71567adb0e1..011217b3e83e3 100644 --- a/TrackingTools/KalmanUpdators/src/Chi2MeasurementEstimator.cc +++ b/TrackingTools/KalmanUpdators/src/Chi2MeasurementEstimator.cc @@ -20,6 +20,7 @@ Chi2MeasurementEstimator::estimate(const TrajectoryStateOnSurface& tsos, template std::pair Chi2MeasurementEstimator::estimate(const TrajectoryStateOnSurface& tsos, const TrackingRecHit& aRecHit) const { + typedef typename AlgebraicROOTObject::Matrix MatD5; typedef typename AlgebraicROOTObject<5,D>::Matrix Mat5D; typedef typename AlgebraicROOTObject::SymMatrix SMatDD; @@ -35,5 +36,6 @@ Chi2MeasurementEstimator::estimate(const TrajectoryStateOnSurface& tsos, R += RMeas; invertPosDefMatrix(R); double est = ROOT::Math::Similarity(r - rMeas, R); + return returnIt(est); } diff --git a/TrackingTools/KalmanUpdators/src/KFUpdator.cc b/TrackingTools/KalmanUpdators/src/KFUpdator.cc index fecdbbd7358a4..783a0a9507837 100644 --- a/TrackingTools/KalmanUpdators/src/KFUpdator.cc +++ b/TrackingTools/KalmanUpdators/src/KFUpdator.cc @@ -113,6 +113,7 @@ TrajectoryStateOnSurface KFUpdator::update(const TrajectoryStateOnSurface& tsos, MeasurementExtractor me(tsos); + typedef typename AlgebraicROOTObject::Matrix MatD5; AlgebraicVector5 x = tsos.localParameters().vector(); const AlgebraicSymMatrix55 &C = (tsos.localError().matrix()); // Measurement matrix diff --git a/TrackingTools/KalmanUpdators/src/MRHChi2MeasurementEstimator.cc b/TrackingTools/KalmanUpdators/src/MRHChi2MeasurementEstimator.cc index 627d49ccb16d0..42c0193e97c63 100644 --- a/TrackingTools/KalmanUpdators/src/MRHChi2MeasurementEstimator.cc +++ b/TrackingTools/KalmanUpdators/src/MRHChi2MeasurementEstimator.cc @@ -6,31 +6,64 @@ #include "FWCore/MessageLogger/interface/MessageLogger.h" #include "DataFormats/Math/interface/invertPosDefMatrix.h" -std::pair -MRHChi2MeasurementEstimator::estimate(const TrajectoryStateOnSurface& tsos, - const TrackingRecHit& aRecHit) const { - if (!aRecHit.isValid()) { - throw cms::Exception("MRHChi2MeasurementEstimator") << "Invalid RecHit passed to the MRHChi2MeasurementEstimator "; - } +std::pair MRHChi2MeasurementEstimator::estimate(const TrajectoryStateOnSurface& tsos, + const TrackingRecHit& aRecHit) const { - typedef AlgebraicROOTObject<2>::Vector Vec; - typedef AlgebraicROOTObject<2>::SymMatrix Mat; + switch (aRecHit.dimension()) { + case 2: return estimate<2>(tsos,aRecHit); + //avoid the not-2D hit due to the final sum + case ( 1 || 3 || 4 || 5 ):{ + std::cout << "WARNING:The hit is not 2D: does not count in the MRH Chi2 estimation." << std::endl; + double est = 0.0; + return HitReturnType(false, est); + } + } + throw cms::Exception("Rec hit of invalid dimension (not 1,2,3,4,5)") << + "The value was " << aRecHit.dimension() << + ", type is " << typeid(aRecHit).name() << "\n"; +} - //better be a multihit... +//--------------------------------------------------------------------------------------------------------------- +template +std::pair MRHChi2MeasurementEstimator::estimate(const TrajectoryStateOnSurface& tsos, + const TrackingRecHit& aRecHit) const { + TSiTrackerMultiRecHit const & mHit = dynamic_cast(aRecHit); - MeasurementExtractor me(tsos); double est=0; + double annealing = mHit.getAnnealingFactor(); - LogDebug("MRHChi2MeasurementEstimator") << "Current annealing factor is " << annealing; + LogDebug("MRHChi2MeasurementEstimator") << "Current annealing factor is " << annealing; + TransientTrackingRecHit::ConstRecHitContainer components = mHit.transientHits(); - LogDebug("MRHChi2MeasurementEstimator") << "this hit has " << components.size() << " components"; - for (TransientTrackingRecHit::ConstRecHitContainer::const_iterator iter = components.begin(); iter != components.end(); iter++){ - Vec r = asSVector<2>((*iter)->parameters()) - me.measuredParameters<2>(**iter); - Mat R = asSMatrix<2>((*iter)->parametersError())*annealing + me.measuredError<2>(**iter); - //int ierr = ! R.Invert(); // if (ierr != 0) throw exception; // - invertPosDefMatrix(R); - LogDebug("MRHChi2MeasurementEstimator") << "Hit with weight " << (*iter)->weight(); - est += ROOT::Math::Similarity(r, R)*((*iter)->weight()); - } + LogDebug("MRHChi2MeasurementEstimator") << "this hit has " << components.size() << " components"; + + for (TransientTrackingRecHit::ConstRecHitContainer::const_iterator iter = components.begin(); iter != components.end(); iter++){ + + // define variables that will be used to setup the KfComponentsHolder + ProjectMatrix pf; + typename AlgebraicROOTObject::Matrix H; + typename AlgebraicROOTObject::Vector r, rMeas; + typename AlgebraicROOTObject::SymMatrix V, VMeas; + AlgebraicVector5 x = tsos.localParameters().vector(); + const AlgebraicSymMatrix55 &C = (tsos.localError().matrix()); + + // setup the holder with the correct dimensions and get the values + KfComponentsHolder holder; + holder.template setup(&r, &V, &H, &pf, &rMeas, &VMeas, x, C); + (**iter).getKfComponents(holder); + + r -= rMeas; + V = V*annealing + VMeas; + bool ierr = invertPosDefMatrix(V); + if( !ierr ) { + edm::LogError("SiTrackerMultiRecHitUpdator")<<"SiTrackerMultiRecHitUpdator::ComputeParameters2dim: W not valid!"<weight(); + est += ROOT::Math::Similarity(r, V)*((*iter)->weight()); + } + return returnIt(est); + } + diff --git a/TrackingTools/PatternTools/BuildFile.xml b/TrackingTools/PatternTools/BuildFile.xml index 05ad6fe641029..177f497d647d1 100644 --- a/TrackingTools/PatternTools/BuildFile.xml +++ b/TrackingTools/PatternTools/BuildFile.xml @@ -7,6 +7,7 @@ + diff --git a/TrackingTools/PatternTools/interface/TrajAnnealing.h b/TrackingTools/PatternTools/interface/TrajAnnealing.h new file mode 100644 index 0000000000000..60f7d03a29638 --- /dev/null +++ b/TrackingTools/PatternTools/interface/TrajAnnealing.h @@ -0,0 +1,48 @@ +/** \class TrajAnnealing + * Allow to save all the traj info + * for each annealing cycle + * suitable for algorithm like DAF + * + * \author in May 2014 by brondolin + */ + +#ifndef DataFormats_TrajAnnealing_h +#define DataFormats_TrajAnnealing_h + +#include + +//class +class TrajAnnealing +{ +public: + TrajAnnealing(): + traj_(), + annealing_(0), + theWeights(){} + virtual ~TrajAnnealing(){} + + TrajAnnealing( Trajectory, float ); + + void Debug() const; + float getAnnealing() const { return annealing_; } + Trajectory getTraj() const { return traj_; } + + //vector of weights + std::vector const & weights() const {return theWeights;} + std::vector & weights() {return theWeights;} + +private: + + Trajectory traj_; + float annealing_; + std::vector theWeights; + TransientTrackingRecHit::RecHitContainer theHits_; + + std::pair > getAnnealingWeight( const TrackingRecHit& aRecHit ) const ; +}; + +// this is our new product, it is simply a +// collection of TrajAnnealing held in an std::vector +typedef std::vector TrajAnnealingCollection; + +#endif diff --git a/TrackingTools/PatternTools/src/TrajAnnealing.cc b/TrackingTools/PatternTools/src/TrajAnnealing.cc new file mode 100644 index 0000000000000..e326133729d5a --- /dev/null +++ b/TrackingTools/PatternTools/src/TrajAnnealing.cc @@ -0,0 +1,70 @@ +#include "TrackingTools/PatternTools/interface/Trajectory.h" +#include "TrackingTools/PatternTools/interface/TrajAnnealing.h" +#include "TrackingTools/PatternTools/interface/TrajectoryMeasurement.h" +#include "RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h" + +TrajAnnealing::TrajAnnealing( Trajectory traj, float ann ){ + traj_ = traj; + annealing_ = ann; + + std::vector measurements = traj_.measurements(); + std::vector vmeas = traj_.measurements(); + std::vector::reverse_iterator imeas; + + //I run inversely on the trajectory obtained and update the state + for (imeas = vmeas.rbegin(); imeas != vmeas.rend(); imeas++){ + theHits_.push_back(imeas->recHit()); + } + + int hitcounter = 1; + for(TransientTrackingRecHit::RecHitContainer::const_iterator ihit = theHits_.begin(); + ihit != theHits_.end(); ++ihit, ++hitcounter) { + + std::pair > annweight; + annweight = getAnnealingWeight(**ihit); + for(unsigned int i = 0 ; i < annweight.second.size(); i++ ){ + theWeights.push_back( annweight.second.at(i) ); + } + } +} + +void TrajAnnealing::Debug() const{ + + std::vector measurements = traj_.measurements(); + TransientTrackingRecHit::RecHitContainer hits; + std::vector vmeas = traj_.measurements(); + std::vector::reverse_iterator imeas; + + //I run inversely on the trajectory obtained and update the state + for (imeas = vmeas.rbegin(); imeas != vmeas.rend(); imeas++){ + hits.push_back(imeas->recHit()); + } + + int hitcounter = 1; + for(TransientTrackingRecHit::RecHitContainer::const_iterator ihit = hits.begin(); + ihit != hits.end(); ++ihit, ++hitcounter) { + + std::pair > annweight; + annweight = getAnnealingWeight(**ihit); + std::cout << "Annealing: " << annweight.first; + for(unsigned int i = 0 ; i < annweight.second.size(); i++ ){ + std::cout << "\tHit weight in mrh " << annweight.second.at(i) << "\t"; + } + std::cout << std::endl; + } + +} + +std::pair > TrajAnnealing::getAnnealingWeight( const TrackingRecHit& aRecHit ) const { + + if (!aRecHit.isValid()) { + std::vector dumpyVec = {0.0}; +// std::cout << "Invalid RecHit passed " << std::endl; + return make_pair(0.0,dumpyVec); + } + + TSiTrackerMultiRecHit const & mHit = dynamic_cast(aRecHit); + return make_pair(mHit.getAnnealingFactor(), mHit.weights()); + +} + diff --git a/TrackingTools/PatternTools/src/classes.h b/TrackingTools/PatternTools/src/classes.h index 5565695f5ec20..f237681d1607d 100644 --- a/TrackingTools/PatternTools/src/classes.h +++ b/TrackingTools/PatternTools/src/classes.h @@ -9,6 +9,7 @@ #include "DataFormats/TrackCandidate/interface/TrackCandidate.h" #include "DataFormats/TrackReco/interface/TrackFwd.h" #include "TrackingTools/PatternTools/interface/Trajectory.h" +#include "TrackingTools/PatternTools/interface/TrajAnnealing.h" #include "TrackingTools/TrajectoryState/interface/FreeTrajectoryState.h" #include "DataFormats/GeometrySurface/interface/Surface.h" #include "DataFormats/CLHEP/interface/Migration.h" @@ -29,7 +30,10 @@ namespace TrackingTools_PatternTools { struct dictionary { std::vector kk; edm::Wrapper > trajCollWrapper; - + + std::vector ta; + edm::Wrapper > trajAnnCollaction; + TrajTrackAssociationCollection ttam; edm::Wrapper wttam; TrajTrackAssociation vttam; diff --git a/TrackingTools/PatternTools/src/classes_def.xml b/TrackingTools/PatternTools/src/classes_def.xml index e2c9a57c2ad90..65c614dbd46fe 100755 --- a/TrackingTools/PatternTools/src/classes_def.xml +++ b/TrackingTools/PatternTools/src/classes_def.xml @@ -59,4 +59,8 @@ + + + + diff --git a/TrackingTools/TrackFitters/python/TrackFitters_cff.py b/TrackingTools/TrackFitters/python/TrackFitters_cff.py index 6ee71422391eb..a2a9b37952606 100644 --- a/TrackingTools/TrackFitters/python/TrackFitters_cff.py +++ b/TrackingTools/TrackFitters/python/TrackFitters_cff.py @@ -5,7 +5,7 @@ from TrackingTools.TrackFitters.KFTrajectoryFitterESProducer_cfi import * from TrackingTools.TrackFitters.KFTrajectorySmootherESProducer_cfi import * -# from TrackingTools.TrackFitters.MRHFitters_cff import * +from TrackingTools.TrackFitters.MRHFitters_cff import * from TrackingTools.TrackFitters.RungeKuttaFitters_cff import * from TrackingTools.TrackFitters.RungeKutta1DFitters_cff import * diff --git a/TrackingTools/TrackFitters/src/KFFittingSmoother.cc b/TrackingTools/TrackFitters/src/KFFittingSmoother.cc index 8d793d415cbce..98f3022825c8a 100644 --- a/TrackingTools/TrackFitters/src/KFFittingSmoother.cc +++ b/TrackingTools/TrackFitters/src/KFFittingSmoother.cc @@ -48,7 +48,7 @@ Trajectory KFFittingSmoother::fitOne(const TrajectorySeed& aSeed, LogDebug("TrackFitters") << "In KFFittingSmoother::fit"; if ( hits.empty() ) return Trajectory(); - + bool hasoutliers=false; bool has_low_pixel_prob=false; // ggiurgiu@fnal.gov: Add flag for pixel hits with low template probability @@ -296,7 +296,7 @@ Trajectory KFFittingSmoother::fitOne(const TrajectorySeed& aSeed, LogTrace("TrackFitters") << "end: returning smoothed trajectory with chi2=" << smoothed.chiSquared() ; - + //LogTrace("TrackFitters") << "dump hits before return"; //Trajectory::DataContainer meas = smoothed[0].measurements(); //for (Trajectory::DataContainer::iterator it=meas.begin();it!=meas.end();++it) { diff --git a/TrackingTools/TrackFitters/src/KFTrajectoryFitter.cc b/TrackingTools/TrackFitters/src/KFTrajectoryFitter.cc index 5efbb8f019d02..fe56fcece508e 100644 --- a/TrackingTools/TrackFitters/src/KFTrajectoryFitter.cc +++ b/TrackingTools/TrackFitters/src/KFTrajectoryFitter.cc @@ -56,7 +56,7 @@ Trajectory KFTrajectoryFitter::fitOne(const TrajectorySeed& aSeed, #ifdef EDM_ML_DEBUG LogDebug("TrackFitters") <<" +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n" - <<" KFTrajectoryFitter::fit starting with " << hits.size() <<" HITS"; + <<" KFTrajectoryFitter::fitOne starting with " << hits.size() <<" HITS"; for (unsigned int j=0;jdet()) @@ -68,6 +68,8 @@ Trajectory KFTrajectoryFitter::fitOne(const TrajectorySeed& aSeed, LogTrace("TrackFitters") << " INITIAL STATE "<< firstPredTsos; #endif + + Trajectory ret(aSeed, thePropagator->propagationDirection()); Trajectory & myTraj = ret; myTraj.reserve(hits.size()); @@ -87,8 +89,7 @@ Trajectory KFTrajectoryFitter::fitOne(const TrajectorySeed& aSeed, #ifdef EDM_ML_DEBUG if (hit.isValid()) { - LogTrace("TrackFitters") - << " ----------------- HIT #" << hitcounter << " (VALID)-----------------------\n" + LogTrace("TrackFitters")<< " ----------------- HIT #" << hitcounter << " (VALID)-----------------------\n" << " HIT IS AT R " << hit.globalPosition().perp() << "\n" << " HIT IS AT Z " << hit.globalPosition().z() << "\n" << " HIT IS AT Phi " << hit.globalPosition().phi() << "\n" @@ -141,13 +142,13 @@ Trajectory KFTrajectoryFitter::fitOne(const TrajectorySeed& aSeed, if ( hitcounter != 1) //no propagation needed for the first hit predTsos = thePropagator->propagate( currTsos, *(hit.surface()) ); - + if unlikely(!predTsos.isValid()) { - LogDebug("TrackFitters") - << "SOMETHING WRONG !" << "\n" - << "KFTrajectoryFitter: predicted tsos not valid!\n" - << "current TSOS: " << currTsos << "\n"; + LogDebug("TrackFitters") + << "SOMETHING WRONG !" << "\n" + << "KFTrajectoryFitter: predicted tsos not valid!\n" + << "current TSOS: " << currTsos << "\n"; if(hit.surface()) LogTrace("TrackFitters") << "next Surface: " << hit.surface()->position() << "\n"; @@ -159,7 +160,7 @@ Trajectory KFTrajectoryFitter::fitOne(const TrajectorySeed& aSeed, return Trajectory(); } } - + if likely(hit.isValid()) { //update LogTrace("TrackFitters") << "THE HIT IS VALID: updating hit with predTsos"; @@ -182,11 +183,17 @@ Trajectory KFTrajectoryFitter::fitOne(const TrajectorySeed& aSeed, || std::abs(currTsos.localParameters().position().x()) > 1000 ) ) || edm::isNotFinite(currTsos.localParameters().qbp()); if unlikely(badState){ - if (!currTsos.isValid()) edm::LogError("FailedUpdate") - <<"updating with the hit failed. Not updating the trajectory with the hit"; - else if (edm::isNotFinite(currTsos.localParameters().qbp())) edm::LogError("TrajectoryNaN")<<"Trajectory has NaN"; - else LogTrace("FailedUpdate")<<"updated state is valid but pretty bad, skipping. currTsos " - <idToLayer((*ihit)->geographicalId()) )); //There is a no-fail policy here. So, it's time to give up //Keep the traj with invalid TSOS so that it's clear what happened @@ -198,11 +205,15 @@ Trajectory KFTrajectoryFitter::fitOne(const TrajectorySeed& aSeed, return Trajectory(); } } else{ - if (preciseHit->det()) myTraj.push(TM(predTsos, currTsos, preciseHit, + if (preciseHit->det()){ + myTraj.push(TM(predTsos, currTsos, preciseHit, estimator()->estimate(predTsos, *preciseHit).second, theGeometry->idToLayer(preciseHit->geographicalId()) )); - else myTraj.push(TM(predTsos, currTsos, preciseHit, + } + else{ + myTraj.push(TM(predTsos, currTsos, preciseHit, estimator()->estimate(predTsos, *preciseHit).second)); + } } } } else { @@ -211,12 +222,13 @@ Trajectory KFTrajectoryFitter::fitOne(const TrajectorySeed& aSeed, currTsos = predTsos; myTraj.push(TM(predTsos, *ihit,0,theGeometry->idToLayer((*ihit)->geographicalId()) )); } - + LogTrace("TrackFitters") << "predTsos !" << "\n" << predTsos << "\n" <<"currTsos !" << "\n" << currTsos; + } LogDebug("TrackFitters") << "Found 1 trajectory with " << myTraj.foundHits() << " valid hits\n"; diff --git a/TrackingTools/TrackFitters/src/KFTrajectorySmoother.cc b/TrackingTools/TrackFitters/src/KFTrajectorySmoother.cc index 79e79ad42e31c..536adb2de045c 100644 --- a/TrackingTools/TrackFitters/src/KFTrajectorySmoother.cc +++ b/TrackingTools/TrackFitters/src/KFTrajectorySmoother.cc @@ -172,7 +172,6 @@ KFTrajectorySmoother::trajectory(const Trajectory& aTraj) const { } TransientTrackingRecHit::RecHitPointer preciseHit = hit->clone(combTsos); - if unlikely(!preciseHit->isValid()){ LogTrace("TrackFitters") << "THE Precise HIT IS NOT VALID: using currTsos = predTsos" << "\n"; currTsos = predTsos; diff --git a/TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h b/TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h index 49d309145fd21..b10de7b39a722 100644 --- a/TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h +++ b/TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h @@ -90,12 +90,23 @@ class TransientTrackingRecHit : public TrackingRecHit, /// cluster probability, overloaded by pixel rechits. virtual float clusterProbability() const { return 1.f; } + /// ERICA::DAFalgo : + /// interface needed to set and read back the weight and the annealing value that has been applied to the current hit error matrix when + /// using it as a component for a composite rec hit (useful for the DAF) + void setWeight(float weight){weight_ = weight;} + float weight() const {return weight_;} + void setAnnealingFactor(float annealing) {annealing_ = annealing;} + float getAnnealingFactor() const {return annealing_;} + private: // hide the clone method for ReferenceCounted. Warning: this method is still // accessible via the bas class TrackingRecHit interface! virtual TransientTrackingRecHit * clone() const = 0; + float weight_; + float annealing_; + }; #endif From 9f102591342344a45a9d6fdd088651caace7ed55 Mon Sep 17 00:00:00 2001 From: erica brondolin Date: Tue, 10 Jun 2014 09:40:42 +0200 Subject: [PATCH 02/16] Running in release pre8 --- DAFTest/DAFValidator/plugins/DAFValidator.cc | 7 +- DAFTest/DAFValidator/plugins/DAFValidator.h | 2 +- .../interface/SiTrackerMultiRecHit.h | 29 +++++++-- .../src/SiTrackerMultiRecHit.cc | 14 +++- .../TrackerRecHit2D/src/classes_def.xml | 3 +- .../interface/GenericProjectedRecHit2D.h | 2 +- .../interface/SiTrackerMultiRecHitUpdator.h | 3 + .../src/GenericProjectedRecHit2D.cc | 6 +- .../src/SiTrackerMultiRecHitUpdator.cc | 57 ++++++++++------- .../src/SimpleDAFHitCollector.cc | 29 +++++---- .../interface/DAFTrackProducerAlgorithm.h | 5 +- .../TrackProducer/plugins/DAFTrackProducer.cc | 6 +- .../src/DAFTrackProducerAlgorithm.cc | 64 +++++++++++-------- .../interface/TSiTrackerMultiRecHit.h | 14 ++-- .../interface/TrackingRecHitPropagator.h | 24 ++++--- .../src/MRHChi2MeasurementEstimator.cc | 10 ++- .../PatternTools/interface/TrajAnnealing.h | 2 +- .../PatternTools/src/TrajAnnealing.cc | 3 +- .../TrackFitters/src/KFTrajectoryFitter.cc | 11 ---- 19 files changed, 177 insertions(+), 114 deletions(-) diff --git a/DAFTest/DAFValidator/plugins/DAFValidator.cc b/DAFTest/DAFValidator/plugins/DAFValidator.cc index 909304154618e..a7ca83afb0cfd 100644 --- a/DAFTest/DAFValidator/plugins/DAFValidator.cc +++ b/DAFTest/DAFValidator/plugins/DAFValidator.cc @@ -20,7 +20,6 @@ #include "DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h" #include "TrackingTools/PatternTools/interface/TrajTrackAssociation.h" #include "DataFormats/TrackingRecHit/interface/TrackingRecHitFwd.h" -#include "RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h" #include "SimDataFormats/TrackingHit/interface/PSimHit.h" using namespace std; @@ -689,12 +688,12 @@ GlobalPoint DAFValidator::getGlobalPosition(const TrackingRecHit* hit, const Tra } //--------------------------------------------------------------------------------------------------------- -std::pair > DAFValidator::getAnnealingWeight( const TrackingRecHit& aRecHit ) const { +/*std::pair > DAFValidator::getAnnealingWeight( const TrackingRecHit& aRecHit ) const { - TSiTrackerMultiRecHit const & mHit = dynamic_cast(aRecHit); + SiTrackerMultiRecHit const & mHit = dynamic_cast(aRecHit); return make_pair(mHit.getAnnealingFactor(), mHit.weights()); -} +}*/ // DEFINE_FWK_MODULE(DAFValidator); diff --git a/DAFTest/DAFValidator/plugins/DAFValidator.h b/DAFTest/DAFValidator/plugins/DAFValidator.h index 9fb1fcff80f39..3c8ab5d18f27a 100644 --- a/DAFTest/DAFValidator/plugins/DAFValidator.h +++ b/DAFTest/DAFValidator/plugins/DAFValidator.h @@ -74,7 +74,7 @@ class DAFValidator : public edm::EDAnalyzer int fillNotMergedHisto(const std::vector& simhitids, const std::vector& simhits, const TrackingParticle* tpref, float weight, const TrackerGeometry* geom) const; float getType(const TrackingRecHit* hit) const; - std::pair > getAnnealingWeight( const TrackingRecHit& aRecHit ) const; +// std::pair > getAnnealingWeight( const TrackingRecHit& aRecHit ) const; private: edm::ParameterSet theConf_; diff --git a/DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h b/DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h index 2b0046ebb33f0..33b78f4827aac 100644 --- a/DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h +++ b/DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h @@ -21,9 +21,12 @@ class SiTrackerMultiRecHit : public BaseTrackerRecHit SiTrackerMultiRecHit(const LocalPoint&, const LocalError&, GeomDet const & idet, - const std::vector< std::pair >&); + const std::vector< std::pair >&, double); virtual SiTrackerMultiRecHit* clone() const {return new SiTrackerMultiRecHit(*this);} +#ifdef NO_DICT + virtual RecHitPointer cloneSH() const { return std::make_shared(*this);} +#endif virtual int dimension() const {return 2;} virtual void getKfComponents( KfComponentsHolder & holder ) const { getKfComponents2D(holder); } @@ -32,11 +35,13 @@ class SiTrackerMultiRecHit : public BaseTrackerRecHit // used by trackMerger (to be improved) virtual OmniClusterRef const & firstClusterRef() const { return static_cast(&theHits.front())->firstClusterRef();} - - //vector of component rechits + /// Access to component RecHits (if any) virtual std::vector recHits() const; - +// virtual void recHitsV(std::vector & ) const; + + /// Non-const access to component RecHits (if any) virtual std::vector recHits() ; +// virtual void recHitsV(std::vector & ); //vector of weights std::vector const & weights() const {return theWeights;} @@ -45,14 +50,28 @@ class SiTrackerMultiRecHit : public BaseTrackerRecHit //returns the weight for the i component float weight(unsigned int i) const {return theWeights[i];} float & weight(unsigned int i) {return theWeights[i];} + + //get the annealing + virtual double getAnnealingFactor() const { return annealing_; } bool sharesInput(const TrackingRecHit* other, SharedInputType what) const; + +/* virtual ConstRecHitContainer transientHits() const { + ConstRecHitContainer result; + std::vector hits; + recHitsV(hits); + for (auto h : hits) result.push_back(h->cloneSH()); + return result; + } +*/ private: edm::OwnVector theHits; + //ConstRecHitContainer theComponents; + //std::vector theComponents; std::vector theWeights; - + double annealing_; }; diff --git a/DataFormats/TrackerRecHit2D/src/SiTrackerMultiRecHit.cc b/DataFormats/TrackerRecHit2D/src/SiTrackerMultiRecHit.cc index f1ece481d14fa..21f87881c2338 100644 --- a/DataFormats/TrackerRecHit2D/src/SiTrackerMultiRecHit.cc +++ b/DataFormats/TrackerRecHit2D/src/SiTrackerMultiRecHit.cc @@ -5,13 +5,15 @@ using namespace std; using namespace edm; SiTrackerMultiRecHit::SiTrackerMultiRecHit(const LocalPoint& pos, const LocalError& err, GeomDet const & idet, - const std::vector< std::pair >& aHitMap): + const std::vector< std::pair >& aHitMap, double annealing): BaseTrackerRecHit(pos,err, idet,trackerHitRTTI::multi) { for(std::vector >::const_iterator ihit = aHitMap.begin(); ihit != aHitMap.end(); ihit++){ theHits.push_back(ihit->first->clone()); + //theComponents.push_back(*ihit->first->clone()); theWeights.push_back(ihit->second); } + annealing_ = annealing; } @@ -68,3 +70,13 @@ vector SiTrackerMultiRecHit::recHits() { // } return theHits.data(); } + +/* +void TrackingRecHit::recHitsV(std::vector & v) const { + v = recHits(); +} + +void TrackingRecHit::recHitsV(std::vector & v) { + v = recHits(); +} +*/ diff --git a/DataFormats/TrackerRecHit2D/src/classes_def.xml b/DataFormats/TrackerRecHit2D/src/classes_def.xml index 382a328eb9d73..e6f8351caf0aa 100755 --- a/DataFormats/TrackerRecHit2D/src/classes_def.xml +++ b/DataFormats/TrackerRecHit2D/src/classes_def.xml @@ -48,7 +48,8 @@ - + + diff --git a/RecoTracker/SiTrackerMRHTools/interface/GenericProjectedRecHit2D.h b/RecoTracker/SiTrackerMRHTools/interface/GenericProjectedRecHit2D.h index ee384f7fe1a19..6e25e52e252c8 100644 --- a/RecoTracker/SiTrackerMRHTools/interface/GenericProjectedRecHit2D.h +++ b/RecoTracker/SiTrackerMRHTools/interface/GenericProjectedRecHit2D.h @@ -61,7 +61,7 @@ class GenericProjectedRecHit2D : public TransientTrackingRecHit { return RecHitPointer( new GenericProjectedRecHit2D( pos, err, det, originaldet, originalHit, propagator)); } - RecHitPointer clone( const TrajectoryStateOnSurface& ts) const; + RecHitPointer clone( const TrajectoryStateOnSurface& ts, const TransientTrackingRecHitBuilder*) const; private: diff --git a/RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h b/RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h index 665db45e952b1..09aee896ff60b 100644 --- a/RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h +++ b/RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h @@ -12,6 +12,7 @@ #include "DataFormats/GeometryVector/interface/LocalPoint.h" #include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h" #include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h" +#include "RecoTracker/TransientTrackingRecHit/interface/TkClonerImpl.h" #include @@ -65,6 +66,7 @@ class SiTrackerMultiRecHitUpdator{ const std::vector& annealingProgram() const {return theAnnealingProgram;} const std::vector& getAnnealingProgram() const {return theAnnealingProgram;} + private: //Obsolete methods @@ -78,6 +80,7 @@ class SiTrackerMultiRecHitUpdator{ const TrackingRecHitPropagator* theHitPropagator; double theChi2Cut; const std::vector theAnnealingProgram; + TkClonerImpl theHitCloner; }; #endif diff --git a/RecoTracker/SiTrackerMRHTools/src/GenericProjectedRecHit2D.cc b/RecoTracker/SiTrackerMRHTools/src/GenericProjectedRecHit2D.cc index 4fd21dad90694..d34bc07949113 100644 --- a/RecoTracker/SiTrackerMRHTools/src/GenericProjectedRecHit2D.cc +++ b/RecoTracker/SiTrackerMRHTools/src/GenericProjectedRecHit2D.cc @@ -9,7 +9,7 @@ GenericProjectedRecHit2D::GenericProjectedRecHit2D( const LocalPoint& pos, const const GeomDet* det, const GeomDet* originalDet, const TransientTrackingRecHit::ConstRecHitPointer originalHit, const TrackingRecHitPropagator* propagator) : - TransientTrackingRecHit( det, originalHit->weight(), originalHit->getAnnealingFactor()) + TrackingRecHit( *det ) //, originalHit->weight(), originalHit->getAnnealingFactor()) { theOriginalDet = originalDet; thePropagator = propagator; @@ -29,8 +29,8 @@ AlgebraicVector GenericProjectedRecHit2D::parameters() const{ } TransientTrackingRecHit::RecHitPointer -GenericProjectedRecHit2D::clone( const TrajectoryStateOnSurface& ts) const +GenericProjectedRecHit2D::clone( const TrajectoryStateOnSurface& ts, const TransientTrackingRecHitBuilder* builder) const { - return thePropagator->project(theOriginalTransientHit, *det(), ts); + return thePropagator->project(theOriginalTransientHit, *det(), ts, builder); } diff --git a/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc b/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc index 147059db10779..f0a2690de4269 100644 --- a/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc +++ b/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc @@ -3,8 +3,9 @@ #include "RecoTracker/SiTrackerMRHTools/interface/GenericProjectedRecHit2D.h" #include "DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h" #include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h" +#include "RecoTracker/TransientTrackingRecHit/interface/TkTransientTrackingRecHitBuilder.h" +//#include "RecoTracker/TransientTrackingRecHit/interface/TkClonerImpl.h" #include "TrackingTools/TransientTrackingRecHit/interface/TrackingRecHitProjector.h" -#include "TrackingTools/TransientTrackingRecHit/interface/InvalidTransientRecHit.h" #include "DataFormats/TrackingRecHit/interface/KfComponentsHolder.h" #include "DataFormats/Math/interface/invertPosDefMatrix.h" #include "DataFormats/Math/interface/ProjectMatrix.h" @@ -17,12 +18,15 @@ SiTrackerMultiRecHitUpdator::SiTrackerMultiRecHitUpdator(const TransientTracking theBuilder(builder), theHitPropagator(hitpropagator), theChi2Cut(Chi2Cut), - theAnnealingProgram(anAnnealingProgram){} + theAnnealingProgram(anAnnealingProgram){ + theHitCloner = static_cast(builder)->cloner(); + } TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::buildMultiRecHit(const std::vector& rhv, TrajectoryStateOnSurface tsos, float annealing) const{ + std::cout << " Calling SiTrackerMultiRecHitUpdator::buildMultiRecHit with AnnealingFactor: " << annealing << std::endl; TransientTrackingRecHit::ConstRecHitContainer tcomponents; for (std::vector::const_iterator iter = rhv.begin(); iter != rhv.end(); iter++){ TransientTrackingRecHit::RecHitPointer transient = theBuilder->build(*iter); @@ -35,7 +39,9 @@ TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::buildMultiR TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( TransientTrackingRecHit::ConstRecHitPointer original, TrajectoryStateOnSurface tsos, double annealing) const{ + std::cout << " Calling SiTrackerMultiRecHitUpdator::update with AnnealingFactor: " << annealing << std::endl; LogTrace("SiTrackerMultiRecHitUpdator") << "Calling SiTrackerMultiRecHitUpdator::update with AnnealingFactor: " << annealing; + if (original->isValid()) LogTrace("SiTrackerMultiRecHitUpdator") << "Original Hit position " << original->localPosition() << " original error " << original->parametersError(); @@ -45,10 +51,16 @@ TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( Tran //return original->clone(); throw cms::Exception("SiTrackerMultiRecHitUpdator") << "!!! MultiRecHitUpdator::update(..): tsos NOT valid!!! "; } - + //check if to clone is the right thing - if (original->transientHits().empty()) return original->clone(tsos); - + if(original->isValid()){ + if (original->transientHits().empty()){ + return theHitCloner.makeShared(original,tsos); + } + } else { + return theHitCloner.makeShared(original,tsos); + } + TransientTrackingRecHit::ConstRecHitContainer tcomponents = original->transientHits(); return update(tcomponents, tsos, annealing); } @@ -58,19 +70,21 @@ TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( Tran TrajectoryStateOnSurface tsos, double annealing) const{ - if (tcomponents.empty()){ + std::cout << "Empty components vector passed to SiTrackerMultiRecHitUpdator::update, returning an InvalidTransientRecHit \n"; LogTrace("SiTrackerMultiRecHitUpdator") << "Empty components vector passed to SiTrackerMultiRecHitUpdator::update, returning an InvalidTransientRecHit "; - return InvalidTransientRecHit::build(0); + return std::make_shared(); } if(!tsos.isValid()) { + std::cout<<"SiTrackerMultiRecHitUpdator::update: tsos NOT valid!!!, returning an InvalidTransientRecHit\n"; LogTrace("SiTrackerMultiRecHitUpdator")<<"SiTrackerMultiRecHitUpdator::update: tsos NOT valid!!!, returning an InvalidTransientRecHit"; - return InvalidTransientRecHit::build(0); + return std::make_shared(); } std::vector updatedcomponents; const GeomDet* geomdet = 0; +std::cout << "here2" ; //running on all over the MRH components for (TransientTrackingRecHit::ConstRecHitContainer::const_iterator iter = tcomponents.begin(); iter != tcomponents.end(); iter++){ @@ -92,14 +106,14 @@ TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( Tran //GenericProjectedRecHit2D is used to prepagate if (&((*iter)->det()->surface())!=&(tsos.surface())){ - TransientTrackingRecHit::RecHitPointer cloned = theHitPropagator->project(*iter, *geomdet, tsos); + TransientTrackingRecHit::RecHitPointer cloned = theHitPropagator->project(*iter, *geomdet, tsos, theBuilder); //if it is used a sensor by sensor grouping this should not appear LogTrace("SiTrackerMultiRecHitUpdator") << "hit propagated"; if (cloned->isValid()) updatedcomponents.push_back(cloned); } else { - TransientTrackingRecHit::RecHitPointer cloned = (*iter)->clone(tsos); + TransientTrackingRecHit::RecHitPointer cloned = theHitCloner.makeShared(*iter,tsos); if (cloned->isValid()){ updatedcomponents.push_back(cloned); LogTrace("SiTrackerMultiRecHitUpdator") << "hit cloned"; @@ -134,31 +148,30 @@ TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( Tran //ORCA: float p = ((mymap[counter].second)/total_sum > 0.01 ? (mymap[counter].second)/total_sum : 1.e-6); normmap.push_back(std::pair(mymap[counter].first, p)); - //storing the weight in the component TransientTrackingRecHit - (*ihit)->setWeight(p); - (*ihit)->setAnnealingFactor(annealing); - finalcomponents.push_back(*ihit); - LogTrace("SiTrackerMultiRecHitUpdator")<< "Component hit type " << typeid(*mymap[counter].first).name() + LogTrace("SiTrackerMultiRecHitUpdator")<< " Component hit type " << typeid(*mymap[counter].first).name() << " position " << mymap[counter].first->localPosition() << " error " << mymap[counter].first->localPositionError() << " with weight " << p; + std::cout << " Component hit type " << typeid(*mymap[counter].first).name() + << " position " << mymap[counter].first->localPosition() + << " \n\terror " << mymap[counter].first->localPositionError() + << " with weight " << p << std::endl; counter++; } - //mymap = normmap; SiTrackerMultiRecHitUpdator::LocalParameters param = calcParameters(tsos, finalcomponents); - //CMSSW531 constructor: - //SiTrackerMultiRecHit updated(param.first, param.second, normmap.front().first->>geographicalId(), normmap); - - SiTrackerMultiRecHit updated(param.first, param.second, *normmap.front().first->det(), normmap); + SiTrackerMultiRecHit updated(param.first, param.second, *normmap.front().first->det(), normmap, annealing); + std::cout << " Updated Hit position " << updated.localPosition() + << " updated error " << updated.localPositionError() << std::endl; LogTrace("SiTrackerMultiRecHitUpdator") << " Updated Hit position " << updated.localPosition() << " updated error " << updated.localPositionError() << std::endl; - return TSiTrackerMultiRecHit::build(geomdet, &updated, finalcomponents, annealing); - + //return TSiTrackerMultiRecHit::build(geomdet, &updated, finalcomponents, annealing); + //return SiTrackerMultiRecHit::build(param.first, param.second, *normmap.front().first->det(), normmap); + return std::make_shared(param.first, param.second, *normmap.front().first->det(), normmap, annealing); } diff --git a/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc b/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc index 20f6c3add8f15..631f9b8444c17 100644 --- a/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc +++ b/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc @@ -3,7 +3,7 @@ #include "RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h" #include "TrackingTools/DetLayers/interface/MeasurementEstimator.h" #include "TrackingTools/PatternTools/interface/Trajectory.h" -#include "TrackingTools/TransientTrackingRecHit/interface/InvalidTransientRecHit.h" +#include "DataFormats/TrackingRecHit/interface/InvalidTrackingRecHit.h" #include "TrackingTools/MeasurementDet/interface/MeasurementDet.h" #include "RecoTracker/MeasurementDet/interface/MeasurementTrackerEvent.h" @@ -16,7 +16,7 @@ using namespace std; vector SimpleDAFHitCollector::recHits(const Trajectory& traj, const MeasurementTrackerEvent *theMTE) const{ -// std::cout << " Calling SimpleDAFHitCollector::recHits" << std::endl; + std::cout << " Calling SimpleDAFHitCollector::recHits" << std::endl; //WARNING: At the moment the trajectories has the measurements //with reversed sorting after the track smoothing @@ -29,13 +29,13 @@ vector SimpleDAFHitCollector::recHits(const Trajectory& t for(vector::const_iterator itrajmeas = meas.begin(); itrajmeas < meas.end(); itrajmeas++) { if (itrajmeas->recHit()->isValid()){ -// std::cout << " Valid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() -// << " local position " << itrajmeas->recHit()->hit()->localPosition() -// << " global position " << itrajmeas->recHit()->hit()->globalPosition() << "\n"; + std::cout << " Valid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() + << " local position " << itrajmeas->recHit()->hit()->localPosition() + << " global position " << itrajmeas->recHit()->hit()->globalPosition() << "\n"; LogTrace("MultiRecHitCollector") << "Valid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() << " local position " << itrajmeas->recHit()->hit()->localPosition(); } else { -// std::cout << " Invalid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() << std::endl; + std::cout << " Invalid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() << std::endl; LogTrace("MultiRecHitCollector") << "Invalid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId(); } } @@ -64,12 +64,12 @@ vector SimpleDAFHitCollector::recHits(const Trajectory& t } //collected hits compatible with the itrajmeas if( measDet.measurements(current, *(getEstimator()), tmps)){ -// std::cout << " Found " << tmps.size() << " compatible measurements." << std::endl; + std::cout << " Found " << tmps.size() << " compatible measurements." << std::endl; for (std::size_t i=0; i!=tmps.size(); ++i){ DetId idtemps = tmps.hits[i]->geographicalId(); if( idtemps == id && tmps.hits[i]->hit()->isValid() ) { -// std::cout << " This hit is valid and has " << idtemps << " DetId."<< std::endl; + std::cout << " This hit is valid and has " << idtemps << " DetId."<< std::endl; LogTrace("MultiRecHitCollector") << "This hit is valid "; hits.push_back(tmps.hits[i]->hit()); } @@ -77,35 +77,36 @@ vector SimpleDAFHitCollector::recHits(const Trajectory& t //I will keep the Invalid hit, IF this is not the first one if (hits.empty()){ -// std::cout << " No valid hits found in current group.\n "; + std::cout << " No valid hits found in current group.\n "; LogTrace("MultiRecHitCollector") << "No valid hits found in current group "; if( result.empty() ) continue; result.push_back(TrajectoryMeasurement(state, - InvalidTransientRecHit::build(&measDet.mdet().geomDet()))); + std::make_shared(measDet.mdet().geomDet(), TrackingRecHit::missing))); } else { //measurements in groups are sorted with increating chi2 //sort( *hits.begin(), *hits.end(), TrajMeasLessEstim()); -// std::cout << " Found " << hits.size() << " valid hits for this sensor.\n"; + std::cout << " Found " << hits.size() << " valid hits for this sensor.\n"; LogTrace("MultiRecHitCollector") << "Found " << hits.size() << " hits for this sensor"; //building a MultiRecHit out of each sensor group result.push_back(TrajectoryMeasurement(state,theUpdator->buildMultiRecHit(hits, state))); } } else { -// std::cout << " No measurements found in current group.\n "; + std::cout << " No measurements found in current group.\n "; LogTrace("MultiRecHitCollector") << "No valid hits found in current group "; if( result.empty() ) continue; result.push_back(TrajectoryMeasurement(state, - InvalidTransientRecHit::build(&measDet.mdet().geomDet()))); + std::make_shared(measDet.mdet().geomDet(), TrackingRecHit::missing))); + } } -// std::cout << " Ending SimpleDAFHitCollector::recHits >> " << result.size() << std::endl; + std::cout << " Ending SimpleDAFHitCollector::recHits >> " << result.size() << std::endl; LogTrace("MultiRecHitCollector") << "Original Measurement size " << meas.size() << " GroupedDAFHitCollector returned " << result.size() << " measurements"; //adding a protection against too few hits and invalid hits diff --git a/RecoTracker/TrackProducer/interface/DAFTrackProducerAlgorithm.h b/RecoTracker/TrackProducer/interface/DAFTrackProducerAlgorithm.h index 19f6a6013b221..b21e9058da910 100644 --- a/RecoTracker/TrackProducer/interface/DAFTrackProducerAlgorithm.h +++ b/RecoTracker/TrackProducer/interface/DAFTrackProducerAlgorithm.h @@ -84,12 +84,13 @@ class DAFTrackProducerAlgorithm { //removes from the trajectory isolated hits with very low weight void filter(const TrajectoryFitter* fitter, std::vector& input, - int minhits, std::vector& output) const; + int minhits, std::vector& output, + const TransientTrackingRecHitBuilder* builder) const; int checkHits( Trajectory iInitTraj, const Trajectory iFinalTraj) const; edm::ParameterSet conf_; - + }; #endif diff --git a/RecoTracker/TrackProducer/plugins/DAFTrackProducer.cc b/RecoTracker/TrackProducer/plugins/DAFTrackProducer.cc index e24ccb2cbaf0c..408ca4442f5e2 100644 --- a/RecoTracker/TrackProducer/plugins/DAFTrackProducer.cc +++ b/RecoTracker/TrackProducer/plugins/DAFTrackProducer.cc @@ -95,9 +95,9 @@ void DAFTrackProducer::produce(edm::Event& theEvent, const edm::EventSetup& setu } //put everything in the event - putInEvt(theEvent, thePropagator.product(), theMeasTk.product(), outputRHColl, - outputTColl, outputTEColl, - outputTrajectoryColl, algoResults); + putInEvt(theEvent, thePropagator.product(),theMeasTk.product(), + outputRHColl, outputTColl, outputTEColl, + outputTrajectoryColl, algoResults, theBuilder.product()); putInEvtTrajAnn(theEvent, trajannResults, outputTrajAnnColl); // std::cout << "DAFTrackProducer: end the DAF algorithm." << "\n"; diff --git a/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc b/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc index 040af6803afb8..f4ee29080500b 100644 --- a/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc +++ b/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc @@ -1,5 +1,7 @@ #include "DataFormats/TrackCandidate/interface/TrackCandidate.h" #include "DataFormats/TrackingRecHit/interface/TrackingRecHitFwd.h" +#include "DataFormats/TrackingRecHit/interface/InvalidTrackingRecHit.h" +#include "RecoTracker/TransientTrackingRecHit/interface/TkTransientTrackingRecHitBuilder.h" #include "DataFormats/TrackReco/interface/Track.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" #include "Geometry/CommonDetUnit/interface/TrackingGeometry.h" @@ -11,12 +13,12 @@ #include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h" #include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h" #include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h" -#include "TrackingTools/TransientTrackingRecHit/interface/InvalidTransientRecHit.h" +#include "RecoTracker/TransientTrackingRecHit/interface/TkClonerImpl.h" #include "TrackingTools/PatternTools/interface/TSCBLBuilderNoMaterial.h" #include "TrackingTools/PatternTools/interface/TransverseImpactPointExtrapolator.h" #include "TrackingTools/TrackFitters/interface/TrajectoryStateWithArbitraryError.h" #include "RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h" - +#include "DataFormats/TrackerRecHit2D/interface/TkCloner.h" #include "TrackingTools/PatternTools/interface/TrajAnnealing.h" void DAFTrackProducerAlgorithm::runWithCandidate(const TrackingGeometry * theG, @@ -31,6 +33,8 @@ void DAFTrackProducerAlgorithm::runWithCandidate(const TrackingGeometry * theG, AlgoProductCollection& algoResults, TrajAnnealingCollection& trajann) const { + std::cout << "////////////////////////////////////////////////////////\n" + << "DAFTrackProducerAlgorithm::runWithCandidate: Number of Trajectories: " << theTrajectoryCollection.size() << "\n"; edm::LogInfo("TrackProducer") << "Number of Trajectories: " << theTrajectoryCollection.size() << "\n"; int cont = 0; @@ -57,6 +61,7 @@ void DAFTrackProducerAlgorithm::runWithCandidate(const TrackingGeometry * theG, for (std::vector::const_iterator ian = updator->getAnnealingProgram().begin(); ian != updator->getAnnealingProgram().end(); ian++){ +std::cout << "Starting with the annealing " << *ian << std::endl; if (currentTraj.isValid()){ LogDebug("DAFTrackProducerAlgorithm") << "Seed direction is " << currentTraj.seed().direction() @@ -90,7 +95,7 @@ void DAFTrackProducerAlgorithm::runWithCandidate(const TrackingGeometry * theG, //in order to remove tracks with too many outliers. //std::vector filtered; - //filter(theFitter, vtraj, conf_.getParameter("MinHits"), filtered); + //filter(theFitter, vtraj, conf_.getParameter("MinHits"), filtered, builder); if(currentTraj.foundHits() >= conf_.getParameter("MinHits")) { @@ -179,7 +184,7 @@ Trajectory DAFTrackProducerAlgorithm::fit(const std::pairfitOne(TrajectorySeed(PTrajectoryStateOnDet(), BasicTrajectorySeed::recHitContainer(), @@ -245,32 +250,37 @@ bool DAFTrackProducerAlgorithm::buildTrack (const Trajectory vtraj, } /*------------------------------------------------------------------------------------------------------*/ void DAFTrackProducerAlgorithm::filter(const TrajectoryFitter* fitter, std::vector& input, - int minhits, std::vector& output) const + int minhits, std::vector& output, + const TransientTrackingRecHitBuilder* builder) const { - if (input.empty()) return; - - int ngoodhits = 0; + if (input.empty()) return; - std::vector vtm = input[0].measurements(); - - TransientTrackingRecHit::RecHitContainer hits; + int ngoodhits = 0; + std::vector vtm = input[0].measurements(); + TransientTrackingRecHit::RecHitContainer hits; - //count the number of non-outlier and non-invalid hits - for (std::vector::reverse_iterator tm=vtm.rbegin(); tm!=vtm.rend();tm++){ - //if the rechit is valid - if (tm->recHit()->isValid()) { - TransientTrackingRecHit::ConstRecHitContainer components = tm->recHit()->transientHits(); - bool isGood = false; - for (TransientTrackingRecHit::ConstRecHitContainer::iterator rechit = components.begin(); rechit != components.end(); rechit++){ - //if there is at least one component with weight higher than 1e-6 then the hit is not an outlier - if ((*rechit)->weight()>1e-6) {ngoodhits++; isGood = true; break;} - } - if (isGood) hits.push_back(tm->recHit()->clone(tm->updatedState())); - else hits.push_back(InvalidTransientRecHit::build(tm->recHit()->det(), TrackingRecHit::missing)); - } else { - hits.push_back(tm->recHit()->clone(tm->updatedState())); - } - } + //count the number of non-outlier and non-invalid hits + for (std::vector::reverse_iterator tm=vtm.rbegin(); tm!=vtm.rend();tm++){ + //if the rechit is valid + if (tm->recHit()->isValid()) { + TransientTrackingRecHit::ConstRecHitContainer components = tm->recHit()->transientHits(); + bool isGood = false; + for (TransientTrackingRecHit::ConstRecHitContainer::iterator rechit = components.begin(); rechit != components.end(); rechit++){ + //if there is at least one component with weight higher than 1e-6 then the hit is not an outlier + if ((*rechit)->weight()>1e-6) {ngoodhits++; isGood = true; break;} + } + if (isGood) { + TkClonerImpl hc = static_cast(builder)->cloner(); + auto tempHit = hc.makeShared(tm->recHit(),tm->updatedState()); + hits.push_back(tempHit); + } + else hits.push_back(std::make_shared(*tm->recHit()->det(), TrackingRecHit::missing)); + } else { + TkClonerImpl hc = static_cast(builder)->cloner(); + auto tempHit = hc.makeShared(tm->recHit(),tm->updatedState()); + hits.push_back(tempHit); + } + } LogDebug("DAFTrackProducerAlgorithm") << "Original number of valid hits " << input[0].foundHits() << "; after filtering " << ngoodhits; diff --git a/RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h b/RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h index 1ece4d2d53f1b..6164bca9102c2 100644 --- a/RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h +++ b/RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h @@ -46,17 +46,17 @@ class TSiTrackerMultiRecHit GCC11_FINAL : public TValidTrackingRecHit { /// interface needed to set and read back an annealing value that has been applied to the current hit error matrix when /// using it as a component for a composite rec hit (useful for the DAF) - void setAnnealingFactor(float annealing) {annealing_ = annealing;} - float getAnnealingFactor() const {return annealing_;} +// void setAnnealingFactor(float annealing) {annealing_ = annealing;} +// float getAnnealingFactor() const {return annealing_;} //vector of weights - std::vector const & weights() const {return theHitData.weights();} - std::vector & weights() {return theHitData.weights();} +// std::vector const & weights() const {return theHitData.weights();} +// std::vector & weights() {return theHitData.weights();} //returns the weight for the i component - float weight(unsigned int i) const {return theHitData.weight(i);} - float & weight(unsigned int i) {return theHitData.weight(i);} +// float weight(unsigned int i) const {return theHitData.weight(i);} +// float & weight(unsigned int i) {return theHitData.weight(i);} virtual const GeomDetUnit* detUnit() const; @@ -65,7 +65,7 @@ class TSiTrackerMultiRecHit GCC11_FINAL : public TValidTrackingRecHit { virtual RecHitPointer clone(const TrajectoryStateOnSurface& ts) const; - virtual ConstRecHitContainer transientHits() const {return theComponents;}; +// virtual ConstRecHitContainer transientHits() const {return theComponents;}; static RecHitPointer build( const GeomDet * geom, const SiTrackerMultiRecHit* rh, const ConstRecHitContainer& components, float annealing=1.){ diff --git a/TrackingTools/KalmanUpdators/interface/TrackingRecHitPropagator.h b/TrackingTools/KalmanUpdators/interface/TrackingRecHitPropagator.h index 7e080291469a2..536d9da400f86 100644 --- a/TrackingTools/KalmanUpdators/interface/TrackingRecHitPropagator.h +++ b/TrackingTools/KalmanUpdators/interface/TrackingRecHitPropagator.h @@ -1,12 +1,16 @@ #ifndef TrackingTools_TrackingRecHitPropagator_h #define TrackingTools_TrackingRecHitPropagator_h +#include "DataFormats/TrackingRecHit/interface/InvalidTrackingRecHit.h" +#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h" +#include "RecoTracker/TransientTrackingRecHit/interface/TkTransientTrackingRecHitBuilder.h" +#include "RecoTracker/TransientTrackingRecHit/interface/TkClonerImpl.h" + #include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h" #include "TrackingTools/KalmanUpdators/interface/TrackingRecHitPropagator.h" #include "TrackingTools/GeomPropagators/interface/AnalyticalPropagator.h" #include "MagneticField/Engine/interface/MagneticField.h" #include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h" -#include "TrackingTools/TransientTrackingRecHit/interface/InvalidTransientRecHit.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" @@ -23,25 +27,29 @@ class TrackingRecHitPropagator { ~TrackingRecHitPropagator() {delete thePropagator;} - /* + template TrackingRecHit::RecHitPointer project(const TrackingRecHit::ConstRecHitPointer hit, const GeomDet& det, - const TrajectoryStateOnSurface ts) const{ + const TrajectoryStateOnSurface ts, + const TransientTrackingRecHitBuilder* builder) const{ + + TkClonerImpl hc = static_cast(builder)->cloner(); + //1) propagate the best possible track parameters to the surface of the hit you want to "move" using a AnalyticalPropagator ; //2) create LocalTrajectoryParameters with the local x,y of the hit and direction + momentum from the propagated track parameters; //3) create a LocalTrajectoryError matrix which is 0 except for the local x,y submatrix, which is filled with the hit errors; //4) create a TSOS from the result of 2) and 3) and propagate it to the reference surface; //5) create a new hit with the local x,y subspace of the result of 4) - if (!ts.isValid()) return InvalidTransientRecHit::build(hit->det()); + if (!ts.isValid()) return std::make_shared(*hit->det(), TrackingRecHit::missing); // LogTrace("SiTrackerMultiRecHitUpdator") << "the tsos is valid"; //check if the ts lays or not on the destination surface and in case propagate it TrajectoryStateOnSurface propagated =ts; if (hit->surface() != &(ts.surface())) propagated = thePropagator->propagate(ts, *(hit->surface())); - if (!propagated.isValid()) return InvalidTransientRecHit::build(hit->det()); + if (!propagated.isValid()) return std::make_shared(*hit->det(), TrackingRecHit::missing); // LogTrace("SiTrackerMultiRecHitUpdator") << "the propagate tsos is valid"; // LogTrace("SiTrackerMultiRecHitUpdator") << "Original: position: "<parameters()<<" error: "<parametersError()<clone(propagated); + TrackingRecHit::RecHitPointer updatedOriginal = hc.makeShared(hit,propagated); // LogTrace("SiTrackerMultiRecHitUpdator") << "New: position: "<parameters()<<" error: "<parametersError()<propagate(hit_state, det.surface()); - if (!projected_hit_state.isValid()) return InvalidTransientRecHit::build(hit->det()); + if (!projected_hit_state.isValid()) return std::make_shared(*hit->det(), TrackingRecHit::missing); LocalPoint p = projected_hit_state.localPosition(); LocalError e = projected_hit_state.localError().positionError(); // LogTrace("SiTrackerMultiRecHitUpdator") << "position: "<det(), updatedOriginal, this); } - */ + private: const AnalyticalPropagator* thePropagator; }; diff --git a/TrackingTools/KalmanUpdators/src/MRHChi2MeasurementEstimator.cc b/TrackingTools/KalmanUpdators/src/MRHChi2MeasurementEstimator.cc index 42c0193e97c63..c1bfed9c602a0 100644 --- a/TrackingTools/KalmanUpdators/src/MRHChi2MeasurementEstimator.cc +++ b/TrackingTools/KalmanUpdators/src/MRHChi2MeasurementEstimator.cc @@ -1,4 +1,6 @@ #include "RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h" +#include "DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h" +#include "RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h" #include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h" #include "TrackingTools/KalmanUpdators/interface/MRHChi2MeasurementEstimator.h" #include "TrackingTools/PatternTools/interface/MeasurementExtractor.h" @@ -27,14 +29,17 @@ std::pair MRHChi2MeasurementEstimator::estimate(const TrajectorySt template std::pair MRHChi2MeasurementEstimator::estimate(const TrajectoryStateOnSurface& tsos, const TrackingRecHit& aRecHit) const { - - TSiTrackerMultiRecHit const & mHit = dynamic_cast(aRecHit); + +std::cout << " MRHChi2MeasurementEstimator::estimate " << std::endl; + SiTrackerMultiRecHit const & mHit = dynamic_cast(aRecHit); double est=0; double annealing = mHit.getAnnealingFactor(); + std::cout << " Current annealing factor is " << annealing; LogDebug("MRHChi2MeasurementEstimator") << "Current annealing factor is " << annealing; TransientTrackingRecHit::ConstRecHitContainer components = mHit.transientHits(); + std::cout << "; this hit has " << components.size() << " components\n"; LogDebug("MRHChi2MeasurementEstimator") << "this hit has " << components.size() << " components"; for (TransientTrackingRecHit::ConstRecHitContainer::const_iterator iter = components.begin(); iter != components.end(); iter++){ @@ -59,6 +64,7 @@ std::pair MRHChi2MeasurementEstimator::estimate(const TrajectorySt edm::LogError("SiTrackerMultiRecHitUpdator")<<"SiTrackerMultiRecHitUpdator::ComputeParameters2dim: W not valid!"<weight() << std::endl; LogDebug("MRHChi2MeasurementEstimator") << "Hit with weight " << (*iter)->weight(); est += ROOT::Math::Similarity(r, V)*((*iter)->weight()); } diff --git a/TrackingTools/PatternTools/interface/TrajAnnealing.h b/TrackingTools/PatternTools/interface/TrajAnnealing.h index 60f7d03a29638..10fa200ecd65e 100644 --- a/TrackingTools/PatternTools/interface/TrajAnnealing.h +++ b/TrackingTools/PatternTools/interface/TrajAnnealing.h @@ -36,7 +36,7 @@ class TrajAnnealing Trajectory traj_; float annealing_; std::vector theWeights; - TransientTrackingRecHit::RecHitContainer theHits_; + TrackingRecHit::RecHitContainer theHits_; std::pair > getAnnealingWeight( const TrackingRecHit& aRecHit ) const ; }; diff --git a/TrackingTools/PatternTools/src/TrajAnnealing.cc b/TrackingTools/PatternTools/src/TrajAnnealing.cc index e326133729d5a..efb8f1a6af979 100644 --- a/TrackingTools/PatternTools/src/TrajAnnealing.cc +++ b/TrackingTools/PatternTools/src/TrajAnnealing.cc @@ -63,7 +63,8 @@ std::pair > TrajAnnealing::getAnnealingWeight( const T return make_pair(0.0,dumpyVec); } - TSiTrackerMultiRecHit const & mHit = dynamic_cast(aRecHit); + SiTrackerMultiRecHit const & mHit = dynamic_cast(aRecHit); + //TSiTrackerMultiRecHit const & mHit = dynamic_cast(aRecHit); return make_pair(mHit.getAnnealingFactor(), mHit.weights()); } diff --git a/TrackingTools/TrackFitters/src/KFTrajectoryFitter.cc b/TrackingTools/TrackFitters/src/KFTrajectoryFitter.cc index 8ae86efaea1bc..405fd7849b231 100644 --- a/TrackingTools/TrackFitters/src/KFTrajectoryFitter.cc +++ b/TrackingTools/TrackFitters/src/KFTrajectoryFitter.cc @@ -237,24 +237,13 @@ Trajectory KFTrajectoryFitter::fitOne(const TrajectorySeed& aSeed, if ((*ihit)->det()) myTraj.push(TM(predTsos, *ihit,0,theGeometry->idToLayer((*ihit)->geographicalId()) )); else myTraj.push(TM(predTsos, *ihit,0)); } -<<<<<<< HEAD - -======= - ->>>>>>> ebrondol/MyNewBranchDAF LogTrace("TrackFitters") << "predTsos !" << "\n" << predTsos << "\n" <<"currTsos !" << "\n" << currTsos; -<<<<<<< HEAD } -======= - - } - ->>>>>>> ebrondol/MyNewBranchDAF LogDebug("TrackFitters") << "Found 1 trajectory with " << myTraj.foundHits() << " valid hits\n"; return ret; From 0079f68c3de2796539a452f094e591516f10edf9 Mon Sep 17 00:00:00 2001 From: erica brondolin Date: Wed, 11 Jun 2014 11:29:55 +0200 Subject: [PATCH 03/16] Fix DAF problems --- .gitignore | 2 + .../DAFValidator/macro/PlotComparisonMaker.C | 22 +- ...rackValidator_DAFValidator_SingleMu_cfg.py | 20 +- ...tiTrackValidator_DAFValidator_TTbar_cfg.py | 17 +- .../test/MultiTrackValidator_SingleMu_cfg.py | 14 +- .../test/MultiTrackValidator_TTbar_cfg.py | 10 +- .../interface/SiTrackerMultiRecHit.h | 10 - .../src/SiTrackerMultiRecHit.cc | 1 - .../interface/GroupedDAFHitCollector.h | 4 +- .../interface/SiTrackerMultiRecHitUpdator.h | 12 +- .../interface/SimpleDAFHitCollector.h | 4 +- .../src/GroupedDAFHitCollector.cc | 1 - .../src/SiTrackerMultiRecHitUpdator.cc | 24 +- .../src/SiTrackerMultiRecHitUpdator.cc~ | 240 ------------------ .../src/SimpleDAFHitCollector.cc | 2 - .../test/DAFRecoTrack_cfg.py | 8 +- .../interface/DAFTrackProducerAlgorithm.h | 3 +- .../TrackProducer/plugins/DAFTrackProducer.cc | 4 +- .../TrackProducer/plugins/DAFTrackProducer.h | 1 + .../python/CTFFinalFitWithMaterialDAF_cfi.py | 3 +- .../src/DAFTrackProducerAlgorithm.cc | 34 ++- .../interface/TSiTrackerMultiRecHit.h | 94 ------- .../src/TSiTrackerMultiRecHit.cc | 36 --- .../src/MRHChi2MeasurementEstimator.cc | 16 +- .../PatternTools/src/TrajAnnealing.cc | 44 ++-- 25 files changed, 130 insertions(+), 496 deletions(-) delete mode 100644 RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc~ delete mode 100644 RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h delete mode 100644 RecoTracker/TransientTrackingRecHit/src/TSiTrackerMultiRecHit.cc diff --git a/.gitignore b/.gitignore index 1a38d6227329c..9095823924977 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,4 @@ __init__.py *.pyc +*.root +*.txt diff --git a/DAFTest/DAFValidator/macro/PlotComparisonMaker.C b/DAFTest/DAFValidator/macro/PlotComparisonMaker.C index fd01f11eacfb6..d0dfaec385281 100644 --- a/DAFTest/DAFValidator/macro/PlotComparisonMaker.C +++ b/DAFTest/DAFValidator/macro/PlotComparisonMaker.C @@ -5,16 +5,12 @@ #include -std::string folderName = "/afs/cern.ch/user/e/ebrondol/CMSSWarea/CMSSW_7_1_0_pre5/src/DAFTest/DAFValidator/"; -std::string FileName1 = "multiprova.root"; -std::string FileName2 = "multiprova.root"; -//std::string FileName1 = "multitrackvalidator_SingleMuPt10_100evts_AllAssociators.root"; -//std::string FileName2 = "multitrackvalidator_DAF_SingleMuPt10_100evts_v3_AllAssociators.root"; -//std::string FileName1 = "multitrackvalidator_TTbar_10evts_AllAssociators.root"; -//std::string FileName2 = "multitrackvalidator_DAF_TTbar_10evts_v3_AllAssociators.root"; -std::string baseFolderRootName = "DQMData/Tracking/Track/"; -//std::string Associator = "quickAssociatorByHits"; -std::string Associator = "AssociatorByChi2"; +std::string folderName = "/afs/cern.ch/user/e/ebrondol/CMSSWarea/CMSSW_7_1_0_pre8/src/"; +std::string FileName1 = "DQM_V0001_R000000001__TTbar__Normal__10evts.root"; +std::string FileName2 = "DQM_V0001_R000000001__TTbar__DAF__10evs.root"; +std::string baseFolderRootName = "DQMData/Run 1/Tracking/Run summary/Track/"; +std::string Associator = "quickAssociatorByHits"; +//std::string Associator = "AssociatorByChi2"; //std::string Associator = "AssociatorByPull"; std::string MultivalLabelTracks1 = "cutsReco"; std::string MultivalLabelTracks2 = "ctfWithMaterialDAF"; @@ -43,8 +39,10 @@ void PlotComparisonMaker(const char* HistoName) std::cout << "InputRootFile1: " << FolderRootName1 << std::endl; std::cout << "InputRootFile2: " << FolderRootName2 << std::endl; - TH1F* histo1 = (TH1F*)( f1->Get((FolderRootName1+HistoName).c_str()) ); - TH1F* histo2 = (TH1F*)( f2->Get((FolderRootName2+HistoName).c_str()) ); +// TH1F* histo1 = (TH1F*)( f1->Get((FolderRootName1+HistoName).c_str()) ); +// TH1F* histo2 = (TH1F*)( f2->Get((FolderRootName2+HistoName).c_str()) ); + TH1F* histo1 = (TH1F*)( f1->FindObjectAny("effic")); + TH1F* histo2 = (TH1F*)( f2->FindObjectAny("effic")); TCanvas* c1 = new TCanvas(); c1 -> cd(); diff --git a/DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_SingleMu_cfg.py b/DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_SingleMu_cfg.py index 0c08466759a84..36b0e25c3d272 100644 --- a/DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_SingleMu_cfg.py +++ b/DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_SingleMu_cfg.py @@ -28,7 +28,7 @@ process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") #from Configuration.AlCa.GlobalTag import GlobalTag #process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:startup', '') -process.GlobalTag.globaltag = 'POSTLS171_V1::All' +process.GlobalTag.globaltag = 'START71_V1::All'#POSTLS171_V1::All' ### standard includes process.load('Configuration/StandardSequences/Services_cff') @@ -39,7 +39,7 @@ process.load("Configuration.StandardSequences.MagneticField_cff") ## includes for DAF -import RecoTracker.CkfPattern.CkfTrajectoryBuilderESProducer_cfi +import RecoTracker.CkfPattern.CkfTrajectoryBuilder_cfi import TrackingTools.TrajectoryCleaning.TrajectoryCleanerBySharedSeeds_cfi process.load("RecoTracker.TrackProducer.TrackRefitters_cff") @@ -54,6 +54,7 @@ from RecoTracker.FinalTrackSelectors.TracksWithQuality_cff import * process.ctfWithMaterialTracksDAF.TrajectoryInEvent = True process.ctfWithMaterialTracksDAF.src = 'TrackRefitter' +process.ctfWithMaterialTracksDAF.TrajAnnealingSaving = True process.MRHFittingSmoother.EstimateCut = -1 process.MRHFittingSmoother.MinNumberOfHits = 3 @@ -70,6 +71,7 @@ process.load("Validation.RecoTrack.cuts_cff") process.load("Validation.RecoTrack.MultiTrackValidator_cff") process.load("DQMServices.Components.EDMtoMEConverter_cff") +process.load("DQMServices.Components.DQMFileSaver_cfi") process.load("Validation.Configuration.postValidation_cff") process.quickTrackAssociatorByHits.SimToRecoDenominator = cms.string('reco') @@ -81,8 +83,8 @@ ComponentName = 'TrackAssociatorByPull') ########### configuration MultiTrackValidator ######## -process.multiTrackValidator.outputFile = 'multiprova.root'#multitrackvalidator_DAF_SingleMuPt10_100evts_v3_AssocByPull.root' -#process.multiTrackValidator.associators = ['quickTrackAssociatorByHits'] +process.dqmSaver.workflow = cms.untracked.string("/SingleMu/DAF/100evs") +#process.multiTrackValidator.outputFile = 'multitrackvalidator_DAF_SingleMuPt10_100evts_AllAssociators.root' process.multiTrackValidator.associators = ['quickTrackAssociatorByHits','TrackAssociatorByChi2','TrackAssociatorByPull'] process.multiTrackValidator.skipHistoFit=cms.untracked.bool(False) process.multiTrackValidator.label = ['ctfWithMaterialTracksDAF'] @@ -106,21 +108,25 @@ ) process.TFileService = cms.Service("TFileService", - fileName = cms.string('prova.root')#DAFValidator_SingleMuPt10_100evts_v3_TrackAssocByPull.root') + fileName = cms.string('DAFValidator_SingleMuPt10_100evts_AllAssociators.root') ) +process.outputFile = cms.EndPath(process.dqmSaver) + process.validation = cms.Sequence( # process.tpClusterProducer * ##it does not compile with DAF::why? - process.multiTrackValidator + process.multiTrackValidator ) # paths process.p = cms.Path( process.MeasurementTrackerEvent * process.TrackRefitter * process.ctfWithMaterialTracksDAF - #* process.validation + * process.validation * process.demo ) +### sequence of paths to run +process.schedule = cms.Schedule(process.p,process.outputFile) diff --git a/DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_TTbar_cfg.py b/DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_TTbar_cfg.py index 495cced8a7553..5dae78732b2d7 100644 --- a/DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_TTbar_cfg.py +++ b/DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_TTbar_cfg.py @@ -34,7 +34,7 @@ process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") #from Configuration.AlCa.GlobalTag import GlobalTag #process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:startup', '') -process.GlobalTag.globaltag = 'POSTLS171_V1::All' +process.GlobalTag.globaltag = 'START71_V1::All'#POSTLS171_V1::All' ### standard includes process.load('Configuration/StandardSequences/Services_cff') @@ -45,7 +45,7 @@ process.load("Configuration.StandardSequences.MagneticField_cff") ## includes for DAF -import RecoTracker.CkfPattern.CkfTrajectoryBuilderESProducer_cfi +import RecoTracker.CkfPattern.CkfTrajectoryBuilder_cfi import TrackingTools.TrajectoryCleaning.TrajectoryCleanerBySharedSeeds_cfi process.load("RecoTracker.TrackProducer.TrackRefitters_cff") @@ -60,6 +60,7 @@ from RecoTracker.FinalTrackSelectors.TracksWithQuality_cff import * process.ctfWithMaterialTracksDAF.TrajectoryInEvent = True process.ctfWithMaterialTracksDAF.src = 'TrackRefitter' +process.ctfWithMaterialTracksDAF.TrajAnnealingSaving = True process.MRHFittingSmoother.EstimateCut = -1 process.MRHFittingSmoother.MinNumberOfHits = 3 @@ -76,6 +77,7 @@ process.load("Validation.RecoTrack.cuts_cff") process.load("Validation.RecoTrack.MultiTrackValidator_cff") process.load("DQMServices.Components.EDMtoMEConverter_cff") +process.load("DQMServices.Components.DQMFileSaver_cfi") process.load("Validation.Configuration.postValidation_cff") process.quickTrackAssociatorByHits.SimToRecoDenominator = cms.string('reco') @@ -87,7 +89,8 @@ ComponentName = 'TrackAssociatorByPull') ########### configuration MultiTrackValidator ######## -process.multiTrackValidator.outputFile = 'multitrackvalidator_DAF_TTbar_10evts_v3_AssocByPull.root' +process.dqmSaver.workflow = cms.untracked.string("/TTbar/DAF/10evs") +#process.multiTrackValidator.outputFile = 'multitrackvalidator_DAF_TTbar_10evts_AllAssoc.root' process.multiTrackValidator.associators = ['quickTrackAssociatorByHits', 'TrackAssociatorByChi2','TrackAssociatorByPull'] process.multiTrackValidator.skipHistoFit=cms.untracked.bool(False) process.multiTrackValidator.label = ['ctfWithMaterialTracksDAF'] @@ -111,9 +114,11 @@ ) process.TFileService = cms.Service("TFileService", - fileName = cms.string('DAFValidator_TTbar_10evts_v3_TrackAssocByPull.root') + fileName = cms.string('DAFValidator_TTbar_10evts_AllAssoc.root') ) +process.outputFile = cms.EndPath(process.dqmSaver) + process.validation = cms.Sequence( # process.tpClusterProducer * ##it does not compile with DAF::why? process.multiTrackValidator @@ -123,11 +128,11 @@ process.p = cms.Path( process.MeasurementTrackerEvent * process.TrackRefitter * process.ctfWithMaterialTracksDAF - #* process.validation + * process.validation * process.demo ) process.schedule = cms.Schedule( - process.p + process.p, process.outputFile ) diff --git a/DAFTest/DAFValidator/test/MultiTrackValidator_SingleMu_cfg.py b/DAFTest/DAFValidator/test/MultiTrackValidator_SingleMu_cfg.py index eb1ef5859fc44..aa6184127c316 100644 --- a/DAFTest/DAFValidator/test/MultiTrackValidator_SingleMu_cfg.py +++ b/DAFTest/DAFValidator/test/MultiTrackValidator_SingleMu_cfg.py @@ -28,7 +28,7 @@ process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") #from Configuration.AlCa.GlobalTag import GlobalTag #process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:startup', '') -process.GlobalTag.globaltag = 'POSTLS171_V1::All' +process.GlobalTag.globaltag = 'START71_V1::All'#POSTLS171_V1::All' ### standard includes process.load('Configuration/StandardSequences/Services_cff') @@ -44,6 +44,7 @@ process.load("Validation.RecoTrack.cuts_cff") process.load("Validation.RecoTrack.MultiTrackValidator_cff") process.load("DQMServices.Components.EDMtoMEConverter_cff") +process.load("DQMServices.Components.DQMFileSaver_cfi") process.load("Validation.Configuration.postValidation_cff") process.quickTrackAssociatorByHits.SimToRecoDenominator = cms.string('reco') @@ -55,9 +56,9 @@ ComponentName = 'TrackAssociatorByPull') ########### configuration MultiTrackValidator ######## -process.multiTrackValidator.outputFile = 'multitrackvalidator_SingleMuPt10_100evts_AssociatorByPull.root' -#process.multiTrackValidator.associators = ['quickTrackAssociatorByHits'] -process.multiTrackValidator.associators = ['TrackAssociatorByPull'] +process.dqmSaver.workflow = cms.untracked.string("/SingleMu/Normal/100evts") +#process.multiTrackValidator.outputFile = 'multitrackvalidator_SingleMuPt10_100evts_AllAssoc.root' +process.multiTrackValidator.associators = ['quickTrackAssociatorByHits', 'TrackAssociatorByChi2', 'TrackAssociatorByPull'] process.multiTrackValidator.skipHistoFit=cms.untracked.bool(False) process.multiTrackValidator.label = ['cutsRecoTracks'] process.multiTrackValidator.UseAssociators = cms.bool(True) @@ -66,6 +67,9 @@ process.quickTrackAssociatorByHits.useClusterTPAssociation = cms.bool(True) process.load("SimTracker.TrackerHitAssociation.clusterTpAssociationProducer_cfi") +#process.Tracer = cms.Service("Tracer") +process.outputFile = cms.EndPath(process.dqmSaver) + process.validation = cms.Sequence( # process.tpClusterProducer * #associate the hits trought an association map between cluster and tp process.multiTrackValidator @@ -77,7 +81,7 @@ process.validation ) process.schedule = cms.Schedule( - process.p + process.p, process.outputFile ) diff --git a/DAFTest/DAFValidator/test/MultiTrackValidator_TTbar_cfg.py b/DAFTest/DAFValidator/test/MultiTrackValidator_TTbar_cfg.py index 8d62832e7a0b1..b5a93fd1f6e99 100644 --- a/DAFTest/DAFValidator/test/MultiTrackValidator_TTbar_cfg.py +++ b/DAFTest/DAFValidator/test/MultiTrackValidator_TTbar_cfg.py @@ -34,7 +34,7 @@ process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") #from Configuration.AlCa.GlobalTag import GlobalTag #process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:startup', '') -process.GlobalTag.globaltag = 'POSTLS171_V1::All' +process.GlobalTag.globaltag = 'START71_V1::All'#POSTLS171_V1::All' ### standard includes process.load('Configuration/StandardSequences/Services_cff') @@ -50,6 +50,7 @@ process.load("Validation.RecoTrack.cuts_cff") process.load("Validation.RecoTrack.MultiTrackValidator_cff") process.load("DQMServices.Components.EDMtoMEConverter_cff") +process.load("DQMServices.Components.DQMFileSaver_cfi") process.load("Validation.Configuration.postValidation_cff") process.quickTrackAssociatorByHits.SimToRecoDenominator = cms.string('reco') @@ -61,7 +62,8 @@ ComponentName = 'TrackAssociatorByPull') ########### configuration MultiTrackValidator ######## -process.multiTrackValidator.outputFile = 'multitrackvalidator_TTbar_10evts_AssociatorByPull.root' +process.dqmSaver.workflow = cms.untracked.string("/TTbar/Normal/10evts") +#process.multiTrackValidator.outputFile = 'multitrackvalidator_TTbar_10evts_AssociatorByPull.root' process.multiTrackValidator.associators = ['quickTrackAssociatorByHits', 'TrackAssociatorByChi2','TrackAssociatorByPull'] process.multiTrackValidator.skipHistoFit=cms.untracked.bool(False) process.multiTrackValidator.label = ['cutsRecoTracks'] @@ -72,6 +74,8 @@ process.quickTrackAssociatorByHits.useClusterTPAssociation = cms.bool(True) process.load("SimTracker.TrackerHitAssociation.clusterTpAssociationProducer_cfi") +process.outputFile = cms.EndPath(process.dqmSaver) + process.validation = cms.Sequence( # process.tpClusterProducer * #associate the hits trought an association map between cluster and tp process.multiTrackValidator @@ -83,7 +87,7 @@ * process.validation ) process.schedule = cms.Schedule( - process.p + process.p, process.outputFile ) diff --git a/DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h b/DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h index 33b78f4827aac..20565673ef958 100644 --- a/DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h +++ b/DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h @@ -57,19 +57,9 @@ class SiTrackerMultiRecHit : public BaseTrackerRecHit bool sharesInput(const TrackingRecHit* other, SharedInputType what) const; -/* virtual ConstRecHitContainer transientHits() const { - ConstRecHitContainer result; - std::vector hits; - recHitsV(hits); - for (auto h : hits) result.push_back(h->cloneSH()); - return result; - } -*/ private: edm::OwnVector theHits; - //ConstRecHitContainer theComponents; - //std::vector theComponents; std::vector theWeights; double annealing_; diff --git a/DataFormats/TrackerRecHit2D/src/SiTrackerMultiRecHit.cc b/DataFormats/TrackerRecHit2D/src/SiTrackerMultiRecHit.cc index 21f87881c2338..6c0d7afdff491 100644 --- a/DataFormats/TrackerRecHit2D/src/SiTrackerMultiRecHit.cc +++ b/DataFormats/TrackerRecHit2D/src/SiTrackerMultiRecHit.cc @@ -10,7 +10,6 @@ SiTrackerMultiRecHit::SiTrackerMultiRecHit(const LocalPoint& pos, const LocalErr { for(std::vector >::const_iterator ihit = aHitMap.begin(); ihit != aHitMap.end(); ihit++){ theHits.push_back(ihit->first->clone()); - //theComponents.push_back(*ihit->first->clone()); theWeights.push_back(ihit->second); } annealing_ = annealing; diff --git a/RecoTracker/SiTrackerMRHTools/interface/GroupedDAFHitCollector.h b/RecoTracker/SiTrackerMRHTools/interface/GroupedDAFHitCollector.h index f9efc1a0fb019..62a3333de8f16 100644 --- a/RecoTracker/SiTrackerMRHTools/interface/GroupedDAFHitCollector.h +++ b/RecoTracker/SiTrackerMRHTools/interface/GroupedDAFHitCollector.h @@ -1,6 +1,6 @@ /** \class GroupedDAFHitCollector - * Returns a collection of TSiTrackerMultiRecHits and InvalidTransientRecHits given a Trajectory. - * Builds a TSiTrackerMultiRecHit for each detGroup + * Returns a collection of SiTrackerMultiRecHits and InvalidRecHits given a Trajectory. + * Builds a SiTrackerMultiRecHit for each detGroup * (i.e. a group of detectors mutually exclusive for the track's crossing point) * * \author tropiano, genta diff --git a/RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h b/RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h index 09aee896ff60b..ca589d5bd6977 100644 --- a/RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h +++ b/RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h @@ -1,6 +1,6 @@ /** \class SiTrackerMultiRecHitUpdator - * Builds a TSiTrackerMultiRecHit out of a vector of TrackingRecHit - * or updates an existing TSiTrackerMultiRecHit given a tsos. + * Builds a SiTrackerMultiRecHit out of a vector of TrackingRecHit + * or updates an existing SiTrackerMultiRecHit given a tsos. * * \author tropiano, genta * \review in May 2014 by brondolin @@ -35,18 +35,18 @@ class SiTrackerMultiRecHitUpdator{ const std::vector& anAnnealingProgram); virtual ~SiTrackerMultiRecHitUpdator(){}; - //calls the update method in order to build a TSiTrackerMultiRecHit + //calls the update method in order to build a SiTrackerMultiRecHit virtual TransientTrackingRecHit::RecHitPointer buildMultiRecHit(const std::vector& rhv, TrajectoryStateOnSurface tsos, float annealing=1.) const; - //updates an existing TSiTrackerMultiRecHit + //updates an existing SiTrackerMultiRecHit //in case a different kind of rechit is passed it returns clone(tsos) virtual TransientTrackingRecHit::RecHitPointer update( TransientTrackingRecHit::ConstRecHitPointer original, TrajectoryStateOnSurface tsos, double annealing=1.) const; - //returns a TSiTrackerMultiRecHit out of the transient components + //returns a SiTrackerMultiRecHit out of the transient components TransientTrackingRecHit::RecHitPointer update( TransientTrackingRecHit::ConstRecHitContainer& tcomponents, TrajectoryStateOnSurface tsos, double annealing=1.) const; @@ -74,7 +74,7 @@ class SiTrackerMultiRecHitUpdator{ //LocalPoint calcParameters(TransientTrackingRecHit::ConstRecHitContainer& map, const LocalError& er) const; LocalParameters calcParameters(const TrajectoryStateOnSurface& tsos, - TransientTrackingRecHit::ConstRecHitContainer& map) const; + std::vector >& aHitMap) const; const TransientTrackingRecHitBuilder* theBuilder; const TrackingRecHitPropagator* theHitPropagator; diff --git a/RecoTracker/SiTrackerMRHTools/interface/SimpleDAFHitCollector.h b/RecoTracker/SiTrackerMRHTools/interface/SimpleDAFHitCollector.h index 291f613869a27..c97b8cca36674 100644 --- a/RecoTracker/SiTrackerMRHTools/interface/SimpleDAFHitCollector.h +++ b/RecoTracker/SiTrackerMRHTools/interface/SimpleDAFHitCollector.h @@ -19,10 +19,10 @@ class SimpleDAFHitCollector :public MultiRecHitCollector { virtual ~SimpleDAFHitCollector(){} //given a trajectory it returns a collection - //of TSiTrackerMultiRecHits and InvalidTransientRecHits. + //of SiTrackerMultiRecHits and InvalidTransientRecHits. //For each measurement in the trajectory, measurements are looked for according to the //MeasurementDet::fastMeasurements method only in the detector where the original measurement lays. - //If measurements are found a TSiTrackerMultiRecHit is built. + //If measurements are found a SiTrackerMultiRecHit is built. //All the components will lay on the same detector virtual std::vector recHits(const Trajectory&, const MeasurementTrackerEvent *theMTE) const; diff --git a/RecoTracker/SiTrackerMRHTools/src/GroupedDAFHitCollector.cc b/RecoTracker/SiTrackerMRHTools/src/GroupedDAFHitCollector.cc index e51ceaaa4df10..ee31d75a94c91 100644 --- a/RecoTracker/SiTrackerMRHTools/src/GroupedDAFHitCollector.cc +++ b/RecoTracker/SiTrackerMRHTools/src/GroupedDAFHitCollector.cc @@ -1,7 +1,6 @@ #include "RecoTracker/SiTrackerMRHTools/interface/GroupedDAFHitCollector.h" #include "RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h" #include "RecoTracker/SiTrackerMRHTools/interface/MeasurementByLayerGrouper.h" -#include "RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h" #include "TrackingTools/GeomPropagators/interface/Propagator.h" #include "TrackingTools/DetLayers/interface/MeasurementEstimator.h" #include "TrackingTools/DetLayers/interface/DetLayer.h" diff --git a/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc b/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc index f0a2690de4269..2c114e822fbee 100644 --- a/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc +++ b/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc @@ -1,10 +1,8 @@ #include "RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h" -#include "RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h" #include "RecoTracker/SiTrackerMRHTools/interface/GenericProjectedRecHit2D.h" #include "DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h" #include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h" #include "RecoTracker/TransientTrackingRecHit/interface/TkTransientTrackingRecHitBuilder.h" -//#include "RecoTracker/TransientTrackingRecHit/interface/TkClonerImpl.h" #include "TrackingTools/TransientTrackingRecHit/interface/TrackingRecHitProjector.h" #include "DataFormats/TrackingRecHit/interface/KfComponentsHolder.h" #include "DataFormats/Math/interface/invertPosDefMatrix.h" @@ -84,7 +82,6 @@ TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( Tran std::vector updatedcomponents; const GeomDet* geomdet = 0; -std::cout << "here2" ; //running on all over the MRH components for (TransientTrackingRecHit::ConstRecHitContainer::const_iterator iter = tcomponents.begin(); iter != tcomponents.end(); iter++){ @@ -138,9 +135,8 @@ std::cout << "here2" ; c_sum += c_i; } double total_sum = a_sum + c_sum; - + unsigned int counter = 0; - TransientTrackingRecHit::ConstRecHitContainer finalcomponents; for(std::vector::iterator ihit = updatedcomponents.begin(); ihit != updatedcomponents.end(); ihit++) { @@ -148,20 +144,18 @@ std::cout << "here2" ; //ORCA: float p = ((mymap[counter].second)/total_sum > 0.01 ? (mymap[counter].second)/total_sum : 1.e-6); normmap.push_back(std::pair(mymap[counter].first, p)); - finalcomponents.push_back(*ihit); - LogTrace("SiTrackerMultiRecHitUpdator")<< " Component hit type " << typeid(*mymap[counter].first).name() << " position " << mymap[counter].first->localPosition() << " error " << mymap[counter].first->localPositionError() << " with weight " << p; - std::cout << " Component hit type " << typeid(*mymap[counter].first).name() + std::cout << " Component hit type " << typeid(*mymap[counter].first).name() << " position " << mymap[counter].first->localPosition() << " \n\terror " << mymap[counter].first->localPositionError() << " with weight " << p << std::endl; counter++; } - SiTrackerMultiRecHitUpdator::LocalParameters param = calcParameters(tsos, finalcomponents); + SiTrackerMultiRecHitUpdator::LocalParameters param = calcParameters(tsos, normmap); SiTrackerMultiRecHit updated(param.first, param.second, *normmap.front().first->det(), normmap, annealing); std::cout << " Updated Hit position " << updated.localPosition() @@ -169,8 +163,6 @@ std::cout << "here2" ; LogTrace("SiTrackerMultiRecHitUpdator") << " Updated Hit position " << updated.localPosition() << " updated error " << updated.localPositionError() << std::endl; - //return TSiTrackerMultiRecHit::build(geomdet, &updated, finalcomponents, annealing); - //return SiTrackerMultiRecHit::build(param.first, param.second, *normmap.front().first->det(), normmap); return std::make_shared(param.first, param.second, *normmap.front().first->det(), normmap, annealing); } @@ -260,18 +252,18 @@ double SiTrackerMultiRecHitUpdator::ComputeWeight(const TrajectoryStateOnSurface } //----------------------------------------------------------------------------------------------------------- -SiTrackerMultiRecHitUpdator::LocalParameters SiTrackerMultiRecHitUpdator::calcParameters(const TrajectoryStateOnSurface& tsos, TransientTrackingRecHit::ConstRecHitContainer& map)const{ +SiTrackerMultiRecHitUpdator::LocalParameters SiTrackerMultiRecHitUpdator::calcParameters(const TrajectoryStateOnSurface& tsos, std::vector >& aHitMap) const{ AlgebraicSymMatrix22 W_sum; AlgebraicVector2 m_sum; - for(TransientTrackingRecHit::ConstRecHitContainer::const_iterator ihit = map.begin(); ihit != map.end(); ihit ++) { + for(std::vector >::const_iterator ihit = aHitMap.begin(); ihit != aHitMap.end(); ihit++){ std::pair PositionAndError22; - PositionAndError22 = ComputeParameters2dim(tsos, *(*ihit)); + PositionAndError22 = ComputeParameters2dim(tsos, *(ihit->first)); - W_sum += ((*ihit)->weight()*PositionAndError22.second); - m_sum += ((*ihit)->weight()*(PositionAndError22.second*PositionAndError22.first)); + W_sum += (ihit->second*PositionAndError22.second); + m_sum += (ihit->second*(PositionAndError22.second*PositionAndError22.first)); } diff --git a/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc~ b/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc~ deleted file mode 100644 index 1c07ebab67609..0000000000000 --- a/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc~ +++ /dev/null @@ -1,240 +0,0 @@ -#include "RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h" -#include "RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h" -//#include "RecoTracker/SiTrackerMRHTools/interface/GenericProjectedRecHit2D.h" -//#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h" -#include "DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h" -#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h" -#include "TrackingTools/TransientTrackingRecHit/interface/TrackingRecHitProjector.h" -#include "TrackingTools/TransientTrackingRecHit/interface/InvalidTransientRecHit.h" -#include "FWCore/MessageLogger/interface/MessageLogger.h" - -//ERICA: All the input parameter are in RecoTracker/SiTrackerMRHTools/python/SiTrackerMultiRecHitUpdator_cfi.py -SiTrackerMultiRecHitUpdator::SiTrackerMultiRecHitUpdator(const TransientTrackingRecHitBuilder* builder, - const TrackingRecHitPropagator* hitpropagator, - const float Chi2Cut, - const std::vector& anAnnealingProgram): - theBuilder(builder), - theHitPropagator(hitpropagator), - theChi2Cut(Chi2Cut), - theAnnealingProgram(anAnnealingProgram){} -//theAnnealingStep(0), -//theIsUpdating(true){} - -/* -TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::buildMultiRecHit(const std::vector& rhv, - TrajectoryStateOnSurface tsos, - float annealing) const{ - std::cout << "Calling SiTrackerMultiRecHitUpdator::buildMultiRecHit with AnnealingFactor: " << annealing << std::endl; - TransientTrackingRecHit::ConstRecHitContainer tcomponents; - for (std::vector::const_iterator iter = rhv.begin(); iter != rhv.end(); iter++){ - TransientTrackingRecHit::RecHitPointer transient = theBuilder->build(*iter); - if (transient->isValid()) tcomponents.push_back(transient); - } - - return update(tcomponents, tsos, annealing); - -} -*/ -TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( TransientTrackingRecHit::ConstRecHitPointer original, - TrajectoryStateOnSurface tsos, - double annealing) const{ - std::cout << "Calling SiTrackerMultiRecHitUpdator::update with AnnealingFactor: " << annealing << std::endl; - LogTrace("SiTrackerMultiRecHitUpdator") << "Calling SiTrackerMultiRecHitUpdator::update with AnnealingFactor: " << annealing; - if (original->isValid()) - LogTrace("SiTrackerMultiRecHitUpdator") << "Original Hit position " << original->localPosition() << " original error " - << original->parametersError(); - else LogTrace("SiTrackerMultiRecHitUpdator") << "Invalid hit"; - - if(!tsos.isValid()) { - //return original->clone(); - throw cms::Exception("SiTrackerMultiRecHitUpdator") << "!!! MultiRecHitUpdator::update(..): tsos NOT valid!!! "; - } - - //check if to clone is the right thing - if (original->transientHits().empty()) return original->clone(tsos); - - TransientTrackingRecHit::ConstRecHitContainer tcomponents = original->transientHits(); - return update(tcomponents, tsos, annealing); -} - -TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( TransientTrackingRecHit::ConstRecHitContainer& tcomponents, - TrajectoryStateOnSurface tsos, - double annealing) const{ - - if (tcomponents.empty()){ - LogTrace("SiTrackerMultiRecHitUpdator") << "Empty components vector passed to SiTrackerMultiRecHitUpdator::update, returning an InvalidTransientRecHit "; - return InvalidTransientRecHit::build(0); - } - - if(!tsos.isValid()) { - LogTrace("SiTrackerMultiRecHitUpdator")<<"SiTrackerMultiRecHitUpdator::update: tsos NOT valid!!!, returning an InvalidTransientRecHit"; - return InvalidTransientRecHit::build(0); - } - - std::vector updatedcomponents; - const GeomDet* geomdet = 0; - - //ERICA: running on all over the measurements for each vtraj - for (TransientTrackingRecHit::ConstRecHitContainer::const_iterator iter = tcomponents.begin(); iter != tcomponents.end(); iter++){ - - //ERICA: the first rechit must belong to the same surface of TSOS + setting geomdet variable - if (iter == tcomponents.begin()) { - - if (&((*iter)->det()->surface())!=&(tsos.surface())){ - throw cms::Exception("SiTrackerMultiRecHitUpdator") << "the Trajectory state and the first rechit passed to the SiTrackerMultiRecHitUpdator lay on different surfaces!: state lays on surface " << tsos.surface().position() << " hit with detid " << (*iter)->det()->geographicalId().rawId() << " lays on surface " << (*iter)->det()->surface().position(); - } - - geomdet = (*iter)->det(); - LogTrace("SiTrackerMultiRecHitUpdator") << "Current reference surface located at " << geomdet->surface().position(); - LogTrace("SiTrackerMultiRecHitUpdator")<< "TSOS position " << tsos.localPosition(); - } - - //ERICA::WARNING you have to fix GenericProjectedRecHit2D.h - if (&((*iter)->det()->surface())!=&(tsos.surface())){ -// TransientTrackingRecHit::RecHitPointer cloned = theHitPropagator->project(*iter, *geomdet, tsos); -// LogTrace("SiTrackerMultiRecHitUpdator") << "hit propagated"; - -// if (cloned->isValid()) updatedcomponents.push_back(cloned); - } else { - TransientTrackingRecHit::RecHitPointer cloned = (*iter)->clone(tsos); - if (cloned->isValid()) updatedcomponents.push_back(cloned); - } - } - LogTrace("SiTrackerMultiRecHitUpdator") << "hit cloned"; - //ERICA: ierr will be set to 0 when inversion is successfull - int ierr; - - std::vector > mymap; - std::vector > normmap; - - double a_sum=0, c_sum=0; - - AlgebraicVector2 tsospos; - tsospos[0]=tsos.localPosition().x(); - tsospos[1]=tsos.localPosition().y(); - LogTrace("SiTrackerMultiRecHitUpdator")<< "TSOS position " << tsos.localPosition(); - - for(std::vector::iterator ihit = updatedcomponents.begin(); ihit != updatedcomponents.end(); ihit++) { - AlgebraicVector2 r(asSVector<2>((*ihit)->parameters()) - tsospos); - AlgebraicSymMatrix22 V(asSMatrix<2>((*ihit)->parametersError())); - V *= annealing;//assume that TSOS is smoothed one - //V += me.measuredError(*ihit);// result = b*V + H*C*H.T() - AlgebraicSymMatrix22 W(V.Inverse(ierr)); - - //ERICA: the Det2 method will preserve the content of the Matrix and return true when the calculation is successfull - double det; - bool ierr2=!(V.Det2(det)); - - if(ierr != 0|| ierr2) { - LogTrace("SiTrackerMultiRecHitUpdator")<<"MultiRecHitUpdator::update: W not valid!"<((*ihit)->hit(), a_i)); - double c_i = exp(-0.5*theChi2Cut/annealing)/(2.*M_PI*sqrt(det)); - a_sum += a_i; - c_sum += c_i; - } - double total_sum = a_sum + c_sum; - - unsigned int counter = 0; - TransientTrackingRecHit::ConstRecHitContainer finalcomponents; - for(std::vector::iterator ihit = updatedcomponents.begin(); ihit != updatedcomponents.end(); ihit++) { - //uncomment lines below to have like ORCA - double p = ((mymap[counter].second)/total_sum > 1.e-6 ? (mymap[counter].second)/total_sum : 1.e-6); - //float p = ((mymap[counter].second)/total_sum > 0.01 ? (mymap[counter].second)/total_sum : 1.e-6); - normmap.push_back(std::pair(mymap[counter].first, p)); - //let's store the weight in the component TransientTrackingRecHit too -// (*ihit)->setWeight(p); -// (*ihit)->setAnnealingFactor(annealing); - finalcomponents.push_back(*ihit); - LogTrace("SiTrackerMultiRecHitUpdator")<< "Component hit type " << typeid(*mymap[counter].first).name() - << " position " << mymap[counter].first->localPosition() - << " error " << mymap[counter].first->localPositionError() - << " with weight " << p; - counter++; - } - - //ERICA: I do not understand what is the utility to do that. - mymap = normmap; - // LocalError er = calcParametersError(finalcomponents); - // LocalPoint p = calcParameters(finalcomponents, er); - SiTrackerMultiRecHitUpdator::LocalParameters param=calcParameters(finalcomponents); -// SiTrackerMultiRecHit updated(param.first, param.second, normmap.front().first->>geographicalId(), normmap); - SiTrackerMultiRecHit updated(param.first, param.second, normmap.front().first->det(), normmap); - LogTrace("SiTrackerMultiRecHitUpdator") << "Updated Hit position " << updated.localPosition() << " updated error " << updated.parametersError() << std::endl; - //return new SiTrackerMultiRecHit(normmap); - return TSiTrackerMultiRecHit::build(geomdet, &updated, finalcomponents, annealing); - -} - - -SiTrackerMultiRecHitUpdator::LocalParameters SiTrackerMultiRecHitUpdator::calcParameters(TransientTrackingRecHit::ConstRecHitContainer& map)const{ - AlgebraicSymMatrix22 W_sum; - AlgebraicVector2 m_sum; - int ierr; - for(TransientTrackingRecHit::ConstRecHitContainer::const_iterator ihit = map.begin(); ihit != map.end(); ihit ++) { - AlgebraicVector2 m(asSVector<2>((*ihit)->parameters())); - AlgebraicSymMatrix22 V(asSMatrix<2>((*ihit)->parametersError())); - AlgebraicSymMatrix22 W(V.Inverse(ierr)); - - if(ierr != 0) { - edm::LogError("SiTrackerMultiRecHitUpdator")<<"MultiRecHit::checkParameters: W not valid!"<weight()*W); - m_sum += ((*ihit)->weight()*(W*m)); - } - } - AlgebraicSymMatrix22 V_sum= W_sum.Inverse(ierr); - AlgebraicVector2 parameters = V_sum*m_sum; - LocalError error=LocalError(V_sum(0,0), V_sum(0,1), V_sum(1,1)); - LocalPoint position=LocalPoint(parameters(0), parameters(1)); - return std::make_pair(position,error); -} - -LocalError SiTrackerMultiRecHitUpdator::calcParametersError(TransientTrackingRecHit::ConstRecHitContainer& map) const { - AlgebraicSymMatrix22 W_sum; - int ierr; - for(TransientTrackingRecHit::ConstRecHitContainer::const_iterator ihit = map.begin(); ihit != map.end(); ihit ++) { - AlgebraicSymMatrix22 V(asSMatrix<2>((*ihit)->parametersError())); - AlgebraicSymMatrix22 W(V.Inverse(ierr)); - - if(ierr != 0) { - edm::LogError("SiTrackerMultiRecHitUpdator")<<"MultiRecHit::checkParametersError: W not valid!"<weight()*W); - } - AlgebraicSymMatrix22 parametersError = W_sum.Inverse(ierr); - return LocalError(parametersError(0,0), parametersError(0,1), parametersError(1,1)); -} - -LocalPoint SiTrackerMultiRecHitUpdator::calcParameters(TransientTrackingRecHit::ConstRecHitContainer& map, const LocalError& er) const { - AlgebraicVector2 m_sum; - int ierr; - for( TransientTrackingRecHit::ConstRecHitContainer::const_iterator ihit = map.begin(); ihit != map.end(); ihit ++) { - AlgebraicVector2 m(asSVector<2>((*ihit)->parameters())); - AlgebraicSymMatrix22 V(asSMatrix<2>((*ihit)->parametersError())); - AlgebraicSymMatrix22 W(V.Inverse(ierr)); - - if(ierr != 0) { - edm::LogError("SiTrackerMultiRecHitUpdator")<<"MultiRecHit::checkParameters: W not valid!"<weight()*(W*m); - else m_sum += ((*ihit)->weight()*(W*m)); - } - AlgebraicSymMatrix22 V_sum; - - V_sum(0,0) = er.xx(); - V_sum(0,1) = er.xy(); - V_sum(1,1) = er.yy(); - //AlgebraicSymMatrix V_sum(parametersError()); - AlgebraicVector2 parameters = V_sum*m_sum; - return LocalPoint(parameters(0), parameters(1)); -} - diff --git a/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc b/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc index 631f9b8444c17..9eacd64663822 100644 --- a/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc +++ b/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc @@ -1,6 +1,5 @@ #include "RecoTracker/SiTrackerMRHTools/interface/SimpleDAFHitCollector.h" #include "RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h" -#include "RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h" #include "TrackingTools/DetLayers/interface/MeasurementEstimator.h" #include "TrackingTools/PatternTools/interface/Trajectory.h" #include "DataFormats/TrackingRecHit/interface/InvalidTrackingRecHit.h" @@ -42,7 +41,6 @@ vector SimpleDAFHitCollector::recHits(const Trajectory& t //groups the TrajectoryMeasurements on a sensor by sensor //we have to sort the TrajectoryMeasurements in the opposite way in the fitting direction -// std::cout << " Sensor by sensor measurements are:\n"; vector result; for(vector::const_reverse_iterator itrajmeas = meas.rbegin(); itrajmeas < meas.rend(); itrajmeas++) { diff --git a/RecoTracker/SiTrackerMRHTools/test/DAFRecoTrack_cfg.py b/RecoTracker/SiTrackerMRHTools/test/DAFRecoTrack_cfg.py index 23d00c0452f32..27165729231b8 100644 --- a/RecoTracker/SiTrackerMRHTools/test/DAFRecoTrack_cfg.py +++ b/RecoTracker/SiTrackerMRHTools/test/DAFRecoTrack_cfg.py @@ -15,14 +15,16 @@ ### Conditions process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") -from Configuration.AlCa.GlobalTag import GlobalTag -process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:startup', '') +#from Configuration.AlCa.GlobalTag import GlobalTag +#process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:startup', '') +process.GlobalTag.globaltag = 'START71_V1::All'#POSTLS171_V1::All' ### Track Refitter process.load("RecoTracker.TrackProducer.TrackRefitters_cff") process.load("RecoTracker.TrackProducer.CTFFinalFitWithMaterialDAF_cff") process.ctfWithMaterialTracksDAF.TrajectoryInEvent = True process.ctfWithMaterialTracksDAF.src = 'TrackRefitter' +process.ctfWithMaterialTracksDAF.TrajAnnealingSaving = True process.MRHFittingSmoother.EstimateCut = -1 process.MRHFittingSmoother.MinNumberOfHits = 3 @@ -30,7 +32,7 @@ # fileNames = cms.untracked.vstring('file:reco_trk_TTbar_13_5evts.root') fileNames = cms.untracked.vstring('file:reco_trk_SingleMuPt10_UP15_10evts.root') ) -process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(-1)) +process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(1)) process.out = cms.OutputModule("PoolOutputModule", outputCommands = cms.untracked.vstring('drop *_*_*_*', diff --git a/RecoTracker/TrackProducer/interface/DAFTrackProducerAlgorithm.h b/RecoTracker/TrackProducer/interface/DAFTrackProducerAlgorithm.h index b21e9058da910..d38c3806baf76 100644 --- a/RecoTracker/TrackProducer/interface/DAFTrackProducerAlgorithm.h +++ b/RecoTracker/TrackProducer/interface/DAFTrackProducerAlgorithm.h @@ -51,7 +51,8 @@ class DAFTrackProducerAlgorithm { const SiTrackerMultiRecHitUpdator*, const reco::BeamSpot&, AlgoProductCollection &, - TrajAnnealingCollection &) const; + TrajAnnealingCollection &, + bool ) const; private: /// Construct Tracks to be put in the event diff --git a/RecoTracker/TrackProducer/plugins/DAFTrackProducer.cc b/RecoTracker/TrackProducer/plugins/DAFTrackProducer.cc index 408ca4442f5e2..dc5dab12238a2 100644 --- a/RecoTracker/TrackProducer/plugins/DAFTrackProducer.cc +++ b/RecoTracker/TrackProducer/plugins/DAFTrackProducer.cc @@ -33,6 +33,8 @@ DAFTrackProducer::DAFTrackProducer(const edm::ParameterSet& iConfig): produces >(); produces(); produces().setBranchAlias( alias_ + "TrajectoryAnnealing" ); + + TrajAnnSaving_ = iConfig.getParameter("TrajAnnealingSaving"); } @@ -87,7 +89,7 @@ void DAFTrackProducer::produce(edm::Event& theEvent, const edm::EventSetup& setu theAlgo.runWithCandidate(theG.product(), theMF.product(), *theTrajectoryCollection, &*mte, theFitter.product(), theBuilder.product(), measurementCollectorHandle.product(), updatorHandle.product(), bs, - algoResults, trajannResults); + algoResults, trajannResults, TrajAnnSaving_); } catch (cms::Exception &e){ edm::LogInfo("DAFTrackProducer") << "cms::Exception caught!!!" << "\n" << e << "\n"; diff --git a/RecoTracker/TrackProducer/plugins/DAFTrackProducer.h b/RecoTracker/TrackProducer/plugins/DAFTrackProducer.h index fbbb6df84b588..faaac103133c3 100644 --- a/RecoTracker/TrackProducer/plugins/DAFTrackProducer.h +++ b/RecoTracker/TrackProducer/plugins/DAFTrackProducer.h @@ -28,6 +28,7 @@ class DAFTrackProducer : public KfTrackProducerBase, public edm::EDProducer { void getFromEvt(edm::Event&, edm::Handle&, reco::BeamSpot&); void putInEvtTrajAnn(edm::Event& theEvent, TrajAnnealingCollection & trajannResults, std::auto_ptr& selTrajAnn); + bool TrajAnnSaving_; }; #endif diff --git a/RecoTracker/TrackProducer/python/CTFFinalFitWithMaterialDAF_cfi.py b/RecoTracker/TrackProducer/python/CTFFinalFitWithMaterialDAF_cfi.py index 9a2493432002b..f8f6046e049ef 100644 --- a/RecoTracker/TrackProducer/python/CTFFinalFitWithMaterialDAF_cfi.py +++ b/RecoTracker/TrackProducer/python/CTFFinalFitWithMaterialDAF_cfi.py @@ -11,7 +11,8 @@ TrajectoryInEvent = cms.bool(False), TTRHBuilder = cms.string('WithAngleAndTemplate'), Propagator = cms.string('RungeKuttaTrackerPropagator'), - MinHits = cms.int32(3) + MinHits = cms.int32(3), + TrajAnnealingSaving = cms.bool(False) ) diff --git a/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc b/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc index f4ee29080500b..e1fae971fb987 100644 --- a/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc +++ b/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc @@ -17,7 +17,9 @@ #include "TrackingTools/PatternTools/interface/TSCBLBuilderNoMaterial.h" #include "TrackingTools/PatternTools/interface/TransverseImpactPointExtrapolator.h" #include "TrackingTools/TrackFitters/interface/TrajectoryStateWithArbitraryError.h" -#include "RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h" +#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h" +#include "DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h" +#include "DataFormats/TrackerRecHit2D/interface/OmniClusterRef.h" #include "DataFormats/TrackerRecHit2D/interface/TkCloner.h" #include "TrackingTools/PatternTools/interface/TrajAnnealing.h" @@ -31,7 +33,8 @@ void DAFTrackProducerAlgorithm::runWithCandidate(const TrackingGeometry * theG, const SiTrackerMultiRecHitUpdator* updator, const reco::BeamSpot& bs, AlgoProductCollection& algoResults, - TrajAnnealingCollection& trajann) const + TrajAnnealingCollection& trajann, + bool TrajAnnSaving_) const { std::cout << "////////////////////////////////////////////////////////\n" << "DAFTrackProducerAlgorithm::runWithCandidate: Number of Trajectories: " << theTrajectoryCollection.size() << "\n"; @@ -55,6 +58,7 @@ void DAFTrackProducerAlgorithm::runWithCandidate(const TrackingGeometry * theG, //getting the MultiRecHit collection and the trajectory with a first fit-smooth round std::pair hits = collectHits(*ivtraj, measurementCollector, &*measTk); + currentTraj = fit(hits, theFitter, *ivtraj); //starting the annealing program @@ -73,8 +77,10 @@ std::cout << "Starting with the annealing " << *ian << std::endl; currentTraj = fit(curiterationhits, theFitter, currentTraj); //saving trajectory for each annealing cycle ... - TrajAnnealing temp(currentTraj, *ian); - trajann.push_back(temp); + if(TrajAnnSaving_){ + TrajAnnealing temp(currentTraj, *ian); + trajann.push_back(temp); + } LogDebug("DAFTrackProducerAlgorithm") << "done annealing value " << (*ian) ; @@ -263,11 +269,13 @@ void DAFTrackProducerAlgorithm::filter(const TrajectoryFitter* fitter, std::vec for (std::vector::reverse_iterator tm=vtm.rbegin(); tm!=vtm.rend();tm++){ //if the rechit is valid if (tm->recHit()->isValid()) { - TransientTrackingRecHit::ConstRecHitContainer components = tm->recHit()->transientHits(); + SiTrackerMultiRecHit const & mHit = dynamic_cast(*tm->recHit()); + std::vector components = mHit.recHits(); + int iComp = 0; bool isGood = false; - for (TransientTrackingRecHit::ConstRecHitContainer::iterator rechit = components.begin(); rechit != components.end(); rechit++){ - //if there is at least one component with weight higher than 1e-6 then the hit is not an outlier - if ((*rechit)->weight()>1e-6) {ngoodhits++; isGood = true; break;} + for(std::vector::const_iterator iter = components.begin(); iter != components.end(); iter++, iComp++){ + //if there is at least one component with weight higher than 1e-6 then the hit is not an outlier + if (mHit.weight(iComp)>1e-6) {ngoodhits++; iComp++; isGood = true; break;} } if (isGood) { TkClonerImpl hc = static_cast(builder)->cloner(); @@ -310,12 +318,12 @@ float DAFTrackProducerAlgorithm::calculateNdof(const Trajectory vtraj) const const std::vector& meas = vtraj.measurements(); for (std::vector::const_iterator iter = meas.begin(); iter != meas.end(); iter++){ if (iter->recHit()->isValid()){ - TransientTrackingRecHit::ConstRecHitContainer components = iter->recHit()->transientHits(); - TransientTrackingRecHit::ConstRecHitContainer::const_iterator iter2; - - for (iter2 = components.begin(); iter2 != components.end(); iter2++){ + SiTrackerMultiRecHit const & mHit = dynamic_cast(*iter->recHit()); + std::vector components = mHit.recHits(); + int iComp = 0; + for(std::vector::const_iterator iter2 = components.begin(); iter2 != components.end(); iter2++, iComp++){ if ((*iter2)->isValid()) - ndof += ((*iter2)->dimension())*(*iter2)->weight(); + ndof += ((*iter2)->dimension())*mHit.weight(iComp); } } diff --git a/RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h b/RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h deleted file mode 100644 index 6164bca9102c2..0000000000000 --- a/RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h +++ /dev/null @@ -1,94 +0,0 @@ -#ifndef TSiTrackerMultiRecHit_h -#define TSiTrackerMultiRecHit_h - -#include "TrackingTools/TransientTrackingRecHit/interface/TValidTrackingRecHit.h" -#include "DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h" -#include "TrackingTools/TransientTrackingRecHit/interface/HelpertRecHit2DLocalPos.h" -#include "Geometry/CommonDetUnit/interface/GeomDetUnit.h" - -/* -A TransientTrackingRecHit for the SiTrackerMultiRecHit -*/ - -class TSiTrackerMultiRecHit GCC11_FINAL : public TValidTrackingRecHit { -public: - //virtual ~TSiTrackerMultiRecHit() {delete theHitData;} - virtual ~TSiTrackerMultiRecHit() {} - - virtual AlgebraicVector parameters() const {return theHitData.parameters();} - virtual AlgebraicSymMatrix parametersError() const { - return HelpertRecHit2DLocalPos().parError( theHitData.localPositionError(), *det()); - //return theHitData.parametersError(); - } - - virtual void getKfComponents( KfComponentsHolder & holder ) const { - HelpertRecHit2DLocalPos().getKfComponents(holder, theHitData, *det()); - } - virtual DetId geographicalId() const {return theHitData.geographicalId();} - virtual AlgebraicMatrix projectionMatrix() const {return theHitData.projectionMatrix();} - virtual int dimension() const {return theHitData.dimension();} - - virtual LocalPoint localPosition() const {return theHitData.localPosition();} - virtual LocalError localPositionError() const {return theHitData.localPositionError();} - - virtual const TrackingRecHit * hit() const {return &theHitData;}; - const SiTrackerMultiRecHit* specificHit() const {return &theHitData;} - - virtual bool isValid() const{return theHitData.isValid();} - - virtual std::vector recHits() const { - return theHitData.recHits(); - } - virtual std::vector recHits() { - return theHitData.recHits(); - } - - - /// interface needed to set and read back an annealing value that has been applied to the current hit error matrix when - /// using it as a component for a composite rec hit (useful for the DAF) -// void setAnnealingFactor(float annealing) {annealing_ = annealing;} -// float getAnnealingFactor() const {return annealing_;} - - - //vector of weights -// std::vector const & weights() const {return theHitData.weights();} -// std::vector & weights() {return theHitData.weights();} - - //returns the weight for the i component -// float weight(unsigned int i) const {return theHitData.weight(i);} -// float & weight(unsigned int i) {return theHitData.weight(i);} - - - virtual const GeomDetUnit* detUnit() const; - - virtual bool canImproveWithTrack() const {return true;} - - virtual RecHitPointer clone(const TrajectoryStateOnSurface& ts) const; - -// virtual ConstRecHitContainer transientHits() const {return theComponents;}; - - static RecHitPointer build( const GeomDet * geom, const SiTrackerMultiRecHit* rh, - const ConstRecHitContainer& components, float annealing=1.){ - return RecHitPointer(new TSiTrackerMultiRecHit( geom, rh, components, annealing)); - } - - - -private: - SiTrackerMultiRecHit theHitData; - //holds the TransientTrackingRecHit components of the MultiRecHit - ConstRecHitContainer theComponents; - float annealing_; - - TSiTrackerMultiRecHit(const GeomDet * geom, const SiTrackerMultiRecHit* rh, - const ConstRecHitContainer& components, float annealing): - TValidTrackingRecHit(*geom), theHitData(*rh), theComponents(components), annealing_(annealing){} - - virtual TSiTrackerMultiRecHit* clone() const { - return new TSiTrackerMultiRecHit(*this); - } - - -}; - -#endif diff --git a/RecoTracker/TransientTrackingRecHit/src/TSiTrackerMultiRecHit.cc b/RecoTracker/TransientTrackingRecHit/src/TSiTrackerMultiRecHit.cc deleted file mode 100644 index 6a0d0b134162e..0000000000000 --- a/RecoTracker/TransientTrackingRecHit/src/TSiTrackerMultiRecHit.cc +++ /dev/null @@ -1,36 +0,0 @@ -#include "RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h" - -/* -TSiTrackerMultiRecHit::TSiTrackerMultiRecHit(const GeomDet * geom, const std::vector& rhs, const SiTrackerMultiRecHitUpdator* updator, const TrajectoryStateOnSurface& tsos): -TValidTrackingRecHit(geom), theUpdator(updator){ - theHitData = theUpdator->buildMultiRecHit(tsos, rhs, theComponents); - setAnnealingFactor(theUpdator->getCurrentAnnealingValue()); -} -*/ - -const GeomDetUnit* TSiTrackerMultiRecHit::detUnit() const{ - return dynamic_cast(det()); -} - -TransientTrackingRecHit::RecHitPointer TSiTrackerMultiRecHit::clone(const TrajectoryStateOnSurface& ts) const{ -/* - std::vector updatedcomponents = theComponents; - SiTrackerMultiRecHit better = theUpdator->update(ts,&theHitData, updatedcomponents); - RecHitPointer result = TSiTrackerMultiRecHit::build( det(), &better, theUpdator, updatedcomponents ); - return result; -*/ - return RecHitPointer(this->clone()); -} - -/* - -std::vector TSiTrackerMultiRecHit::recHits() const { - std::vector components; - std::vector::const_iterator iter; - for (iter = theComponents.begin(); iter != theComponents.end(); iter++){ - components.push_back(iter->get()); - } - return components; -} - -*/ diff --git a/TrackingTools/KalmanUpdators/src/MRHChi2MeasurementEstimator.cc b/TrackingTools/KalmanUpdators/src/MRHChi2MeasurementEstimator.cc index c1bfed9c602a0..84e27888e2bce 100644 --- a/TrackingTools/KalmanUpdators/src/MRHChi2MeasurementEstimator.cc +++ b/TrackingTools/KalmanUpdators/src/MRHChi2MeasurementEstimator.cc @@ -1,4 +1,3 @@ -#include "RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h" #include "DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h" #include "RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h" #include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h" @@ -7,6 +6,8 @@ #include "DataFormats/GeometrySurface/interface/Plane.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" #include "DataFormats/Math/interface/invertPosDefMatrix.h" +#include "DataFormats/Math/interface/ProjectMatrix.h" +#include "DataFormats/TrackingRecHit/interface/KfComponentsHolder.h" std::pair MRHChi2MeasurementEstimator::estimate(const TrajectoryStateOnSurface& tsos, const TrackingRecHit& aRecHit) const { @@ -38,11 +39,13 @@ std::cout << " MRHChi2MeasurementEstimator::estimate " << std::endl; std::cout << " Current annealing factor is " << annealing; LogDebug("MRHChi2MeasurementEstimator") << "Current annealing factor is " << annealing; - TransientTrackingRecHit::ConstRecHitContainer components = mHit.transientHits(); + std::vector components = mHit.recHits(); std::cout << "; this hit has " << components.size() << " components\n"; LogDebug("MRHChi2MeasurementEstimator") << "this hit has " << components.size() << " components"; - for (TransientTrackingRecHit::ConstRecHitContainer::const_iterator iter = components.begin(); iter != components.end(); iter++){ + int iComp = 0; + for(std::vector::const_iterator iter = components.begin(); iter != components.end(); iter++, iComp++){ +// for (TransientTrackingRecHit::ConstRecHitContainer::const_iterator iter = components.begin(); iter != components.end(); iter++){ // define variables that will be used to setup the KfComponentsHolder ProjectMatrix pf; @@ -64,9 +67,10 @@ std::cout << " MRHChi2MeasurementEstimator::estimate " << std::endl; edm::LogError("SiTrackerMultiRecHitUpdator")<<"SiTrackerMultiRecHitUpdator::ComputeParameters2dim: W not valid!"<weight() << std::endl; - LogDebug("MRHChi2MeasurementEstimator") << "Hit with weight " << (*iter)->weight(); - est += ROOT::Math::Similarity(r, V)*((*iter)->weight()); + std::cout << " Hit with weight " << mHit.weight(iComp) << std::endl; + LogDebug("MRHChi2MeasurementEstimator") << "Hit with weight " << mHit.weight(iComp); + est += ROOT::Math::Similarity(r, V)*mHit.weight(iComp); + } return returnIt(est); diff --git a/TrackingTools/PatternTools/src/TrajAnnealing.cc b/TrackingTools/PatternTools/src/TrajAnnealing.cc index efb8f1a6af979..4ebf06e91d636 100644 --- a/TrackingTools/PatternTools/src/TrajAnnealing.cc +++ b/TrackingTools/PatternTools/src/TrajAnnealing.cc @@ -1,7 +1,7 @@ #include "TrackingTools/PatternTools/interface/Trajectory.h" #include "TrackingTools/PatternTools/interface/TrajAnnealing.h" #include "TrackingTools/PatternTools/interface/TrajectoryMeasurement.h" -#include "RecoTracker/TransientTrackingRecHit/interface/TSiTrackerMultiRecHit.h" +#include "DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h" TrajAnnealing::TrajAnnealing( Trajectory traj, float ann ){ traj_ = traj; @@ -11,19 +11,15 @@ TrajAnnealing::TrajAnnealing( Trajectory traj, float ann ){ std::vector vmeas = traj_.measurements(); std::vector::reverse_iterator imeas; - //I run inversely on the trajectory obtained and update the state for (imeas = vmeas.rbegin(); imeas != vmeas.rend(); imeas++){ theHits_.push_back(imeas->recHit()); - } - - int hitcounter = 1; - for(TransientTrackingRecHit::RecHitContainer::const_iterator ihit = theHits_.begin(); - ihit != theHits_.end(); ++ihit, ++hitcounter) { - - std::pair > annweight; - annweight = getAnnealingWeight(**ihit); - for(unsigned int i = 0 ; i < annweight.second.size(); i++ ){ - theWeights.push_back( annweight.second.at(i) ); + if (imeas->recHit()->isValid()){ + SiTrackerMultiRecHit const & mHit = dynamic_cast(*imeas->recHit()); + std::vector components = mHit.recHits(); + int iComp = 0; + for(std::vector::const_iterator iter2 = components.begin(); iter2 != components.end(); iter2++, iComp++){ + theWeights.push_back(mHit.weight(iComp)); + } } } } @@ -31,28 +27,21 @@ TrajAnnealing::TrajAnnealing( Trajectory traj, float ann ){ void TrajAnnealing::Debug() const{ std::vector measurements = traj_.measurements(); - TransientTrackingRecHit::RecHitContainer hits; std::vector vmeas = traj_.measurements(); std::vector::reverse_iterator imeas; //I run inversely on the trajectory obtained and update the state for (imeas = vmeas.rbegin(); imeas != vmeas.rend(); imeas++){ - hits.push_back(imeas->recHit()); - } - - int hitcounter = 1; - for(TransientTrackingRecHit::RecHitContainer::const_iterator ihit = hits.begin(); - ihit != hits.end(); ++ihit, ++hitcounter) { - - std::pair > annweight; - annweight = getAnnealingWeight(**ihit); - std::cout << "Annealing: " << annweight.first; - for(unsigned int i = 0 ; i < annweight.second.size(); i++ ){ - std::cout << "\tHit weight in mrh " << annweight.second.at(i) << "\t"; + if (imeas->recHit()->isValid()){ + SiTrackerMultiRecHit const & mHit = dynamic_cast(*imeas->recHit()); + std::vector components = mHit.recHits(); + int iComp = 0; + std::cout << "Annealing: " << mHit.getAnnealingFactor(); + for(std::vector::const_iterator iter2 = components.begin(); iter2 != components.end(); iter2++, iComp++){ + std::cout << "\tHit weight in mrh " << mHit.weight(iComp) << "\t"; + } } - std::cout << std::endl; } - } std::pair > TrajAnnealing::getAnnealingWeight( const TrackingRecHit& aRecHit ) const { @@ -64,7 +53,6 @@ std::pair > TrajAnnealing::getAnnealingWeight( const T } SiTrackerMultiRecHit const & mHit = dynamic_cast(aRecHit); - //TSiTrackerMultiRecHit const & mHit = dynamic_cast(aRecHit); return make_pair(mHit.getAnnealingFactor(), mHit.weights()); } From 5ecc4356115ad65395728001a25f43c4816fe653 Mon Sep 17 00:00:00 2001 From: erica brondolin Date: Wed, 11 Jun 2014 11:44:07 +0200 Subject: [PATCH 04/16] Delete cout --- .../src/SiTrackerMultiRecHitUpdator.cc | 18 +++++++-------- .../src/SimpleDAFHitCollector.cc | 22 +++++++++---------- .../src/DAFTrackProducerAlgorithm.cc | 6 ++--- .../src/MRHChi2MeasurementEstimator.cc | 10 ++++----- 4 files changed, 25 insertions(+), 31 deletions(-) diff --git a/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc b/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc index 2c114e822fbee..f02b8e5f556c2 100644 --- a/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc +++ b/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc @@ -24,7 +24,7 @@ SiTrackerMultiRecHitUpdator::SiTrackerMultiRecHitUpdator(const TransientTracking TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::buildMultiRecHit(const std::vector& rhv, TrajectoryStateOnSurface tsos, float annealing) const{ - std::cout << " Calling SiTrackerMultiRecHitUpdator::buildMultiRecHit with AnnealingFactor: " << annealing << std::endl; +// std::cout << " Calling SiTrackerMultiRecHitUpdator::buildMultiRecHit with AnnealingFactor: " << annealing << std::endl; TransientTrackingRecHit::ConstRecHitContainer tcomponents; for (std::vector::const_iterator iter = rhv.begin(); iter != rhv.end(); iter++){ TransientTrackingRecHit::RecHitPointer transient = theBuilder->build(*iter); @@ -37,7 +37,7 @@ TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::buildMultiR TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( TransientTrackingRecHit::ConstRecHitPointer original, TrajectoryStateOnSurface tsos, double annealing) const{ - std::cout << " Calling SiTrackerMultiRecHitUpdator::update with AnnealingFactor: " << annealing << std::endl; +// std::cout << " Calling SiTrackerMultiRecHitUpdator::update with AnnealingFactor: " << annealing << std::endl; LogTrace("SiTrackerMultiRecHitUpdator") << "Calling SiTrackerMultiRecHitUpdator::update with AnnealingFactor: " << annealing; if (original->isValid()) @@ -69,13 +69,11 @@ TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( Tran double annealing) const{ if (tcomponents.empty()){ - std::cout << "Empty components vector passed to SiTrackerMultiRecHitUpdator::update, returning an InvalidTransientRecHit \n"; LogTrace("SiTrackerMultiRecHitUpdator") << "Empty components vector passed to SiTrackerMultiRecHitUpdator::update, returning an InvalidTransientRecHit "; return std::make_shared(); } if(!tsos.isValid()) { - std::cout<<"SiTrackerMultiRecHitUpdator::update: tsos NOT valid!!!, returning an InvalidTransientRecHit\n"; LogTrace("SiTrackerMultiRecHitUpdator")<<"SiTrackerMultiRecHitUpdator::update: tsos NOT valid!!!, returning an InvalidTransientRecHit"; return std::make_shared(); } @@ -148,18 +146,18 @@ TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( Tran << " position " << mymap[counter].first->localPosition() << " error " << mymap[counter].first->localPositionError() << " with weight " << p; - std::cout << " Component hit type " << typeid(*mymap[counter].first).name() - << " position " << mymap[counter].first->localPosition() - << " \n\terror " << mymap[counter].first->localPositionError() - << " with weight " << p << std::endl; +// std::cout << " Component hit type " << typeid(*mymap[counter].first).name() +// << " position " << mymap[counter].first->localPosition() +// << " \n\terror " << mymap[counter].first->localPositionError() +// << " with weight " << p << std::endl; counter++; } SiTrackerMultiRecHitUpdator::LocalParameters param = calcParameters(tsos, normmap); SiTrackerMultiRecHit updated(param.first, param.second, *normmap.front().first->det(), normmap, annealing); - std::cout << " Updated Hit position " << updated.localPosition() - << " updated error " << updated.localPositionError() << std::endl; +// std::cout << " Updated Hit position " << updated.localPosition() +// << " updated error " << updated.localPositionError() << std::endl; LogTrace("SiTrackerMultiRecHitUpdator") << " Updated Hit position " << updated.localPosition() << " updated error " << updated.localPositionError() << std::endl; diff --git a/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc b/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc index 9eacd64663822..e42240fefccad 100644 --- a/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc +++ b/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc @@ -15,7 +15,7 @@ using namespace std; vector SimpleDAFHitCollector::recHits(const Trajectory& traj, const MeasurementTrackerEvent *theMTE) const{ - std::cout << " Calling SimpleDAFHitCollector::recHits" << std::endl; +// std::cout << " Calling SimpleDAFHitCollector::recHits" << std::endl; //WARNING: At the moment the trajectories has the measurements //with reversed sorting after the track smoothing @@ -28,13 +28,13 @@ vector SimpleDAFHitCollector::recHits(const Trajectory& t for(vector::const_iterator itrajmeas = meas.begin(); itrajmeas < meas.end(); itrajmeas++) { if (itrajmeas->recHit()->isValid()){ - std::cout << " Valid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() - << " local position " << itrajmeas->recHit()->hit()->localPosition() - << " global position " << itrajmeas->recHit()->hit()->globalPosition() << "\n"; +// std::cout << " Valid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() +// << " local position " << itrajmeas->recHit()->hit()->localPosition() +// << " global position " << itrajmeas->recHit()->hit()->globalPosition() << "\n"; LogTrace("MultiRecHitCollector") << "Valid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() << " local position " << itrajmeas->recHit()->hit()->localPosition(); } else { - std::cout << " Invalid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() << std::endl; +// std::cout << " Invalid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() << std::endl; LogTrace("MultiRecHitCollector") << "Invalid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId(); } } @@ -62,12 +62,12 @@ vector SimpleDAFHitCollector::recHits(const Trajectory& t } //collected hits compatible with the itrajmeas if( measDet.measurements(current, *(getEstimator()), tmps)){ - std::cout << " Found " << tmps.size() << " compatible measurements." << std::endl; +// std::cout << " Found " << tmps.size() << " compatible measurements." << std::endl; for (std::size_t i=0; i!=tmps.size(); ++i){ DetId idtemps = tmps.hits[i]->geographicalId(); if( idtemps == id && tmps.hits[i]->hit()->isValid() ) { - std::cout << " This hit is valid and has " << idtemps << " DetId."<< std::endl; +// std::cout << " This hit is valid and has " << idtemps << " DetId."<< std::endl; LogTrace("MultiRecHitCollector") << "This hit is valid "; hits.push_back(tmps.hits[i]->hit()); } @@ -75,7 +75,7 @@ vector SimpleDAFHitCollector::recHits(const Trajectory& t //I will keep the Invalid hit, IF this is not the first one if (hits.empty()){ - std::cout << " No valid hits found in current group.\n "; +// std::cout << " No valid hits found in current group.\n "; LogTrace("MultiRecHitCollector") << "No valid hits found in current group "; if( result.empty() ) continue; @@ -86,14 +86,14 @@ vector SimpleDAFHitCollector::recHits(const Trajectory& t //measurements in groups are sorted with increating chi2 //sort( *hits.begin(), *hits.end(), TrajMeasLessEstim()); - std::cout << " Found " << hits.size() << " valid hits for this sensor.\n"; +// std::cout << " Found " << hits.size() << " valid hits for this sensor.\n"; LogTrace("MultiRecHitCollector") << "Found " << hits.size() << " hits for this sensor"; //building a MultiRecHit out of each sensor group result.push_back(TrajectoryMeasurement(state,theUpdator->buildMultiRecHit(hits, state))); } } else { - std::cout << " No measurements found in current group.\n "; +// std::cout << " No measurements found in current group.\n "; LogTrace("MultiRecHitCollector") << "No valid hits found in current group "; if( result.empty() ) continue; @@ -104,7 +104,7 @@ vector SimpleDAFHitCollector::recHits(const Trajectory& t } } - std::cout << " Ending SimpleDAFHitCollector::recHits >> " << result.size() << std::endl; +// std::cout << " Ending SimpleDAFHitCollector::recHits >> " << result.size() << std::endl; LogTrace("MultiRecHitCollector") << "Original Measurement size " << meas.size() << " GroupedDAFHitCollector returned " << result.size() << " measurements"; //adding a protection against too few hits and invalid hits diff --git a/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc b/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc index e1fae971fb987..2aff73babbd5d 100644 --- a/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc +++ b/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc @@ -36,8 +36,8 @@ void DAFTrackProducerAlgorithm::runWithCandidate(const TrackingGeometry * theG, TrajAnnealingCollection& trajann, bool TrajAnnSaving_) const { - std::cout << "////////////////////////////////////////////////////////\n" - << "DAFTrackProducerAlgorithm::runWithCandidate: Number of Trajectories: " << theTrajectoryCollection.size() << "\n"; +// std::cout << "////////////////////////////////////////////////////////\n" +// << "DAFTrackProducerAlgorithm::runWithCandidate: Number of Trajectories: " << theTrajectoryCollection.size() << "\n"; edm::LogInfo("TrackProducer") << "Number of Trajectories: " << theTrajectoryCollection.size() << "\n"; int cont = 0; @@ -65,7 +65,6 @@ void DAFTrackProducerAlgorithm::runWithCandidate(const TrackingGeometry * theG, for (std::vector::const_iterator ian = updator->getAnnealingProgram().begin(); ian != updator->getAnnealingProgram().end(); ian++){ -std::cout << "Starting with the annealing " << *ian << std::endl; if (currentTraj.isValid()){ LogDebug("DAFTrackProducerAlgorithm") << "Seed direction is " << currentTraj.seed().direction() @@ -190,7 +189,6 @@ Trajectory DAFTrackProducerAlgorithm::fit(const std::pairfitOne(TrajectorySeed(PTrajectoryStateOnDet(), BasicTrajectorySeed::recHitContainer(), diff --git a/TrackingTools/KalmanUpdators/src/MRHChi2MeasurementEstimator.cc b/TrackingTools/KalmanUpdators/src/MRHChi2MeasurementEstimator.cc index 84e27888e2bce..2eb73482965fe 100644 --- a/TrackingTools/KalmanUpdators/src/MRHChi2MeasurementEstimator.cc +++ b/TrackingTools/KalmanUpdators/src/MRHChi2MeasurementEstimator.cc @@ -16,7 +16,7 @@ std::pair MRHChi2MeasurementEstimator::estimate(const TrajectorySt case 2: return estimate<2>(tsos,aRecHit); //avoid the not-2D hit due to the final sum case ( 1 || 3 || 4 || 5 ):{ - std::cout << "WARNING:The hit is not 2D: does not count in the MRH Chi2 estimation." << std::endl; +// std::cout << "WARNING:The hit is not 2D: does not count in the MRH Chi2 estimation." << std::endl; double est = 0.0; return HitReturnType(false, est); } @@ -31,21 +31,19 @@ template std::pair MRHChi2MeasurementEstimator::estimate(const TrajectoryStateOnSurface& tsos, const TrackingRecHit& aRecHit) const { -std::cout << " MRHChi2MeasurementEstimator::estimate " << std::endl; SiTrackerMultiRecHit const & mHit = dynamic_cast(aRecHit); double est=0; double annealing = mHit.getAnnealingFactor(); - std::cout << " Current annealing factor is " << annealing; +// std::cout << " Current annealing factor is " << annealing; LogDebug("MRHChi2MeasurementEstimator") << "Current annealing factor is " << annealing; std::vector components = mHit.recHits(); - std::cout << "; this hit has " << components.size() << " components\n"; +// std::cout << "; this hit has " << components.size() << " components\n"; LogDebug("MRHChi2MeasurementEstimator") << "this hit has " << components.size() << " components"; int iComp = 0; for(std::vector::const_iterator iter = components.begin(); iter != components.end(); iter++, iComp++){ -// for (TransientTrackingRecHit::ConstRecHitContainer::const_iterator iter = components.begin(); iter != components.end(); iter++){ // define variables that will be used to setup the KfComponentsHolder ProjectMatrix pf; @@ -67,7 +65,7 @@ std::cout << " MRHChi2MeasurementEstimator::estimate " << std::endl; edm::LogError("SiTrackerMultiRecHitUpdator")<<"SiTrackerMultiRecHitUpdator::ComputeParameters2dim: W not valid!"< Date: Wed, 11 Jun 2014 12:15:26 +0200 Subject: [PATCH 05/16] cleaning up --- .gitignore | 2 - DAFTest/DAFValidator/macro/HistoHit.C | 210 ------ .../DAFValidator/macro/PlotComparisonMaker.C | 82 -- .../macro/PlotComparisonMaker_v2.C | 67 -- DAFTest/DAFValidator/plugins/BuildFile.xml | 16 - DAFTest/DAFValidator/plugins/DAFValidator.cc | 700 ------------------ DAFTest/DAFValidator/plugins/DAFValidator.h | 147 ---- .../DAFValidator/plugins/DAFValidator_v1.cc | 186 ----- ...rackValidator_DAFValidator_SingleMu_cfg.py | 132 ---- ...tiTrackValidator_DAFValidator_TTbar_cfg.py | 138 ---- .../test/MultiTrackValidator_SingleMu_cfg.py | 87 --- .../test/MultiTrackValidator_TTbar_cfg.py | 93 --- .../plugins/TkPixelMeasurementDet.cc | 1 + .../SiTrackerMRHTools/.admin/CVS/Entries | 2 - .../SiTrackerMRHTools/.admin/CVS/Repository | 1 - RecoTracker/SiTrackerMRHTools/.admin/CVS/Root | 1 - RecoTracker/SiTrackerMRHTools/.admin/CVS/Tag | 1 - .../SiTrackerMRHTools/.admin/developers | 50 -- 18 files changed, 1 insertion(+), 1915 deletions(-) delete mode 100644 DAFTest/DAFValidator/macro/HistoHit.C delete mode 100644 DAFTest/DAFValidator/macro/PlotComparisonMaker.C delete mode 100644 DAFTest/DAFValidator/macro/PlotComparisonMaker_v2.C delete mode 100644 DAFTest/DAFValidator/plugins/BuildFile.xml delete mode 100644 DAFTest/DAFValidator/plugins/DAFValidator.cc delete mode 100644 DAFTest/DAFValidator/plugins/DAFValidator.h delete mode 100644 DAFTest/DAFValidator/plugins/DAFValidator_v1.cc delete mode 100644 DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_SingleMu_cfg.py delete mode 100644 DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_TTbar_cfg.py delete mode 100644 DAFTest/DAFValidator/test/MultiTrackValidator_SingleMu_cfg.py delete mode 100644 DAFTest/DAFValidator/test/MultiTrackValidator_TTbar_cfg.py delete mode 100644 RecoTracker/SiTrackerMRHTools/.admin/CVS/Entries delete mode 100644 RecoTracker/SiTrackerMRHTools/.admin/CVS/Repository delete mode 100644 RecoTracker/SiTrackerMRHTools/.admin/CVS/Root delete mode 100644 RecoTracker/SiTrackerMRHTools/.admin/CVS/Tag delete mode 100644 RecoTracker/SiTrackerMRHTools/.admin/developers diff --git a/.gitignore b/.gitignore index 9095823924977..1a38d6227329c 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,2 @@ __init__.py *.pyc -*.root -*.txt diff --git a/DAFTest/DAFValidator/macro/HistoHit.C b/DAFTest/DAFValidator/macro/HistoHit.C deleted file mode 100644 index d92701694aa1f..0000000000000 --- a/DAFTest/DAFValidator/macro/HistoHit.C +++ /dev/null @@ -1,210 +0,0 @@ - -void drawingPlotFromOneFile(const std::string& datafile) -{ - float x[20] = {0.0, 0.5, 1, 2.5, 5, 10, 25, 50, 100, 10000, 1000000, 10000000, 50000000, 75000000, 100000000, 250000000, 500000000, 750000000, 1000000000, 5000000000}; - TH1F *g = new TH1F("g","histo",19,x);//100,0.5,100.5);//,1,0.5,10000000000); - std::string perc; - std::string line; - int i; - int npar = 5; - std::ifstream inFile; - inFile.open (datafile.c_str(), std::ios::in); - - TF1 *f1 = new TF1("f1","sin(x)/x",-10,10); - - //con parametri esterni - //TF1 *f1 = new TF1("f1","[0]*x*sin([1]*x)",-3,3); - //f1->SetParameter(0,10); - //f1->SetParameter(1,2); - - f1->SetTitle("Disegno di una funzione"); - f1->GetXaxis ()->SetTitle ("x"); - f1->GetYaxis ()->SetTitle ("sin(x)/x"); - f1->GetXaxis ()->CenterTitle (); - f1->GetYaxis ()->CenterTitle (); - - - while(!inFile.eof()) - { - getline(inFile, line); - istringstream iss(line); - string sub; - iss >> sub; - if (sub == "Begin" || sub == "something"){ - std::cin.ignore(256,' '); - } else { - inFile >> perc; - if(atof(perc.c_str())) { - double value = (double)atof(perc.c_str()); - //std::cout<<"Alla riga " <Fill(value*npar); - } - } - i++; - - } - - inFile.close(); - - TCanvas *c = new TCanvas("c_graph","c_graph"); - c->cd(); - c->SetGridy(); - c->SetGridx(); - c->SetTickx(); - c->SetTicky(); - c->SetLogy(); - c->SetLogx(); - - g->SetTitle("TGraph Title"); - g->GetXaxis()->SetTitle("#chi^{2}"); - g->GetYaxis()->SetTitle("N"); - g->SetMarkerStyle(11); - g->SetMarkerColor(6); -// g->SetMinimum(0); -// g->SetMaximum(40); - g->Draw("HISTO"); - f1->Draw("same"); - - c->Print( "histoProva.pdf","pdf" ); - -} - - -void drawingPlotFromTwoFile(const std::string& datafile1, const std::string& datafile2) -{ - TH1F *g = new TH1F("g","chi2",30,0.5,30.5);//,1,0.5,10000000000); - TH1F *g2= new TH1F("g2","chi2_prob",50,0.0,1.0);//,1,0.5,10000000000); - TH1F *h = new TH1F("h","histo2",30,0.5,30.5); - TH1F *h2= new TH1F("h2","chi2_prob2",50,0.0,1.0);//,1,0.5,10000000000); - std::string perc; - std::string line; - int i; - int npar = 5; - double chi2Cut = 100; - std::ifstream inFile1, inFile2; - inFile1.open (datafile1.c_str(), std::ios::in); - inFile2.open (datafile2.c_str(), std::ios::in); - - TF1 *fgamma = new TF1("fgamma", "TMath::GammaDist(x, [0], [1], [2])", 0, 30); - fgamma->SetParameters(npar/2, 0, 2); - - - while(!inFile1.eof()) - { - getline(inFile1, line); - istringstream iss(line); - string sub; - iss >> sub; - if (sub == "Begin" || sub == "something"){ - std::cin.ignore(256,' '); - } else { - inFile1 >> perc; - if(atof(perc.c_str())) { - double value = (double)atof(perc.c_str()); - //std::cout<<"Alla riga " <Fill(value*npar); - - g2->Fill(TMath::Prob(value*npar, npar)); - - } - } - i++; - - } - - inFile1.close(); - i = 0; - - while(!inFile2.eof()) - { - getline(inFile2, line); - istringstream iss(line); - string sub; - iss >> sub; - if (sub == "Begin" || sub == "something"){ - std::cin.ignore(256,' '); - } else { - inFile2 >> perc; - if(atof(perc.c_str())) { - double value = (double)atof(perc.c_str()); - //std::cout<<"Alla riga " <Fill(value*npar); - - h2->Fill(TMath::Prob(value*npar, npar)); - - } - } - i++; - - } - inFile2.close(); - - TCanvas *c = new TCanvas("c_graph","c_graph"); - c->cd(); - c->SetGridy(); - c->SetGridx(); - c->SetTickx(); - c->SetTicky(); -// c->SetLogy(); - - TLegend* legend = new TLegend(0.56, 0.77, 0.76, 0.92); - legend -> SetFillColor(kWhite); - legend -> SetFillStyle(1001); - legend -> SetTextFont(42); - legend -> SetTextSize(0.03); - - legend -> AddEntry(g,"cutsRecoTracks","L"); - legend -> AddEntry(h,"ctfWithMaterialTracksDAF","L"); - legend -> AddEntry(fgamma,"#chi^{2} with 5 dof","l"); - - g->SetTitle("TGraph Title"); - g->GetXaxis()->SetTitle("#chi^{2}"); - g->GetYaxis()->SetTitle("N/N_{tot}"); - g->SetMarkerStyle(11); - g->SetMarkerColor(6); - g->SetLineColor(2); - g -> GetXaxis() -> SetTitleSize(0.03); - g -> GetYaxis() -> SetTitleSize(0.03); - g -> GetXaxis() -> SetLabelSize(0.03); - g -> GetYaxis() -> SetLabelSize(0.03); - h->SetLineColor(4); - h->SetLineWidth(2); -// g->Fit(fgamma); - fgamma->SetLineColor(13); - fgamma->SetLineWidth(2); - fgamma->Draw(); - g->DrawNormalized("sameHISTO"); - h->DrawNormalized("sameHISTO"); - legend->Draw("same"); - fgamma->SetLineColor(13); - fgamma->SetLineWidth(2); - fgamma->Draw("same"); - - c->Print( "histoProva2.pdf","pdf" ); - - legend->Clear(); - legend -> AddEntry(g,"cutsRecoTracks","L"); - legend -> AddEntry(h,"ctfWithMaterialTracksDAF","L"); - - TCanvas *c2 = new TCanvas("c_graph2","c_graph2"); - c2->cd(); - c2->SetGridy(); - c2->SetGridx(); - c2->SetTickx(); - c2->SetTicky(); - //c2->SetLogy(); - g2->GetXaxis()->SetTitle("#chi^{2} prob"); - g2->GetYaxis()->SetTitle("N"); - g2-> GetXaxis() -> SetTitleSize(0.03); - g2-> GetYaxis() -> SetTitleSize(0.03); - g2-> GetXaxis() -> SetLabelSize(0.03); - g2-> GetYaxis() -> SetLabelSize(0.03); - g2->SetLineColor(2); - h2->SetLineColor(4); - h2->SetLineWidth(2); - g2->Draw(); - h2->Draw("same"); - legend->Draw("same"); - c->Print( "histoProva3.pdf","pdf" ); -} - diff --git a/DAFTest/DAFValidator/macro/PlotComparisonMaker.C b/DAFTest/DAFValidator/macro/PlotComparisonMaker.C deleted file mode 100644 index d0dfaec385281..0000000000000 --- a/DAFTest/DAFValidator/macro/PlotComparisonMaker.C +++ /dev/null @@ -1,82 +0,0 @@ -/////////// -// Macro that provide to plot multivalidation varibles for recoTrack and DAF -// variables are: effic,fakerate,dzres_vs_eta_Sigma,pull*,chi2_prob ... -////////// - -#include - -std::string folderName = "/afs/cern.ch/user/e/ebrondol/CMSSWarea/CMSSW_7_1_0_pre8/src/"; -std::string FileName1 = "DQM_V0001_R000000001__TTbar__Normal__10evts.root"; -std::string FileName2 = "DQM_V0001_R000000001__TTbar__DAF__10evs.root"; -std::string baseFolderRootName = "DQMData/Run 1/Tracking/Run summary/Track/"; -std::string Associator = "quickAssociatorByHits"; -//std::string Associator = "AssociatorByChi2"; -//std::string Associator = "AssociatorByPull"; -std::string MultivalLabelTracks1 = "cutsReco"; -std::string MultivalLabelTracks2 = "ctfWithMaterialDAF"; -std::string FolderRootName1 = baseFolderRootName + MultivalLabelTracks2 + "_" + Associator + "/"; -std::string FolderRootName2 = baseFolderRootName + MultivalLabelTracks2 + "_" + Associator + "/"; -//std::string HistoName = "dzres_vs_eta_Sigma"; - -//std::string HistoName = "chi2"; -//std::string HistoName = "assocSharedHit"; -//std::string HistoName = "tracks"; -//std::string HistoName = "pullDz"; -//std::string HistoName = "hits"; - -void PlotComparisonMaker(const char* HistoName) -{ - std::cout << "Plotting " << HistoName << " variable..." << std::endl; - std::string inFileTotalName1 = folderName + FileName1; - std::string inFileTotalName2 = folderName + FileName2; - - std::cout << "InputFile1: " << inFileTotalName1 << std::endl; - std::cout << "InputFile2: " << inFileTotalName2 << std::endl; - - TFile* f1 = TFile::Open(inFileTotalName1.c_str(), "READ"); - TFile* f2 = TFile::Open(inFileTotalName2.c_str(), "READ"); - - std::cout << "InputRootFile1: " << FolderRootName1 << std::endl; - std::cout << "InputRootFile2: " << FolderRootName2 << std::endl; - -// TH1F* histo1 = (TH1F*)( f1->Get((FolderRootName1+HistoName).c_str()) ); -// TH1F* histo2 = (TH1F*)( f2->Get((FolderRootName2+HistoName).c_str()) ); - TH1F* histo1 = (TH1F*)( f1->FindObjectAny("effic")); - TH1F* histo2 = (TH1F*)( f2->FindObjectAny("effic")); - - TCanvas* c1 = new TCanvas(); - c1 -> cd(); - c1 -> SetGridx(); - c1 -> SetGridy(); - - histo1 -> SetMarkerColor(2); - histo1 -> SetLineColor(2); - histo1 -> SetLineWidth(2); - histo2 -> SetMarkerColor(4); - histo2 -> SetLineColor(4); - histo1 -> GetYaxis() -> SetTitle("Number of Events"); - histo1 -> GetXaxis() -> SetTitle("#chi^{2}"); - histo1 -> GetXaxis() -> SetTitleSize(0.03); - histo1 -> GetYaxis() -> SetTitleSize(0.03); - histo1 -> GetXaxis() -> SetLabelSize(0.03); - histo1 -> GetYaxis() -> SetLabelSize(0.03); - - TLegend* legend = new TLegend(0.16, 0.77, 0.30, 0.92); - legend -> SetFillColor(kWhite); - legend -> SetFillStyle(1001); - legend -> SetTextFont(42); - legend -> SetTextSize(0.03); - - legend -> AddEntry(histo1,("cutsRecoTracks - "+Associator).c_str(),"PL"); - legend -> AddEntry(histo2,("ctfWithMaterialTracksDAF - "+Associator).c_str(),"PL"); - -// histo1 -> Draw("Histo"); -// histo2 -> Draw("Histosame"); - histo1 -> Draw("P"); - histo2 -> Draw("Psame"); - legend -> Draw("same"); - - c1 -> Print((string(HistoName)+"Comparison.pdf").c_str(), "pdf"); - c1 -> Print((string(HistoName)+"Comparison.png").c_str(), "png"); -// c1 -> SaveAs((string(HistoName)+"Comparison.C").c_str()); -} diff --git a/DAFTest/DAFValidator/macro/PlotComparisonMaker_v2.C b/DAFTest/DAFValidator/macro/PlotComparisonMaker_v2.C deleted file mode 100644 index 09ffc6a3e6ca8..0000000000000 --- a/DAFTest/DAFValidator/macro/PlotComparisonMaker_v2.C +++ /dev/null @@ -1,67 +0,0 @@ -//////// -// Macro that provide to plot multivalidation varibles for DAFValidator class -////////// - -#include - -std::string folderName = "/afs/cern.ch/user/e/ebrondol/CMSSWarea/CMSSW_7_1_0_pre5/src/DAFTest/DAFValidator/MultiTrackValidator/"; -std::string FileName1 = "DAFValidator_SingleMuPt10_100evts_v3_TrackAssocByPull.root"; -std::string FileName2 = "DAFValidator_TTbar_10evts_v3_TrackAssocByPull.root"; -std::string baseFolderRootName = "demo/"; -std::string HistoName = "Weight"; - -//void PlotComparisonMaker_v2(const char* HistoName) -void PlotComparisonMaker_v2() -{ - std::cout << "Plotting " << HistoName << " variable..." << std::endl; - std::string inFileTotalName1 = folderName + FileName1; - std::string inFileTotalName2 = folderName + FileName2; - - std::cout << "InputFile1: " << inFileTotalName1 << std::endl; - std::cout << "InputFile2: " << inFileTotalName2 << std::endl; - - TFile* f1 = TFile::Open(inFileTotalName1.c_str(), "READ"); - TFile* f2 = TFile::Open(inFileTotalName2.c_str(), "READ"); - - TH1F* histo1 = (TH1F*)( f1->Get((baseFolderRootName+HistoName).c_str()) ); - TH1F* histo2 = (TH1F*)( f2->Get((baseFolderRootName+HistoName).c_str()) ); - - TCanvas* c1 = new TCanvas(); - c1 -> cd(); - c1 -> SetGridx(); - c1 -> SetGridy(); - - histo1 -> SetMarkerColor(2); - histo1 -> SetLineColor(2); - histo1 -> SetLineWidth(2); - histo2 -> SetMarkerColor(4); - histo2 -> SetLineColor(4); - histo1 -> GetXaxis() -> SetTitle(HistoName.c_str()); - histo1 -> GetYaxis() -> SetTitle("Number of events"); - histo1 -> GetXaxis() -> SetTitleSize(0.03); - histo1 -> GetYaxis() -> SetTitleSize(0.03); - histo1 -> GetXaxis() -> SetLabelSize(0.03); - histo1 -> GetYaxis() -> SetLabelSize(0.03); - - TLegend* legend = new TLegend(0.16, 0.77, 0.30, 0.92); - legend -> SetFillColor(kWhite); - legend -> SetFillStyle(1001); - legend -> SetTextFont(42); - legend -> SetTextSize(0.03); - - legend -> AddEntry(histo1,"SingleMuPt10","PL"); - legend -> AddEntry(histo2,"TTbar","PL"); - - histo1 -> DrawNormalized(); - histo2 -> DrawNormalized("same"); -// histo1 -> Draw("Histo"); -// histo2 -> Draw("Histosame"); -// histo1 -> Draw("P"); -// histo2 -> Draw("Psame"); - legend -> Draw("same"); - - c1 -> Print((string(HistoName)+".pdf").c_str(), "pdf"); - c1 -> Print((string(HistoName)+".png").c_str(), "png"); -// c1 -> SaveAs((string(HistoName)+"Comparison.C").c_str()); -} - diff --git a/DAFTest/DAFValidator/plugins/BuildFile.xml b/DAFTest/DAFValidator/plugins/BuildFile.xml deleted file mode 100644 index 7291e72584726..0000000000000 --- a/DAFTest/DAFValidator/plugins/BuildFile.xml +++ /dev/null @@ -1,16 +0,0 @@ - - - - - - - - - - - - - - - - diff --git a/DAFTest/DAFValidator/plugins/DAFValidator.cc b/DAFTest/DAFValidator/plugins/DAFValidator.cc deleted file mode 100644 index a7ca83afb0cfd..0000000000000 --- a/DAFTest/DAFValidator/plugins/DAFValidator.cc +++ /dev/null @@ -1,700 +0,0 @@ -#include "DAFTest/DAFValidator/plugins/DAFValidator.h" - -#include "TrackingTools/PatternTools/interface/Trajectory.h" -#include "TrackingTools/PatternTools/interface/TrajAnnealing.h" -#include "FWCore/Framework/interface/ESHandle.h" -#include "FWCore/MessageLogger/interface/MessageLogger.h" -#include "FWCore/Utilities/interface/Exception.h" -#include "FWCore/Utilities/interface/InputTag.h" -#include "SimTracker/TrackAssociation/interface/TrackAssociatorBase.h" -#include "SimTracker/Records/interface/TrackAssociatorRecord.h" -#include "SimTracker/TrackerHitAssociation/interface/TrackerHitAssociator.h" -#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h" -#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h" -#include "DataFormats/GeometryVector/interface/LocalPoint.h" -#include "TrackingTools/PatternTools/interface/TrajectoryMeasurement.h" -#include "DataFormats/TrackerRecHit2D/interface/SiPixelRecHit.h" -#include "DataFormats/TrackerRecHit2D/interface/SiStripRecHit2D.h" -#include "DataFormats/TrackerRecHit2D/interface/SiStripMatchedRecHit2D.h" -#include "DataFormats/TrackerRecHit2D/interface/ProjectedSiStripRecHit2D.h" -#include "DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h" -#include "TrackingTools/PatternTools/interface/TrajTrackAssociation.h" -#include "DataFormats/TrackingRecHit/interface/TrackingRecHitFwd.h" -#include "SimDataFormats/TrackingHit/interface/PSimHit.h" - -using namespace std; -using namespace edm; -typedef TransientTrackingRecHit::ConstRecHitPointer ConstRecHitPointer; - - -int event = 0; - -DAFValidator::DAFValidator(const edm::ParameterSet& iConfig): - theConf_(iConfig), - tracksTag_(iConfig.getUntrackedParameter("tracks")), - trackingParticleTag_(iConfig.getParameter("trackingParticleLabel")), - associatorTag_(iConfig.getUntrackedParameter("associator")) -{ - //now do what ever initialization is needed - edm::Service fs; - annealing_weight = fs->make("AnnWeight","Changing of weights as a funct of annealing", 1000, 0.0, 1.0, 100, -1, 90); - annealing_weight_tgraph1 = fs->make(); - annealing_weight_tgraph2 = fs->make(); - annealing_weight_tgraph3 = fs->make(); - annealing_weight_tgraph4 = fs->make(); - annealing_weight_tgraph5 = fs->make(); - annealing_weight_tgraph6 = fs->make(); - annealing_weight_tot = fs->make(); - - //histos - histo_maxweight = fs->make("Weight", "max weight of the mrh components ", 110, 0, 1.1); - processtype_withassociatedsimhit_merged = fs->make("Process_Type_merged", "type of the process(merged_simhit)", 20, 0, 20); - processtype_withassociatedsimhit = fs->make("Process_Type", "type of the process", 20, 0, 20); - Hit_Histo = fs->make("Momentum_of_Hit", "momentum of the hit", 100, 0, 100); - MergedHisto = fs->make("Histogram_Hit_Merged", "type of the hit", 5, 0, 5); - NotMergedHisto = fs->make("Histogram_Hit_NotMerged", "type of the hit", 5, 0, 5); - weight_vs_processtype_merged = fs->make("WeightVsProcessType", "weight vs proc type", 20, 0, 20, 110, 0, 1.1 ); - weight_vs_processtype_notmerged = fs->make("WeightVsProcessTypeNotMerged", "weight vs proc type not merged", 20, 0, 20, 110, 0, 1.1 ); - pull_vs_weight = fs->make("PullVsWeight", "pull vs weight", 100, 0, 20, 110, 0, 1.1 ); - Merged_vs_weight = fs->make("HitsMergedVsWeight", "hits vs weight", 5, 0, 5, 110, 0, 1.1 ); - NotMerged_vs_weight = fs->make("HitsNotMergedVsWeight", "hits vs weight", 5, 0, 5, 110, 0, 1.1 ); - NotMergedPos = fs->make("BadHitsPositionNotMerged", "badposition", 600, -30, 30, 2400, -1200, 1200); - MergedPos = fs->make("BadHitsPositionMerged()", "badposition", 600, -30, 30, 2400, -1200, 1200); - -} - -DAFValidator::~DAFValidator() -{ - - // do anything here that needs to be done at desctruction time - // (e.g. close files, deallocate resources etc.) - -} - -// ------------ method called for each event ------------ -void -DAFValidator::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) -{ - using namespace reco; - event++; - - //get the track collection - Handle> trackCollection; - iEvent.getByLabel(tracksTag_, trackCollection); - - //get the trajectory annealing collection - Handle trajAnnCollection; - iEvent.getByLabel(tracksTag_, trajAnnCollection); - - //get the association map between Traj and Track - Handle assoMap; - iEvent.getByLabel(tracksTag_, assoMap); - - int nAnnealing = 1; - for(TrajAnnealingCollection::const_iterator iTA = trajAnnCollection->begin() ; - iTA != trajAnnCollection->end(); iTA++){ - //iTA->Debug(); - std::vector Weights = iTA->weights(); - float ann; - ann = iTA->getAnnealing(); - for(unsigned int i = 0; i < Weights.size(); i++) - { - if(nAnnealing == 1){ - annealing_weight_tgraph1->SetPoint(nHitsAnn1,Weights.at(i),ann); - nHitsAnn1++; - } - if(nAnnealing == 2){ - annealing_weight_tgraph2->SetPoint(nHitsAnn2,Weights.at(i),ann); - nHitsAnn2++; - } - if(nAnnealing == 3){ - annealing_weight_tgraph3->SetPoint(nHitsAnn3,Weights.at(i),ann); - nHitsAnn3++; - } - if(nAnnealing == 4){ - annealing_weight_tgraph4->SetPoint(nHitsAnn4,Weights.at(i),ann); - nHitsAnn4++; - } - if(nAnnealing == 5){ - annealing_weight_tgraph5->SetPoint(nHitsAnn5,Weights.at(i),ann); - nHitsAnn5++; - } - if(nAnnealing == 6){ - annealing_weight_tgraph6->SetPoint(nHitsAnn6,Weights.at(i),ann); - nHitsAnn6++; - } - annealing_weight->Fill(Weights.at(i),ann); - } - if(nAnnealing == 6) nAnnealing = 1; - else nAnnealing++; - } - - - //CMSSW_5_1_3 - //get tracker geometry - ESHandle tkgeom; - iSetup.get().get(tkgeom); - - //get the tracking particle collection - Handle trackingParticleCollection; - iEvent.getByLabel(trackingParticleTag_, trackingParticleCollection); - // float SimTracknum=trackingParticleCollection->size(); - - //hit associator :: CHECK IT - TrackerHitAssociator hitAssociate(iEvent, theConf_); - - //track associator (tracking particles to the reco track) - ESHandle associatorHandle; - iSetup.get().get(associatorTag_,associatorHandle); - reco::RecoToSimCollection RecsimColl = associatorHandle->associateRecoToSim(trackCollection, trackingParticleCollection, &iEvent, &iSetup); - - //loop over the recotrack looking for corresponding trackingparticle - int i = 0; - int nSimu = 0; - - for(TrajTrackAssociationCollection::const_iterator it = assoMap->begin();it != assoMap->end(); ++it){ - - std::map trackid; - - const edm::Ref > traj = it->key; - - const reco::TrackRef trackref = it->val; - trackid.insert(make_pair(trackref,i)); - edm::RefToBase track(trackCollection,i); - i++; - vector > simTracks; - TrackingParticleRef matchedSimTrack; - int nSim = 0; - - if(RecsimColl.find(track) != RecsimColl.end()){ - - simTracks=RecsimColl[track]; - float fractionmax=0; - for(vector >::const_iterator it = simTracks.begin(); it != simTracks.end(); ++it) - { - TrackingParticleRef simTrack = it->first; - float fraction = it->second; - - //pick the trackingparticle with the highest fraction of hishared hits - if(fraction > fractionmax) - { - matchedSimTrack = simTrack; - fractionmax=fraction; - nSim++; } - } - - analyzeHits(matchedSimTrack.get(), track.get(), hitAssociate, traj, tkgeom.product(), event); - nSimu++; - - } - } -} -//-------------------------------------------------------------------------------------- -void DAFValidator::analyzeHits(const TrackingParticle* tpref, - const reco::Track* rtref, - TrackerHitAssociator& hitassociator, - const edm::Ref > traj_iterator, - const TrackerGeometry* geom, - int event) { - - - if (!tpref || !rtref) { - cout << "something wrong: tpref = " << tpref << " rtref = " << rtref << endl; - return; - } - - //loop over the reco track rec hits, associate the simhits - trackingRecHit_iterator iter; - std::vector measurements =traj_iterator->measurements(); - std::vector::iterator traj_mes_iterator; - - for(traj_mes_iterator=measurements.begin();traj_mes_iterator!=measurements.end();traj_mes_iterator++){ - const TrackingRecHit* ttrh=traj_mes_iterator->recHit()->hit(); - - const SiTrackerMultiRecHit* mrh = dynamic_cast(ttrh); - const TrackingRecHit* rechit=0; - float maxweight = 0; - if (mrh){ - vector components = mrh->recHits(); - vector::const_iterator icomp; - int hitcounter=0; - for (icomp = components.begin(); icomp != components.end(); icomp++) { - if((*icomp)->isValid()) - { - //extract the hit with the max weight from the multirechit - weight = mrh->weight(hitcounter); - if(weight > maxweight) { - rechit=*icomp; - maxweight=weight; - } - } - - hitcounter++; - } - } - - else{ - if(ttrh->isValid()){ - rechit=ttrh; - maxweight=1; - } - } - if(rechit){ - - if (getType(rechit)==2.) - { - std::vector hits = rechit->recHits(); - - for(std::vector::iterator iterhits=hits.begin();iterhits!=hits.end();iterhits++) - { - const TrackingRecHit* rechit1 = *iterhits; - - LocalPoint pos; - if(rechit1->isValid()) pos=rechit1->localPosition(); - //unsigned int detid=rechit->geographicalId().rawId(); - - TrajectoryStateOnSurface tsos = traj_mes_iterator->updatedState(); - - AlgebraicVector tsospos(2); - tsospos[0]=tsos.localPosition().x(); - tsospos[1]=tsos.localPosition().y(); - - AlgebraicVector hitposition(2); - hitposition[0]=pos.x(); - hitposition[1]=pos.y(); - - AlgebraicVector tsoserr(3); - tsoserr[0] = tsos.localError().positionError().xx(); - tsoserr[1] = tsos.localError().positionError().yy(); - tsoserr[2] = tsos.localError().positionError().xy(); - - AlgebraicVector hiterr(3); - hiterr[0] = rechit1->localPositionError().xx(); - hiterr[1] = rechit1->localPositionError().yy(); - hiterr[2] = rechit1->localPositionError().xy(); - - tsoslocalx = tsospos[0]; - tsoslocaly = tsospos[1]; - - hitlocalx = hitposition[0]; - hitlocaly = hitposition[1]; - - tsoslocalsigmax = tsoserr[0]; - tsoslocalsigmay = tsoserr[1]; - tsoslocalcov = tsoserr[2]; - - hitlocalsigmax = hiterr[0]; - hitlocalsigmay = hiterr[1]; - hitlocalcov = hiterr[2]; - - nevent=event; - weight=maxweight; - GlobalPoint point=getGlobalPosition(rechit1,geom); - r=point.perp(); - zeta=point.z(); - phi=point.phi(); - hittype=getType(rechit1); - detId=rechit->geographicalId().rawId(); - - //ERICA :: fixed hit associator !! - //do the association between rechits and simhits - vector matchedhits; - vector simhitids; - matchedhits = hitassociator.associateHit(*rechit1); - simhitids = hitassociator.associateHitId(*rechit1); - fillDAFHistos(matchedhits, maxweight, rechit1, geom); - fillPHistos(matchedhits); - - if(matchedhits.size()!=1){ - notmergedtype=0; - mergedtype=fillMergedHisto(simhitids,matchedhits,tpref,maxweight,geom); - - } - - else{ - - mergedtype=0; - notmergedtype=fillNotMergedHisto(simhitids,matchedhits,tpref,maxweight,geom); - - } - - mrhit->Fill(); - } - } - - else { - LocalPoint pos; - if(rechit->isValid()) pos=rechit->localPosition(); - //unsigned int detid=rechit->geographicalId().rawId(); - - TrajectoryStateOnSurface tsos = traj_mes_iterator->updatedState(); - - AlgebraicVector tsospos(2); - tsospos[0]=tsos.localPosition().x(); - tsospos[1]=tsos.localPosition().y(); - - AlgebraicVector hitposition(2); - hitposition[0]=pos.x(); - hitposition[1]=pos.y(); - - AlgebraicVector tsoserr(3); - tsoserr[0] = tsos.localError().positionError().xx(); - tsoserr[1] = tsos.localError().positionError().yy(); - tsoserr[2] = tsos.localError().positionError().xy(); - - AlgebraicVector hiterr(3); - hiterr[0] = rechit->localPositionError().xx(); - hiterr[1] = rechit->localPositionError().yy(); - hiterr[2] = rechit->localPositionError().xy(); - - tsoslocalx = tsospos[0]; - tsoslocaly = tsospos[1]; - - hitlocalx = hitposition[0]; - hitlocaly = hitposition[1]; - - tsoslocalsigmax = tsoserr[0]; - tsoslocalsigmay = tsoserr[1]; - tsoslocalcov = tsoserr[2]; - - hitlocalsigmax = hiterr[0]; - hitlocalsigmay = hiterr[1]; - hitlocalcov = hiterr[2]; - - nevent=event; - weight=maxweight; - GlobalPoint point=getGlobalPosition(rechit,geom); - r=point.perp(); - zeta=point.z(); - phi=point.phi(); - hittype=getType(rechit); - detId=rechit->geographicalId().rawId(); - - //ERICA :: fixed hit associator !! - //do the association between rechits and simhits - vector matchedhits; - vector simhitids; - matchedhits = hitassociator.associateHit(*rechit); - simhitids = hitassociator.associateHitId(*rechit); - fillDAFHistos(matchedhits, maxweight, rechit, geom); - fillPHistos(matchedhits); - - if(matchedhits.size()!=1){ - notmergedtype=0; - mergedtype=fillMergedHisto(simhitids,matchedhits,tpref,maxweight,geom); - } - - else{ - mergedtype=0; - notmergedtype=fillNotMergedHisto(simhitids,matchedhits,tpref,maxweight,geom); - } - - mrhit->Fill(); - - } - - } - - } -} - -// ------------ method called once each job just before starting event loop ------------ -void DAFValidator::beginJob() -{ - -} - -// ------------ method called once each job just after ending the event loop ------------ -void DAFValidator::endJob() -{ - -} - -// ------------ method called when starting to processes a run ------------ -void DAFValidator::beginRun(edm::Run const&, edm::EventSetup const&) -{ - int bufsize = 64000; - mrhit = new TTree("Ntuple","Ntuple"); - mrhit->Branch("mergedtype" , &mergedtype , "mergedtype/I" , bufsize); - mrhit->Branch("notmergedtype" , ¬mergedtype , "notmergedtype/I" , bufsize); - mrhit->Branch("weight" , &weight , "weight/F" , bufsize); - mrhit->Branch("detId" , &detId , "detId/I" , bufsize); - mrhit->Branch("r" , &r , "r/F" , bufsize); - mrhit->Branch("zeta" , &zeta , "zeta/F" , bufsize); - mrhit->Branch("phi" , &phi , "phi/F" , bufsize); - mrhit->Branch("hittyipe" , &hittype , "hittype/F" , bufsize); - mrhit->Branch("event" , &nevent , "nevent/I" , bufsize); - - - - mrhit->Branch("hitlocalx" , &hitlocalx , "hitlocalx/F" , bufsize); - mrhit->Branch("hitlocaly" , &hitlocaly , "hitlocaly/F" , bufsize); - mrhit->Branch("hitlocalsigmax" , &hitlocalsigmax , "hitlocalsigmax/F" , bufsize); - mrhit->Branch("hitlocalsigmay" , &hitlocalsigmay , "hitlocalsigmay/F" , bufsize); - mrhit->Branch("hitlocalcov" , &hitlocalcov , "hitlocalcov/F" , bufsize); - mrhit->Branch("tsoslocalx" , &tsoslocalx , "tsoslocalx/F" , bufsize); - mrhit->Branch("tsoslocaly" , &tsoslocaly , "tsoslocaly/F" , bufsize); - mrhit->Branch("tsoslocalsigmax" , &tsoslocalsigmax , "tsoslocalsigmax/F" , bufsize); - mrhit->Branch("tsoslocalsigmay" , &tsoslocalsigmay , "tsoslocalsigmay/F" , bufsize); - mrhit->Branch("tsoslocalcov" , &tsoslocalcov , "tsoslocalcov/F" , bufsize); - mrhit->Branch("RecoTracknum" , &tsoslocalcov , "tsoslocalcov/F" , bufsize); - mrhit->Branch("SimTracknum" , &tsoslocalcov , "tsoslocalcov/F" , bufsize); - - event=0; - mergedtype=0; - notmergedtype=0; - nHitsAnn1=0; - nHitsAnn2=0; - nHitsAnn3=0; - nHitsAnn4=0; - nHitsAnn5=0; - nHitsAnn6=0; - -} - - -// ------------ method called when ending the processing of a run ------------ -void DAFValidator::endRun(edm::Run const&, edm::EventSetup const&) -{ - //drawing - TCanvas* c = new TCanvas(); - c -> cd(); - c -> SetGridx(); - c -> SetGridy(); - - annealing_weight_tgraph1 -> SetMarkerColor(2); - annealing_weight_tgraph1 -> SetLineColor(2); - annealing_weight_tgraph1 -> SetMarkerStyle(10); - annealing_weight_tgraph2 -> SetMarkerColor(3); - annealing_weight_tgraph2 -> SetLineColor(3); - annealing_weight_tgraph2 -> SetMarkerStyle(10); - annealing_weight_tgraph3 -> SetMarkerColor(4); - annealing_weight_tgraph3 -> SetLineColor(4); - annealing_weight_tgraph3 -> SetMarkerStyle(10); - annealing_weight_tgraph4 -> SetMarkerColor(7); - annealing_weight_tgraph4 -> SetLineColor(7); - annealing_weight_tgraph4 -> SetMarkerStyle(10); - annealing_weight_tgraph4 -> SetMarkerSize(3); - annealing_weight_tgraph5 -> SetMarkerColor(6); - annealing_weight_tgraph5 -> SetLineColor(6); - annealing_weight_tgraph5 -> SetMarkerStyle(10); - annealing_weight_tgraph5 -> SetMarkerSize(2); - annealing_weight_tgraph6 -> SetMarkerColor(97); - annealing_weight_tgraph6 -> SetLineColor(97); - annealing_weight_tgraph6 -> SetMarkerStyle(10); - - annealing_weight_tot -> SetTitle(" ;weights;annealing value"); - annealing_weight_tot -> Add(annealing_weight_tgraph1); - annealing_weight_tot -> Add(annealing_weight_tgraph2); - annealing_weight_tot -> Add(annealing_weight_tgraph3); - annealing_weight_tot -> Add(annealing_weight_tgraph4); - annealing_weight_tot -> Add(annealing_weight_tgraph5); - annealing_weight_tot -> Add(annealing_weight_tgraph6); - annealing_weight_tot -> Draw("ap"); - -// c->Print("annweighttgraphPlot.pdf", "pdf"); -// c->SaveAs("annweighttgraphPlot.C"); - - -} - -// ------------ method fills 'descriptions' with the allowed parameters for the module ------------ -void DAFValidator::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { - //The following says we do not know what parameters are allowed so do no validation - // Please change this to state exactly what you do use, even if it is no parameters - edm::ParameterSetDescription desc; - desc.setUnknown(); - descriptions.addDefault(desc); - - //Specify that only 'tracks' is allowed - //To use, remove the default given above and uncomment below - //ParameterSetDescription desc; - //desc.addUntracked("tracks","ctfWithMaterialTracks"); - //descriptions.addDefault(desc); -} -//------------------------------------------------------------------------------------------------------ -void DAFValidator::fillDAFHistos(std::vector& matched, - float weight, - const TrackingRecHit* rechit, - const TrackerGeometry* geom){ - //this could be filled without matching - histo_maxweight->Fill(weight); - - //check the hit validity - if (!matched.size()){ - edm::LogError("DAFValidator") << "fillDAFHistos: this multirechit has no corresponding simhits"; - return; - } - - unsigned short ptype; - - if (matched.size()==1) - { - - float pull=calculatepull(rechit, matched.front(), geom); - pull_vs_weight->Fill(pull,weight); - - ptype = matched.front().processType(); - processtype_withassociatedsimhit->Fill(ptype); - weight_vs_processtype_notmerged->Fill(ptype, weight); - - } - - else if (matched.size()>1) - { - - for(vector::iterator imatched=matched.begin(); imatched!=matched.end(); imatched++ ) - { - float pull=calculatepull(rechit, (*imatched), geom); - pull_vs_weight->Fill(pull,weight); - - ptype = imatched->processType(); - processtype_withassociatedsimhit_merged->Fill(ptype); - weight_vs_processtype_merged->Fill(ptype, weight); - } - } - - -} -//------------------------------------------------------------------------------------------------------ -float DAFValidator::calculatepull(const TrackingRecHit* hit, - PSimHit simhit, - const TrackerGeometry* geom){ - - //perform the calculation of the pull - AlgebraicVector reccoor(2); - AlgebraicVector simcoor(2); - AlgebraicVector diffcoor(2); - - //reccoor[0] = getGlobalPositionRec(hit, geom).x(); - //reccoor[1] = getGlobalPositionRec(hit, geom).y(); - - //simcoor[0] = getGlobalPositionSim(simhit, geom).x(); - //simcoor[1] = getGlobalPositionSim(simhit, geom).y(); - - reccoor[0] = hit->localPosition().x(); - reccoor[1] = hit->localPosition().y(); - - simcoor[0] = simhit.localPosition().x(); - simcoor[1] = simhit.localPosition().y(); - - diffcoor = reccoor-simcoor; - float diff = sqrt(diffcoor[0]*diffcoor[0]+diffcoor[1]*diffcoor[1]); - - float sigma = sqrt((hit->localPositionError().xx() + hit->localPositionError().yy()+ hit->localPositionError().xy())); - float pull = diff/sigma; - - return pull; - //return diff; -} -//------------------------------------------------------------------------------------------------------ -void DAFValidator::fillPHistos(std::vector& components){ - //check the hit validity - if (!components.size()){ - edm::LogError("DAFValidator") << "fillPHistos: this multirechit has no hits"; - return; - } - - for(vector::iterator icomp=components.begin(); icomp!=components.end(); icomp++ ) - { - float pabs = icomp->pabs(); - Hit_Histo->Fill(pabs); - } -} -//------------------------------------------------------------------------------------------------------ -int DAFValidator::fillMergedHisto(const std::vector& simhitids, const std::vector& simhits, - const TrackingParticle* tpref, float weight, const TrackerGeometry* geom) const -{ - - if (simhitids.empty()) {cout << "something wrong" << endl;} - GlobalPoint point; - //unsigned int simcount=0; - for (TrackingParticle::g4t_iterator g4T = tpref -> g4Track_begin(); g4T != tpref -> g4Track_end(); ++g4T){ - //vector::const_iterator isimid; - vector::const_iterator isimid; - // unsigned int simcount=0; - //for (isimid = simhitids.begin(); isimid != simhitids.end(); isimid++){ - //in case of merged hits we have to make a for cicle - for(isimid = simhits.begin(); isimid != simhits.end(); isimid++){ - - if (((*g4T).trackId() == (*isimid).trackId()) || (isimid->processType() == 2)){ - return 2; - } - else continue; - } - } - return 1; -} -//------------------------------------------------------------------------------------------------------ -int DAFValidator::fillNotMergedHisto(const std::vector& simhitids, const std::vector& simhits, - const TrackingParticle* tpref, float weight, const TrackerGeometry* geom) const -{ - if (simhitids.empty()) {cout << "something wrong" << endl;} - - vector::const_iterator isimid = simhits.begin(); - //int simcount=0; - if ( isimid->processType() == 2) - { - for (TrackingParticle::g4t_iterator g4T = tpref -> g4Track_begin(); g4T != tpref -> g4Track_end(); ++g4T){ - //vector::const_iterator isimid; - // int simcount=0; - if ((*g4T).trackId()==isimid->trackId()) return 3; - } - } - - else { - for (TrackingParticle::g4t_iterator g4T = tpref -> g4Track_begin(); g4T != tpref -> g4Track_end(); ++g4T){ - //vector::const_iterator isimid; - // int simcount=0; - if ((*g4T).trackId()==isimid->trackId()) return 2; - } - } - - return 1; -} -//------------------------------------------------------------------------------------------------------ - - -float DAFValidator::getType(const TrackingRecHit* hit) const { - if (!hit->isValid()){ - throw cms::Exception("DAFValidator") << "This hit is invalid, cannot be casted as any type of tracker hit (strip or pixel)! "; - } - const SiPixelRecHit* pixhit = dynamic_cast(hit); - const SiStripRecHit2D* stripmono = dynamic_cast(hit); - const SiStripMatchedRecHit2D* stripmatched = dynamic_cast(hit); - const ProjectedSiStripRecHit2D* stripprojected = dynamic_cast(hit); - if(pixhit) return 0.; - else if (stripmono) return 1.; - else if (stripmatched) return 2.; - else if (stripprojected) return 3.; - else throw cms::Exception("DAFValidator") << "Rec Hits of type " << typeid(*hit).name() << " should not be present at this stage "; -} -//--------------------------------------------------------------------------------------------------------- -GlobalPoint DAFValidator::getGlobalPositionSim(const PSimHit hit, const TrackerGeometry* geom) const{ - - cout << "detid" << hit << endl; - DetId detid = DetId(hit.detUnitId()); - - //const GeomDet* gdet = geom->idToDet(hit.detUnitId()); - const GeomDet* gdet = geom->idToDet(detid); - GlobalPoint global = gdet->toGlobal(hit.localPosition()); - return global; -} -//--------------------------------------------------------------------------------------------------------- -GlobalPoint DAFValidator::getGlobalPosition(const TrackingRecHit* hit, const TrackerGeometry* geom) const{ - const GeomDet* gdet = geom->idToDet(hit->geographicalId()); - GlobalPoint global = gdet->toGlobal(hit->localPosition()); - return global; -} - -//--------------------------------------------------------------------------------------------------------- -/*std::pair > DAFValidator::getAnnealingWeight( const TrackingRecHit& aRecHit ) const { - - SiTrackerMultiRecHit const & mHit = dynamic_cast(aRecHit); - return make_pair(mHit.getAnnealingFactor(), mHit.weights()); - -}*/ -// -DEFINE_FWK_MODULE(DAFValidator); - - diff --git a/DAFTest/DAFValidator/plugins/DAFValidator.h b/DAFTest/DAFValidator/plugins/DAFValidator.h deleted file mode 100644 index 3c8ab5d18f27a..0000000000000 --- a/DAFTest/DAFValidator/plugins/DAFValidator.h +++ /dev/null @@ -1,147 +0,0 @@ -/** \class DAFValidator - * An analyzer suitable for multitrack - * fitting algorithm like DAF, MTF and EA - * - * \author tropiano, genta (?) - * \review in May 2014 by brondolin - */ - -#ifndef DAFValidator_h -#define DAFValidator_h - -#include -#include -#include - -// user include files -#include "FWCore/Framework/interface/Frameworkfwd.h" -#include "FWCore/Framework/interface/EDAnalyzer.h" - -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/Framework/interface/MakerMacros.h" - -#include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "FWCore/Utilities/interface/InputTag.h" -#include "DataFormats/GeometryVector/interface/GlobalPoint.h" -#include "DataFormats/TrackingRecHit/interface/TrackingRecHitFwd.h" -#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticleFwd.h" -#include "DataFormats/TrackReco/interface/Track.h" -#include "DataFormats/TrackReco/interface/TrackFwd.h" -#include "TrackingTools/PatternTools/interface/Trajectory.h" -#include "SimTracker/TrackerHitAssociation/interface/TrackerHitAssociator.h" - -#include "FWCore/ServiceRegistry/interface/Service.h" -#include "CommonTools/UtilAlgos/interface/TFileService.h" -#include "TH1.h" -#include "TH2F.h" -#include "TTree.h" -#include "TFile.h" -#include "TGraph.h" -#include "TMultiGraph.h" -#include "TCanvas.h" - -class TrackerHitAssociator; -class TrackerGeometry; -class PSimHit; - -class DAFValidator : public edm::EDAnalyzer -{ - public: - explicit DAFValidator(const edm::ParameterSet& conf); - ~DAFValidator(); - - static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); - - virtual void beginJob() override; - virtual void beginRun(edm::Run const&, edm::EventSetup const&) override; - virtual void analyze(const edm::Event&, const edm::EventSetup&) override; - virtual void endRun(edm::Run const&, edm::EventSetup const&) override; - virtual void endJob() override; - - void analyzeHits(const TrackingParticle* tpref, const reco::Track* rtref, - TrackerHitAssociator& hitassociator, - const edm::Ref > traj_iterator, - const TrackerGeometry* geom, - int event); - GlobalPoint getGlobalPositionSim(const PSimHit hit, const TrackerGeometry* geom) const; - GlobalPoint getGlobalPosition(const TrackingRecHit* hit, const TrackerGeometry* geom) const; - void fillDAFHistos(std::vector& matched, float weight, - const TrackingRecHit* rechit, const TrackerGeometry* geom); - float calculatepull(const TrackingRecHit* hit, PSimHit simhit, const TrackerGeometry* geom); - void fillPHistos(std::vector& components); - int fillMergedHisto(const std::vector& simhitids, const std::vector& simhits, - const TrackingParticle* tpref, float weight, const TrackerGeometry* geom) const; - int fillNotMergedHisto(const std::vector& simhitids, const std::vector& simhits, - const TrackingParticle* tpref, float weight, const TrackerGeometry* geom) const; - float getType(const TrackingRecHit* hit) const; -// std::pair > getAnnealingWeight( const TrackingRecHit& aRecHit ) const; - - private: - edm::ParameterSet theConf_; - edm::InputTag tracksTag_; - edm::InputTag trackingParticleTag_; - std::string associatorTag_; - TH1F* histo_maxweight; - - TH2F* weight_withassociatedsimhit_vs_type; - TH2F* weight_withassociatedsimhit_vs_r; - TH2F* weight_withassociatedsimhit_vs_eta; - TH1F* weight_partially_unmatched; - TH2F* weight_vs_type_partially_unmatched; - TH2F* weight_vs_r_partially_unmatched; - TH2F* weight_vs_eta_partially_unmatched; - TH1F* weight_totally_unmatched; - TH2F* weight_vs_type_totally_unmatched; - TH2F* weight_vs_r_totally_unmatched; - TH2F* weight_vs_eta_totally_unmatched; - TH1F* processtype_withassociatedsimhit_merged; - TH1F* processtype_withassociatedsimhit; - TH1F* Hit_Histo; - TH1F* MergedHisto; - TH1F* NotMergedHisto; - TH2F* weight_vs_processtype_merged; - TH2F* weight_vs_processtype_notmerged; - TH2F* pull_vs_weight; - TH2F* Merged_vs_weight; - TH2F* NotMerged_vs_weight; - TH2F* NotMergedPos; - TH2F* MergedPos; - TTree* mrhit; - // TTree* mrhit2; - int mergedtype; - int notmergedtype; - float weight; - uint32_t detId; - float r; - float zeta; - float phi; - float hittype; - int nevent; - float hitlocalx; - float hitlocaly; - float hitlocalsigmax; - float hitlocalsigmay; - float hitlocalcov; - float tsoslocalx; - float tsoslocaly; - float tsoslocalsigmax; - float tsoslocalsigmay; - float tsoslocalcov; - float SimTracknum; - float RecoTracknum; - - //ERICA - TH2F* annealing_weight; - int nHitsAnn1, nHitsAnn2, nHitsAnn3; - int nHitsAnn4, nHitsAnn5, nHitsAnn6; - TGraph* annealing_weight_tgraph1; - TGraph* annealing_weight_tgraph2; - TGraph* annealing_weight_tgraph3; - TGraph* annealing_weight_tgraph4; - TGraph* annealing_weight_tgraph5; - TGraph* annealing_weight_tgraph6; - TMultiGraph *annealing_weight_tot; - -}; -#endif - diff --git a/DAFTest/DAFValidator/plugins/DAFValidator_v1.cc b/DAFTest/DAFValidator/plugins/DAFValidator_v1.cc deleted file mode 100644 index 7ba6700737672..0000000000000 --- a/DAFTest/DAFValidator/plugins/DAFValidator_v1.cc +++ /dev/null @@ -1,186 +0,0 @@ -// -*- C++ -*- -// -// Package: DAFTest/DAFValidator_v1 -// Class: DAFValidator_v1 -// -/**\class DAFValidator_v1 DAFValidator_v1.cc DAFTest/DAFValidator_v1/plugins/DAFValidator_v1.cc - - Description: [one line class summary] - - Implementation: - [Notes on implementation] -*/ -// -// Original Author: Erica Brondolin -// Created: Wed, 07 May 2014 10:31:58 GMT -// -// - - -// system include files -#include - -// user include files -#include "FWCore/Framework/interface/Frameworkfwd.h" -#include "FWCore/Framework/interface/EDAnalyzer.h" - -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/Framework/interface/MakerMacros.h" - -#include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "FWCore/Utilities/interface/InputTag.h" -#include "DataFormats/TrackReco/interface/Track.h" -#include "DataFormats/TrackReco/interface/TrackFwd.h" -#include "FWCore/ServiceRegistry/interface/Service.h" -#include "CommonTools/UtilAlgos/interface/TFileService.h" -#include "TH1.h" -// -// class declaration -// - -class DAFValidator_v1 : public edm::EDAnalyzer { - public: - explicit DAFValidator_v1(const edm::ParameterSet&); - ~DAFValidator_v1(); - - static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); - - - private: - virtual void beginJob() override; - virtual void analyze(const edm::Event&, const edm::EventSetup&) override; - virtual void endJob() override; - - //virtual void beginRun(edm::Run const&, edm::EventSetup const&) override; - //virtual void endRun(edm::Run const&, edm::EventSetup const&) override; - //virtual void beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override; - //virtual void endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) override; - - // ----------member data --------------------------- - edm::InputTag tracksTag_; //used to select what tracks to read from configuration file - TH1F * h_track_q, *h_track_pt, *h_track_nlayers, *h_track_missoutlay; - -}; - -// -// constants, enums and typedefs -// - -// -// static data member definitions -// - -// -// constructors and destructor -// -DAFValidator_v1::DAFValidator_v1(const edm::ParameterSet& iConfig): - tracksTag_(iConfig.getUntrackedParameter("tracks")) -{ - //now do what ever initialization is needed - edm::Service fs; - h_track_q = fs->make("track_charge" , "track_charge" , 200 , -2 , 2 ); - h_track_pt = fs->make("track_pt", "track_pt", 100, 8., 12.); - h_track_nlayers = fs->make("track_nlayers","track_nlayers",20,-0.5,19.5); - h_track_missoutlay = fs->make("track_missoutlay","track_missoutlay",10,-0.5,9.5); - -} - - -DAFValidator_v1::~DAFValidator_v1() -{ - - // do anything here that needs to be done at desctruction time - // (e.g. close files, deallocate resources etc.) - -} - - -// -// member functions -// - -// ------------ method called for each event ------------ -void -DAFValidator_v1::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) -{ - using namespace edm; - using namespace reco; - using namespace std; - - Handle tracks; - iEvent.getByLabel(tracksTag_,tracks); - for(TrackCollection::const_iterator itTrack = tracks->begin(); itTrack != tracks->end(); ++itTrack) { - h_track_q->Fill( itTrack->charge() ); - h_track_pt->Fill(itTrack->pt()); - //hit pattern - HitPattern track_hitpatt = itTrack->hitPattern(); - h_track_nlayers->Fill(track_hitpatt.trackerLayersWithMeasurement()); - HitPattern track_missoutlay = itTrack->trackerExpectedHitsOuter(); - h_track_missoutlay->Fill(track_missoutlay.numberOfHits()); - } - -} - - -// ------------ method called once each job just before starting event loop ------------ -void -DAFValidator_v1::beginJob() -{ -} - -// ------------ method called once each job just after ending the event loop ------------ -void -DAFValidator_v1::endJob() -{ -} - -// ------------ method called when starting to processes a run ------------ -/* -void -DAFValidator_v1::beginRun(edm::Run const&, edm::EventSetup const&) -{ -} -*/ - -// ------------ method called when ending the processing of a run ------------ -/* -void -DAFValidator_v1::endRun(edm::Run const&, edm::EventSetup const&) -{ -} -*/ - -// ------------ method called when starting to processes a luminosity block ------------ -/* -void -DAFValidator_v1::beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) -{ -} -*/ - -// ------------ method called when ending the processing of a luminosity block ------------ -/* -void -DAFValidator_v1::endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) -{ -} -*/ - -// ------------ method fills 'descriptions' with the allowed parameters for the module ------------ -void -DAFValidator_v1::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { - //The following says we do not know what parameters are allowed so do no validation - // Please change this to state exactly what you do use, even if it is no parameters - edm::ParameterSetDescription desc; - desc.setUnknown(); - descriptions.addDefault(desc); - - //Specify that only 'tracks' is allowed - //To use, remove the default given above and uncomment below - //ParameterSetDescription desc; - //desc.addUntracked("tracks","ctfWithMaterialTracks"); - //descriptions.addDefault(desc); -} - -//define this as a plug-in -DEFINE_FWK_MODULE(DAFValidator_v1); diff --git a/DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_SingleMu_cfg.py b/DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_SingleMu_cfg.py deleted file mode 100644 index 36b0e25c3d272..0000000000000 --- a/DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_SingleMu_cfg.py +++ /dev/null @@ -1,132 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -process = cms.Process("MULTITRACKVALIDATOR") - -# message logger -process.MessageLogger = cms.Service("MessageLogger", - default = cms.untracked.PSet( limit = cms.untracked.int32(10) ) -) - -# source -readFiles = cms.untracked.vstring() -secFiles = cms.untracked.vstring() -source = cms.Source ("PoolSource",fileNames = readFiles, secondaryFileNames = secFiles) -readFiles.extend( [ - '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-RECO/POSTLS171_V1-v1/00000/980D6268-26B6-E311-AA4D-0025905A6136.root' ] ); - -secFiles.extend( [ - '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/0AD53A78-F5B5-E311-BF6A-00248C55CC9D.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/1CB3FB16-F6B5-E311-842C-0025905A613C.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/AA4515DD-F5B5-E311-834B-0025905A6076.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/AE114155-F5B5-E311-9837-002618943874.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/F85DDD54-F5B5-E311-98E0-002354EF3BCE.root' ] ); - -process.source = source -process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(100) ) - -### conditions -process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") -#from Configuration.AlCa.GlobalTag import GlobalTag -#process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:startup', '') -process.GlobalTag.globaltag = 'START71_V1::All'#POSTLS171_V1::All' - -### standard includes -process.load('Configuration/StandardSequences/Services_cff') -process.load('Configuration.StandardSequences.Geometry_cff') -process.load("Configuration.StandardSequences.RawToDigi_cff") -process.load("Configuration.EventContent.EventContent_cff") -process.load("Configuration.StandardSequences.Reconstruction_cff") -process.load("Configuration.StandardSequences.MagneticField_cff") - -## includes for DAF -import RecoTracker.CkfPattern.CkfTrajectoryBuilder_cfi -import TrackingTools.TrajectoryCleaning.TrajectoryCleanerBySharedSeeds_cfi - -process.load("RecoTracker.TrackProducer.TrackRefitters_cff") -process.load("RecoTracker.TrackProducer.CTFFinalFitWithMaterialDAF_cff") -process.load("SimGeneral.MixingModule.mixNoPU_cfi") -# replace this with whatever track type you want to look at -process.TrackRefitter.TrajectoryInEvent = True -process.RKFittingSmoother.MinNumberOfHits=3 -process.TrackRefitter.Fitter = "RKFittingSmoother" -process.load("RecoTracker.TransientTrackingRecHit.TransientTrackingRecHitBuilderWithoutRefit_cfi") - -from RecoTracker.FinalTrackSelectors.TracksWithQuality_cff import * -process.ctfWithMaterialTracksDAF.TrajectoryInEvent = True -process.ctfWithMaterialTracksDAF.src = 'TrackRefitter' -process.ctfWithMaterialTracksDAF.TrajAnnealingSaving = True -process.MRHFittingSmoother.EstimateCut = -1 -process.MRHFittingSmoother.MinNumberOfHits = 3 - -import copy -from TrackingTools.KalmanUpdators.Chi2MeasurementEstimatorESProducer_cfi import * -# Chi2MeasurementEstimatorESProducer -RelaxedChi2 = copy.deepcopy(Chi2MeasurementEstimator) -RelaxedChi2.ComponentName = 'RelaxedChi2' -RelaxedChi2.MaxChi2 = 100. - -### validation-specific includes -process.load("SimTracker.TrackAssociation.quickTrackAssociatorByHits_cfi") -process.load("SimTracker.TrackAssociation.trackingParticleRecoTrackAsssociation_cfi") -process.load("Validation.RecoTrack.cuts_cff") -process.load("Validation.RecoTrack.MultiTrackValidator_cff") -process.load("DQMServices.Components.EDMtoMEConverter_cff") -process.load("DQMServices.Components.DQMFileSaver_cfi") -process.load("Validation.Configuration.postValidation_cff") - -process.quickTrackAssociatorByHits.SimToRecoDenominator = cms.string('reco') - -process.load("SimTracker.TrackAssociation.TrackAssociatorByChi2_cfi") -process.TrackAssociatorByChi2ESProducer.chi2cut = cms.double(500.0) -process.TrackAssociatorByPullESProducer = process.TrackAssociatorByChi2ESProducer.clone( chi2cut = 50.0, - onlyDiagonal = True, - ComponentName = 'TrackAssociatorByPull') - -########### configuration MultiTrackValidator ######## -process.dqmSaver.workflow = cms.untracked.string("/SingleMu/DAF/100evs") -#process.multiTrackValidator.outputFile = 'multitrackvalidator_DAF_SingleMuPt10_100evts_AllAssociators.root' -process.multiTrackValidator.associators = ['quickTrackAssociatorByHits','TrackAssociatorByChi2','TrackAssociatorByPull'] -process.multiTrackValidator.skipHistoFit=cms.untracked.bool(False) -process.multiTrackValidator.label = ['ctfWithMaterialTracksDAF'] -process.multiTrackValidator.UseAssociators = cms.bool(True) -process.multiTrackValidator.runStandalone = cms.bool(True) - -process.quickTrackAssociatorByHits.useClusterTPAssociation = cms.bool(True) -process.load("SimTracker.TrackerHitAssociation.clusterTpAssociationProducer_cfi") - -### DAF Validator -process.load('SimTracker.TrackAssociation.TrackAssociatorByHits_cfi') -process.load('SimGeneral.TrackingAnalysis.trackingParticles_cfi') - -process.demo = cms.EDAnalyzer('DAFValidator', - tracks = cms.untracked.InputTag('ctfWithMaterialTracksDAF'), - trackingParticleLabel = cms.InputTag("mix","MergedTrackTruth"), - associator = cms.untracked.string("TrackAssociatorByChi2"), - associatePixel = cms.bool(True), - associateStrip = cms.bool(True), - associateRecoTracks = cms.bool(True) -) - -process.TFileService = cms.Service("TFileService", - fileName = cms.string('DAFValidator_SingleMuPt10_100evts_AllAssociators.root') -) - -process.outputFile = cms.EndPath(process.dqmSaver) - -process.validation = cms.Sequence( -# process.tpClusterProducer * ##it does not compile with DAF::why? - process.multiTrackValidator -) - -# paths -process.p = cms.Path( - process.MeasurementTrackerEvent * process.TrackRefitter - * process.ctfWithMaterialTracksDAF - * process.validation - * process.demo -) - -### sequence of paths to run -process.schedule = cms.Schedule(process.p,process.outputFile) - - diff --git a/DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_TTbar_cfg.py b/DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_TTbar_cfg.py deleted file mode 100644 index 5dae78732b2d7..0000000000000 --- a/DAFTest/DAFValidator/test/MultiTrackValidator_DAFValidator_TTbar_cfg.py +++ /dev/null @@ -1,138 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -process = cms.Process("MULTITRACKVALIDATOR") - -# message logger -process.MessageLogger = cms.Service("MessageLogger", - default = cms.untracked.PSet( limit = cms.untracked.int32(10) ) -) - -# source -readFiles = cms.untracked.vstring() -secFiles = cms.untracked.vstring() -source = cms.Source ("PoolSource",fileNames = readFiles, secondaryFileNames = secFiles) -readFiles.extend( [ - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-RECO/POSTLS171_V1-v1/00000/3E806F9A-4BB6-E311-A4D2-002618943935.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-RECO/POSTLS171_V1-v1/00000/66797485-44B6-E311-9924-002618943939.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-RECO/POSTLS171_V1-v1/00000/B4F97AB1-25B6-E311-A16B-003048FFD760.root' ] ); - -secFiles.extend( [ - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/0466F34F-2FB6-E311-B125-0026189438EA.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/40408552-2FB6-E311-B773-0025905A60A0.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/48164C0F-00B6-E311-8EEB-0025905A60CE.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/680935B9-FFB5-E311-9750-003048FFD71A.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/80154D86-32B6-E311-A72A-002618943858.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/AAFCD423-01B6-E311-A08C-003048FFD75C.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/E03BC81A-01B6-E311-9608-00261894385A.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/F2FC75BE-04B6-E311-BBAC-0025905A48BA.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/F44896B7-06B6-E311-96AC-0026189438D7.root' ] ); - -process.source = source -process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(10) ) - -### conditions -process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") -#from Configuration.AlCa.GlobalTag import GlobalTag -#process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:startup', '') -process.GlobalTag.globaltag = 'START71_V1::All'#POSTLS171_V1::All' - -### standard includes -process.load('Configuration/StandardSequences/Services_cff') -process.load('Configuration.StandardSequences.Geometry_cff') -process.load("Configuration.StandardSequences.RawToDigi_cff") -process.load("Configuration.EventContent.EventContent_cff") -process.load("Configuration.StandardSequences.Reconstruction_cff") -process.load("Configuration.StandardSequences.MagneticField_cff") - -## includes for DAF -import RecoTracker.CkfPattern.CkfTrajectoryBuilder_cfi -import TrackingTools.TrajectoryCleaning.TrajectoryCleanerBySharedSeeds_cfi - -process.load("RecoTracker.TrackProducer.TrackRefitters_cff") -process.load("RecoTracker.TrackProducer.CTFFinalFitWithMaterialDAF_cff") -process.load("SimGeneral.MixingModule.mixNoPU_cfi") -# replace this with whatever track type you want to look at -process.TrackRefitter.TrajectoryInEvent = True -process.RKFittingSmoother.MinNumberOfHits=3 -process.TrackRefitter.Fitter = "RKFittingSmoother" -process.load("RecoTracker.TransientTrackingRecHit.TransientTrackingRecHitBuilderWithoutRefit_cfi") - -from RecoTracker.FinalTrackSelectors.TracksWithQuality_cff import * -process.ctfWithMaterialTracksDAF.TrajectoryInEvent = True -process.ctfWithMaterialTracksDAF.src = 'TrackRefitter' -process.ctfWithMaterialTracksDAF.TrajAnnealingSaving = True -process.MRHFittingSmoother.EstimateCut = -1 -process.MRHFittingSmoother.MinNumberOfHits = 3 - -import copy -from TrackingTools.KalmanUpdators.Chi2MeasurementEstimatorESProducer_cfi import * -# Chi2MeasurementEstimatorESProducer -RelaxedChi2 = copy.deepcopy(Chi2MeasurementEstimator) -RelaxedChi2.ComponentName = 'RelaxedChi2' -RelaxedChi2.MaxChi2 = 100. - -### validation-specific includes -process.load("SimTracker.TrackAssociation.quickTrackAssociatorByHits_cfi") -process.load("SimTracker.TrackAssociation.trackingParticleRecoTrackAsssociation_cfi") -process.load("Validation.RecoTrack.cuts_cff") -process.load("Validation.RecoTrack.MultiTrackValidator_cff") -process.load("DQMServices.Components.EDMtoMEConverter_cff") -process.load("DQMServices.Components.DQMFileSaver_cfi") -process.load("Validation.Configuration.postValidation_cff") - -process.quickTrackAssociatorByHits.SimToRecoDenominator = cms.string('reco') - -process.load("SimTracker.TrackAssociation.TrackAssociatorByChi2_cfi") -process.TrackAssociatorByChi2ESProducer.chi2cut = cms.double(500.0) -process.TrackAssociatorByPullESProducer = process.TrackAssociatorByChi2ESProducer.clone( chi2cut = 50.0, - onlyDiagonal = True, - ComponentName = 'TrackAssociatorByPull') - -########### configuration MultiTrackValidator ######## -process.dqmSaver.workflow = cms.untracked.string("/TTbar/DAF/10evs") -#process.multiTrackValidator.outputFile = 'multitrackvalidator_DAF_TTbar_10evts_AllAssoc.root' -process.multiTrackValidator.associators = ['quickTrackAssociatorByHits', 'TrackAssociatorByChi2','TrackAssociatorByPull'] -process.multiTrackValidator.skipHistoFit=cms.untracked.bool(False) -process.multiTrackValidator.label = ['ctfWithMaterialTracksDAF'] -process.multiTrackValidator.UseAssociators = cms.bool(True) -process.multiTrackValidator.runStandalone = cms.bool(True) - -process.quickTrackAssociatorByHits.useClusterTPAssociation = cms.bool(True) -process.load("SimTracker.TrackerHitAssociation.clusterTpAssociationProducer_cfi") - -### DAF Validator -process.load('SimTracker.TrackAssociation.TrackAssociatorByHits_cfi') -process.load('SimGeneral.TrackingAnalysis.trackingParticles_cfi') - -process.demo = cms.EDAnalyzer('DAFValidator', - tracks = cms.untracked.InputTag('ctfWithMaterialTracksDAF'), - trackingParticleLabel = cms.InputTag("mix","MergedTrackTruth"), - associator = cms.untracked.string("TrackAssociatorByChi2"), - associatePixel = cms.bool(True), - associateStrip = cms.bool(True), - associateRecoTracks = cms.bool(True) -) - -process.TFileService = cms.Service("TFileService", - fileName = cms.string('DAFValidator_TTbar_10evts_AllAssoc.root') -) - -process.outputFile = cms.EndPath(process.dqmSaver) - -process.validation = cms.Sequence( -# process.tpClusterProducer * ##it does not compile with DAF::why? - process.multiTrackValidator -) - -# paths -process.p = cms.Path( - process.MeasurementTrackerEvent * process.TrackRefitter - * process.ctfWithMaterialTracksDAF - * process.validation - * process.demo -) -process.schedule = cms.Schedule( - process.p, process.outputFile -) - - diff --git a/DAFTest/DAFValidator/test/MultiTrackValidator_SingleMu_cfg.py b/DAFTest/DAFValidator/test/MultiTrackValidator_SingleMu_cfg.py deleted file mode 100644 index aa6184127c316..0000000000000 --- a/DAFTest/DAFValidator/test/MultiTrackValidator_SingleMu_cfg.py +++ /dev/null @@ -1,87 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -process = cms.Process("MULTITRACKVALIDATOR") - -# message logger -process.MessageLogger = cms.Service("MessageLogger", - default = cms.untracked.PSet( limit = cms.untracked.int32(10) ) -) - -# source -readFiles = cms.untracked.vstring() -secFiles = cms.untracked.vstring() -source = cms.Source ("PoolSource",fileNames = readFiles, secondaryFileNames = secFiles) -readFiles.extend( [ - '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-RECO/POSTLS171_V1-v1/00000/980D6268-26B6-E311-AA4D-0025905A6136.root' ] ); - -secFiles.extend( [ - '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/0AD53A78-F5B5-E311-BF6A-00248C55CC9D.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/1CB3FB16-F6B5-E311-842C-0025905A613C.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/AA4515DD-F5B5-E311-834B-0025905A6076.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/AE114155-F5B5-E311-9837-002618943874.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValSingleMuPt10_UP15/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/F85DDD54-F5B5-E311-98E0-002354EF3BCE.root' ] ); - -process.source = source -process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(100) ) - -### conditions -process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") -#from Configuration.AlCa.GlobalTag import GlobalTag -#process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:startup', '') -process.GlobalTag.globaltag = 'START71_V1::All'#POSTLS171_V1::All' - -### standard includes -process.load('Configuration/StandardSequences/Services_cff') -process.load('Configuration.StandardSequences.Geometry_cff') -process.load("Configuration.StandardSequences.RawToDigi_cff") -process.load("Configuration.EventContent.EventContent_cff") -process.load("Configuration.StandardSequences.Reconstruction_cff") -process.load("Configuration.StandardSequences.MagneticField_cff") - -### validation-specific includes -process.load("SimTracker.TrackAssociation.quickTrackAssociatorByHits_cfi") -process.load("SimTracker.TrackAssociation.trackingParticleRecoTrackAsssociation_cfi") -process.load("Validation.RecoTrack.cuts_cff") -process.load("Validation.RecoTrack.MultiTrackValidator_cff") -process.load("DQMServices.Components.EDMtoMEConverter_cff") -process.load("DQMServices.Components.DQMFileSaver_cfi") -process.load("Validation.Configuration.postValidation_cff") - -process.quickTrackAssociatorByHits.SimToRecoDenominator = cms.string('reco') - -process.load("SimTracker.TrackAssociation.TrackAssociatorByChi2_cfi") -process.TrackAssociatorByChi2ESProducer.chi2cut = cms.double(500.0) -process.TrackAssociatorByPullESProducer = process.TrackAssociatorByChi2ESProducer.clone( - chi2cut = 50.0,onlyDiagonal = True, - ComponentName = 'TrackAssociatorByPull') - -########### configuration MultiTrackValidator ######## -process.dqmSaver.workflow = cms.untracked.string("/SingleMu/Normal/100evts") -#process.multiTrackValidator.outputFile = 'multitrackvalidator_SingleMuPt10_100evts_AllAssoc.root' -process.multiTrackValidator.associators = ['quickTrackAssociatorByHits', 'TrackAssociatorByChi2', 'TrackAssociatorByPull'] -process.multiTrackValidator.skipHistoFit=cms.untracked.bool(False) -process.multiTrackValidator.label = ['cutsRecoTracks'] -process.multiTrackValidator.UseAssociators = cms.bool(True) -process.multiTrackValidator.runStandalone = cms.bool(True) - -process.quickTrackAssociatorByHits.useClusterTPAssociation = cms.bool(True) -process.load("SimTracker.TrackerHitAssociation.clusterTpAssociationProducer_cfi") - -#process.Tracer = cms.Service("Tracer") -process.outputFile = cms.EndPath(process.dqmSaver) - -process.validation = cms.Sequence( -# process.tpClusterProducer * #associate the hits trought an association map between cluster and tp - process.multiTrackValidator -) - -# paths -process.p = cms.Path( - process.cutsRecoTracks * - process.validation -) -process.schedule = cms.Schedule( - process.p, process.outputFile -) - - diff --git a/DAFTest/DAFValidator/test/MultiTrackValidator_TTbar_cfg.py b/DAFTest/DAFValidator/test/MultiTrackValidator_TTbar_cfg.py deleted file mode 100644 index b5a93fd1f6e99..0000000000000 --- a/DAFTest/DAFValidator/test/MultiTrackValidator_TTbar_cfg.py +++ /dev/null @@ -1,93 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -process = cms.Process("MULTITRACKVALIDATOR") - -# message logger -process.MessageLogger = cms.Service("MessageLogger", - default = cms.untracked.PSet( limit = cms.untracked.int32(10) ) -) - -# source -readFiles = cms.untracked.vstring() -secFiles = cms.untracked.vstring() -source = cms.Source ("PoolSource",fileNames = readFiles, secondaryFileNames = secFiles) -readFiles.extend( [ - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-RECO/POSTLS171_V1-v1/00000/3E806F9A-4BB6-E311-A4D2-002618943935.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-RECO/POSTLS171_V1-v1/00000/66797485-44B6-E311-9924-002618943939.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-RECO/POSTLS171_V1-v1/00000/B4F97AB1-25B6-E311-A16B-003048FFD760.root' ] ); - -secFiles.extend( [ - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/0466F34F-2FB6-E311-B125-0026189438EA.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/40408552-2FB6-E311-B773-0025905A60A0.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/48164C0F-00B6-E311-8EEB-0025905A60CE.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/680935B9-FFB5-E311-9750-003048FFD71A.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/80154D86-32B6-E311-A72A-002618943858.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/AAFCD423-01B6-E311-A08C-003048FFD75C.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/E03BC81A-01B6-E311-9608-00261894385A.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/F2FC75BE-04B6-E311-BBAC-0025905A48BA.root', - '/store/relval/CMSSW_7_1_0_pre5/RelValTTbar_13/GEN-SIM-DIGI-RAW-HLTDEBUG/POSTLS171_V1-v1/00000/F44896B7-06B6-E311-96AC-0026189438D7.root' ] ); - -process.source = source -process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(10) ) - -### conditions -process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") -#from Configuration.AlCa.GlobalTag import GlobalTag -#process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:startup', '') -process.GlobalTag.globaltag = 'START71_V1::All'#POSTLS171_V1::All' - -### standard includes -process.load('Configuration/StandardSequences/Services_cff') -process.load('Configuration.StandardSequences.Geometry_cff') -process.load("Configuration.StandardSequences.RawToDigi_cff") -process.load("Configuration.EventContent.EventContent_cff") -process.load("Configuration.StandardSequences.Reconstruction_cff") -process.load("Configuration.StandardSequences.MagneticField_cff") - -### validation-specific includes -process.load("SimTracker.TrackAssociation.quickTrackAssociatorByHits_cfi") -process.load("SimTracker.TrackAssociation.trackingParticleRecoTrackAsssociation_cfi") -process.load("Validation.RecoTrack.cuts_cff") -process.load("Validation.RecoTrack.MultiTrackValidator_cff") -process.load("DQMServices.Components.EDMtoMEConverter_cff") -process.load("DQMServices.Components.DQMFileSaver_cfi") -process.load("Validation.Configuration.postValidation_cff") - -process.quickTrackAssociatorByHits.SimToRecoDenominator = cms.string('reco') - -process.load("SimTracker.TrackAssociation.TrackAssociatorByChi2_cfi") -process.TrackAssociatorByChi2ESProducer.chi2cut = cms.double(500.0) -process.TrackAssociatorByPullESProducer = process.TrackAssociatorByChi2ESProducer.clone( chi2cut = 50.0, - onlyDiagonal = True, - ComponentName = 'TrackAssociatorByPull') - -########### configuration MultiTrackValidator ######## -process.dqmSaver.workflow = cms.untracked.string("/TTbar/Normal/10evts") -#process.multiTrackValidator.outputFile = 'multitrackvalidator_TTbar_10evts_AssociatorByPull.root' -process.multiTrackValidator.associators = ['quickTrackAssociatorByHits', 'TrackAssociatorByChi2','TrackAssociatorByPull'] -process.multiTrackValidator.skipHistoFit=cms.untracked.bool(False) -process.multiTrackValidator.label = ['cutsRecoTracks'] -process.multiTrackValidator.useLogPt=cms.untracked.bool(True) -process.multiTrackValidator.UseAssociators = cms.bool(True) -process.multiTrackValidator.runStandalone = cms.bool(True) - -process.quickTrackAssociatorByHits.useClusterTPAssociation = cms.bool(True) -process.load("SimTracker.TrackerHitAssociation.clusterTpAssociationProducer_cfi") - -process.outputFile = cms.EndPath(process.dqmSaver) - -process.validation = cms.Sequence( -# process.tpClusterProducer * #associate the hits trought an association map between cluster and tp - process.multiTrackValidator -) - -# paths -process.p = cms.Path( - process.cutsRecoTracks - * process.validation -) -process.schedule = cms.Schedule( - process.p, process.outputFile -) - - diff --git a/RecoTracker/MeasurementDet/plugins/TkPixelMeasurementDet.cc b/RecoTracker/MeasurementDet/plugins/TkPixelMeasurementDet.cc index 10ed3c6ad1b19..e8002a73cc86e 100644 --- a/RecoTracker/MeasurementDet/plugins/TkPixelMeasurementDet.cc +++ b/RecoTracker/MeasurementDet/plugins/TkPixelMeasurementDet.cc @@ -27,6 +27,7 @@ TkPixelMeasurementDet::TkPixelMeasurementDet( const GeomDet* gdet, bool TkPixelMeasurementDet::measurements( const TrajectoryStateOnSurface& stateOnThisDet, const MeasurementEstimator& est, const MeasurementTrackerEvent & data, TempMeasurements & result) const { + if (!isActive(data)) { result.add(theInactiveHit, 0.F); return true; diff --git a/RecoTracker/SiTrackerMRHTools/.admin/CVS/Entries b/RecoTracker/SiTrackerMRHTools/.admin/CVS/Entries deleted file mode 100644 index 921311b5ab61c..0000000000000 --- a/RecoTracker/SiTrackerMRHTools/.admin/CVS/Entries +++ /dev/null @@ -1,2 +0,0 @@ -/developers/1.3/Tue Jul 8 10:54:26 2008//TCMSSW_3_1_2 -D diff --git a/RecoTracker/SiTrackerMRHTools/.admin/CVS/Repository b/RecoTracker/SiTrackerMRHTools/.admin/CVS/Repository deleted file mode 100644 index 445157be358ec..0000000000000 --- a/RecoTracker/SiTrackerMRHTools/.admin/CVS/Repository +++ /dev/null @@ -1 +0,0 @@ -CMSSW/RecoTracker/SiTrackerMRHTools/.admin diff --git a/RecoTracker/SiTrackerMRHTools/.admin/CVS/Root b/RecoTracker/SiTrackerMRHTools/.admin/CVS/Root deleted file mode 100644 index 18147e885e317..0000000000000 --- a/RecoTracker/SiTrackerMRHTools/.admin/CVS/Root +++ /dev/null @@ -1 +0,0 @@ -:ext:ebrondol@lxplus5.cern.ch:/afs/cern.ch/user/c/cvscmssw/public/CMSSW diff --git a/RecoTracker/SiTrackerMRHTools/.admin/CVS/Tag b/RecoTracker/SiTrackerMRHTools/.admin/CVS/Tag deleted file mode 100644 index 27c493f6a303a..0000000000000 --- a/RecoTracker/SiTrackerMRHTools/.admin/CVS/Tag +++ /dev/null @@ -1 +0,0 @@ -NCMSSW_3_1_2 diff --git a/RecoTracker/SiTrackerMRHTools/.admin/developers b/RecoTracker/SiTrackerMRHTools/.admin/developers deleted file mode 100644 index 58caa0b36fc16..0000000000000 --- a/RecoTracker/SiTrackerMRHTools/.admin/developers +++ /dev/null @@ -1,50 +0,0 @@ -# Names of Developers with write access to this module -# -# There are two types of developers: -# 1) Administrators - entitled to edit all files in the module , -# in particular the .admin directory. (Including this file) -# 2) Regular Developers - entitled to edit all files in the module -# except those in the .admin directory. -# -# Entries must have the following format: -# -# [logname] : [Firstname Familyname] : [emailaddress] -# -# where [logname] is the login name of the user (in lower case) -# [Firstname Familyname] is the fullname of the user in free format -# [emailaddress] any email address of the user -# -# IMPORTANT: The only entry that uniqely identifies the user -# is the [loginname]. The rest of the entries are -# used for information and clarity purposes. -# -# You can find the information required to add a user, using the "phone" -# command from any CERN machine. "phone user -A" will give you a list of his -# accounts and lognames too. -# A safe assumption is to look for his ZH account on AFS/LXPLUS -# Please remember to use lower case for the logname. -# In case of doubts, please contact cvsadmin.cern.ch -# -# Important -# --------- -# --- Put names of regular developers after the >Developers Tag -# --- Put names of administrators after the >Administrators Tag -# -# NB: This file was automatically generated by CreateCVSPackage.pl. -# ->Developers -adamwo : Wolfgang Adam : Wolfgang.Adam@cern.ch -burkett : Kevin Burkett : burkett@fnal.gov -genta : Chiara Genta : Chiara.Genta@cern.ch -lenzip : Piergiulio Lenzi : Piergiulio.Lenzi@cern.ch -mangano : Boris Mangano : Boris.Mangano@cern.ch -tropiano : Antonio Tropiano : Antonio.Tropiano@cern.ch - ->Administrators -adamwo : Wolfgang Adam : Wolfgang.Adam@cern.ch -burkett : Kevin Burkett : burkett@fnal.gov -genta : Chiara Genta : Chiara.Genta@cern.ch -lenzip : Piergiulio Lenzi : Piergiulio.Lenzi@cern.ch -mangano : Boris Mangano : Boris.Mangano@cern.ch -tropiano : Antonio Tropiano : Antonio.Tropiano@cern.ch - From ffeec43b4bbb50a47665e9a5e7f615c406ad4124 Mon Sep 17 00:00:00 2001 From: erica brondolin Date: Wed, 11 Jun 2014 13:02:40 +0200 Subject: [PATCH 06/16] cleaning up TrackingTools folder --- TrackingTools/KalmanUpdators/src/KFUpdator.cc | 1 - TrackingTools/PatternTools/BuildFile.xml | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/TrackingTools/KalmanUpdators/src/KFUpdator.cc b/TrackingTools/KalmanUpdators/src/KFUpdator.cc index a27c551cd1685..8e771901d015e 100644 --- a/TrackingTools/KalmanUpdators/src/KFUpdator.cc +++ b/TrackingTools/KalmanUpdators/src/KFUpdator.cc @@ -113,7 +113,6 @@ TrajectoryStateOnSurface KFUpdator::update(const TrajectoryStateOnSurface& tsos, MeasurementExtractor me(tsos); - typedef typename AlgebraicROOTObject::Matrix MatD5; AlgebraicVector5 x = tsos.localParameters().vector(); const AlgebraicSymMatrix55 &C = (tsos.localError().matrix()); // Measurement matrix diff --git a/TrackingTools/PatternTools/BuildFile.xml b/TrackingTools/PatternTools/BuildFile.xml index bc5dc990a449e..05ad6fe641029 100644 --- a/TrackingTools/PatternTools/BuildFile.xml +++ b/TrackingTools/PatternTools/BuildFile.xml @@ -3,10 +3,10 @@ + - From 460ad45be9ae74b52a4d3f4f5baca52dc2da82f5 Mon Sep 17 00:00:00 2001 From: erica brondolin Date: Wed, 11 Jun 2014 17:25:42 +0200 Subject: [PATCH 07/16] Delete TSiTrackerMultiRecHit from DPGAnalysis/SiStripTools --- DPGAnalysis/SiStripTools/plugins/TrackerDpgAnalysis.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/DPGAnalysis/SiStripTools/plugins/TrackerDpgAnalysis.cc b/DPGAnalysis/SiStripTools/plugins/TrackerDpgAnalysis.cc index b5033d206885a..e73fcd6e7fcfc 100644 --- a/DPGAnalysis/SiStripTools/plugins/TrackerDpgAnalysis.cc +++ b/DPGAnalysis/SiStripTools/plugins/TrackerDpgAnalysis.cc @@ -89,7 +89,6 @@ #include #include #include -#include #include #include #include "RecoVertex/VertexPrimitives/interface/TransientVertex.h" @@ -1104,7 +1103,8 @@ std::vector TrackerDpgAnalysis::onTrackAngles(edm::Handle >& collection,const TransientTrackingRecHit* hit , double tla) { if(!hit) return; - const TSiTrackerMultiRecHit* multihit=dynamic_cast(hit); + //SiTrackerMultiRecHit const & mHit = dynamic_cast(aRecHit); + const SiTrackerMultiRecHit* multihit=dynamic_cast(hit); const SiStripRecHit2D* singlehit=dynamic_cast(hit); const SiStripRecHit1D* hit1d=dynamic_cast(hit); if(hit1d) { //...->33X From 8ec828653fbbae12765c4ef133f96fe8b77b9bf6 Mon Sep 17 00:00:00 2001 From: erica brondolin Date: Wed, 11 Jun 2014 17:29:22 +0200 Subject: [PATCH 08/16] Delete TSiTrackerMultiRecHit from DPGAnalysis/SiStripTools (2) --- DPGAnalysis/SiStripTools/plugins/TrackerDpgAnalysis.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/DPGAnalysis/SiStripTools/plugins/TrackerDpgAnalysis.cc b/DPGAnalysis/SiStripTools/plugins/TrackerDpgAnalysis.cc index e73fcd6e7fcfc..1a10c33e8a3b6 100644 --- a/DPGAnalysis/SiStripTools/plugins/TrackerDpgAnalysis.cc +++ b/DPGAnalysis/SiStripTools/plugins/TrackerDpgAnalysis.cc @@ -1103,7 +1103,6 @@ std::vector TrackerDpgAnalysis::onTrackAngles(edm::Handle >& collection,const TransientTrackingRecHit* hit , double tla) { if(!hit) return; - //SiTrackerMultiRecHit const & mHit = dynamic_cast(aRecHit); const SiTrackerMultiRecHit* multihit=dynamic_cast(hit); const SiStripRecHit2D* singlehit=dynamic_cast(hit); const SiStripRecHit1D* hit1d=dynamic_cast(hit); From 62b28f1625ba005970f90d45e2d901b3d81461b1 Mon Sep 17 00:00:00 2001 From: erica brondolin Date: Thu, 12 Jun 2014 11:49:18 +0200 Subject: [PATCH 09/16] Add MRHChi2 in TrackingComponentsRecord --- TrackingTools/TrackFitters/python/MRHFitters_cff.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/TrackingTools/TrackFitters/python/MRHFitters_cff.py b/TrackingTools/TrackFitters/python/MRHFitters_cff.py index 27e7b3d600af5..53085c3258771 100644 --- a/TrackingTools/TrackFitters/python/MRHFitters_cff.py +++ b/TrackingTools/TrackFitters/python/MRHFitters_cff.py @@ -1,5 +1,7 @@ import FWCore.ParameterSet.Config as cms +import TrackingTools.KalmanUpdators.MRHChi2MeasurementEstimatorESProducer_cfi + import TrackingTools.TrackFitters.KFTrajectoryFitterESProducer_cfi MRHTrajectoryFitter = TrackingTools.TrackFitters.KFTrajectoryFitterESProducer_cfi.KFTrajectoryFitter.clone( ComponentName = 'MRHFitter', From 7da9ea9b7f6346acb574a4322e7a4f134ec515e7 Mon Sep 17 00:00:00 2001 From: erica brondolin Date: Thu, 12 Jun 2014 16:44:35 +0200 Subject: [PATCH 10/16] Fix MRHChi2 in TrackingComponentsRecord --- TrackingTools/TrackFitters/python/MRHFitters_cff.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/TrackingTools/TrackFitters/python/MRHFitters_cff.py b/TrackingTools/TrackFitters/python/MRHFitters_cff.py index 53085c3258771..ecba177950584 100644 --- a/TrackingTools/TrackFitters/python/MRHFitters_cff.py +++ b/TrackingTools/TrackFitters/python/MRHFitters_cff.py @@ -1,6 +1,6 @@ import FWCore.ParameterSet.Config as cms -import TrackingTools.KalmanUpdators.MRHChi2MeasurementEstimatorESProducer_cfi +from TrackingTools.KalmanUpdators.MRHChi2MeasurementEstimatorESProducer_cfi import * import TrackingTools.TrackFitters.KFTrajectoryFitterESProducer_cfi MRHTrajectoryFitter = TrackingTools.TrackFitters.KFTrajectoryFitterESProducer_cfi.KFTrajectoryFitter.clone( From 628982473253553ed17a8395a47ee5005930eeda Mon Sep 17 00:00:00 2001 From: erica brondolin Date: Wed, 18 Jun 2014 16:35:34 +0200 Subject: [PATCH 11/16] Adding debug --- .../interface/GroupedDAFHitCollector.h | 6 ++-- .../interface/SiTrackerMultiRecHitUpdator.h | 3 +- .../interface/SimpleDAFHitCollector.h | 6 ++-- .../plugins/MultiRecHitCollectorESProducer.cc | 5 ++-- .../SiTrackerMultiRecHitUpdatorESProducer.cc | 3 +- .../python/GroupedMultiRecHitCollector_cfi.py | 3 +- .../python/SiTrackerMultiRecHitUpdator_cfi.py | 3 +- .../python/SimpleMultiRecHitCollector_cfi.py | 3 +- .../src/GroupedDAFHitCollector.cc | 1 - .../src/SiTrackerMultiRecHitUpdator.cc | 30 ++++++++++++------- .../src/SimpleDAFHitCollector.cc | 25 ++++++++-------- .../src/DAFTrackProducerAlgorithm.cc | 4 +-- 12 files changed, 53 insertions(+), 39 deletions(-) diff --git a/RecoTracker/SiTrackerMRHTools/interface/GroupedDAFHitCollector.h b/RecoTracker/SiTrackerMRHTools/interface/GroupedDAFHitCollector.h index 62a3333de8f16..4dd68e0aadcea 100644 --- a/RecoTracker/SiTrackerMRHTools/interface/GroupedDAFHitCollector.h +++ b/RecoTracker/SiTrackerMRHTools/interface/GroupedDAFHitCollector.h @@ -26,9 +26,9 @@ class GroupedDAFHitCollector :public MultiRecHitCollector { const SiTrackerMultiRecHitUpdator* updator, const MeasurementEstimator* est, const Propagator* propagator, - const Propagator* reversePropagator): + const Propagator* reversePropagator, bool debug): MultiRecHitCollector(measurementTracker), theUpdator(updator), - theEstimator(est), thePropagator(propagator), theReversePropagator(reversePropagator){} + theEstimator(est), thePropagator(propagator), theReversePropagator(reversePropagator), debug_(debug){} virtual ~GroupedDAFHitCollector(){} @@ -49,7 +49,7 @@ class GroupedDAFHitCollector :public MultiRecHitCollector { const MeasurementEstimator* theEstimator; const Propagator* thePropagator; const Propagator* theReversePropagator; - + const bool debug_; }; diff --git a/RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h b/RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h index ca589d5bd6977..35dba6f79ad78 100644 --- a/RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h +++ b/RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h @@ -32,7 +32,7 @@ class SiTrackerMultiRecHitUpdator{ SiTrackerMultiRecHitUpdator(const TransientTrackingRecHitBuilder* builder, const TrackingRecHitPropagator* hitpropagator, const float Chi2Cut, - const std::vector& anAnnealingProgram); + const std::vector& anAnnealingProgram, bool debug); virtual ~SiTrackerMultiRecHitUpdator(){}; //calls the update method in order to build a SiTrackerMultiRecHit @@ -81,6 +81,7 @@ class SiTrackerMultiRecHitUpdator{ double theChi2Cut; const std::vector theAnnealingProgram; TkClonerImpl theHitCloner; + bool debug_; }; #endif diff --git a/RecoTracker/SiTrackerMRHTools/interface/SimpleDAFHitCollector.h b/RecoTracker/SiTrackerMRHTools/interface/SimpleDAFHitCollector.h index c97b8cca36674..4caffea12864e 100644 --- a/RecoTracker/SiTrackerMRHTools/interface/SimpleDAFHitCollector.h +++ b/RecoTracker/SiTrackerMRHTools/interface/SimpleDAFHitCollector.h @@ -12,8 +12,8 @@ class SimpleDAFHitCollector :public MultiRecHitCollector { explicit SimpleDAFHitCollector(const MeasurementTracker* measurementTracker, const SiTrackerMultiRecHitUpdator* updator, const MeasurementEstimator* est, - const Propagator* propagator - ):MultiRecHitCollector(measurementTracker), theUpdator(updator), theEstimator(est), thePropagator(propagator){} + const Propagator* propagator, bool debug + ):MultiRecHitCollector(measurementTracker), theUpdator(updator), theEstimator(est), thePropagator(propagator), debug_(debug){} virtual ~SimpleDAFHitCollector(){} @@ -40,7 +40,7 @@ class SimpleDAFHitCollector :public MultiRecHitCollector { const MeasurementEstimator* theEstimator; //this actually is not used in the fastMeasurement method const Propagator* thePropagator; - + const bool debug_; }; diff --git a/RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.cc b/RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.cc index 0dd443507bd63..2d77870064ce7 100644 --- a/RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.cc +++ b/RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.cc @@ -39,6 +39,7 @@ MultiRecHitCollectorESProducer::produce(const MultiRecHitRecord& iRecord){ std::string propagatorAlongName = conf_.getParameter("propagatorAlong"); std::string estimatorName = conf_.getParameter("estimator"); std::string measurementTrackerName = conf_.getParameter("MeasurementTrackerName"); + bool debug = conf_.getParameter("Debug"); ESHandle mrhuhandle; @@ -58,13 +59,13 @@ MultiRecHitCollectorESProducer::produce(const MultiRecHitRecord& iRecord){ mrhuhandle.product(), estimatorhandle.product(), propagatorhandle.product(), - propagatorOppositehandle.product())); + propagatorOppositehandle.product(), debug)); } else { _collector = boost::shared_ptr(new SimpleDAFHitCollector(measurementhandle.product(), mrhuhandle.product(), estimatorhandle.product(), - propagatorhandle.product())); + propagatorhandle.product(), debug)); } return _collector; diff --git a/RecoTracker/SiTrackerMRHTools/plugins/SiTrackerMultiRecHitUpdatorESProducer.cc b/RecoTracker/SiTrackerMRHTools/plugins/SiTrackerMultiRecHitUpdatorESProducer.cc index 8d16ced13b3a0..93346053e1b13 100644 --- a/RecoTracker/SiTrackerMRHTools/plugins/SiTrackerMultiRecHitUpdatorESProducer.cc +++ b/RecoTracker/SiTrackerMRHTools/plugins/SiTrackerMultiRecHitUpdatorESProducer.cc @@ -33,8 +33,9 @@ SiTrackerMultiRecHitUpdatorESProducer::produce(const MultiRecHitRecord & iRecord edm::ESHandle hhitpropagator; iRecord.getRecord().getRecord().get(hitpropagator, hhitpropagator); + bool debug = pset_.getParameter("Debug"); //_updator = boost::shared_ptr(new SiTrackerMultiRecHitUpdator(pDD.product(), pp, sp, mp, annealingProgram)); - _updator = boost::shared_ptr(new SiTrackerMultiRecHitUpdator(hbuilder.product(),hhitpropagator.product(), Chi2Cut, annealingProgram)); + _updator = boost::shared_ptr(new SiTrackerMultiRecHitUpdator(hbuilder.product(),hhitpropagator.product(), Chi2Cut, annealingProgram, debug)); // _updator = boost::shared_ptr(new SiTrackerMultiRecHitUpdator(hhitpropagator.product(),annealingProgram)); return _updator; } diff --git a/RecoTracker/SiTrackerMRHTools/python/GroupedMultiRecHitCollector_cfi.py b/RecoTracker/SiTrackerMRHTools/python/GroupedMultiRecHitCollector_cfi.py index 4de0a0aa9465e..d9c5aec39a8ac 100644 --- a/RecoTracker/SiTrackerMRHTools/python/GroupedMultiRecHitCollector_cfi.py +++ b/RecoTracker/SiTrackerMRHTools/python/GroupedMultiRecHitCollector_cfi.py @@ -7,7 +7,8 @@ propagatorOpposite = cms.string('OppositeRungeKuttaTrackerPropagator'), MeasurementTrackerName = cms.string(''), estimator = cms.string('RelaxedChi2'), - Mode = cms.string('Grouped') + Mode = cms.string('Grouped'), + Debug = cms.bool(False) ) diff --git a/RecoTracker/SiTrackerMRHTools/python/SiTrackerMultiRecHitUpdator_cfi.py b/RecoTracker/SiTrackerMRHTools/python/SiTrackerMultiRecHitUpdator_cfi.py index 412cf57fab0d9..788d7f456120b 100644 --- a/RecoTracker/SiTrackerMRHTools/python/SiTrackerMultiRecHitUpdator_cfi.py +++ b/RecoTracker/SiTrackerMRHTools/python/SiTrackerMultiRecHitUpdator_cfi.py @@ -5,7 +5,8 @@ TTRHBuilder = cms.string('WithAngleAndTemplate'), HitPropagator = cms.string('trackingRecHitPropagator'), AnnealingProgram = cms.vdouble(80.0, 9.0, 4.0, 1.0, 1.0, 1.0), - ChiSquareCut =cms.double(15.0) + ChiSquareCut =cms.double(15.0), + Debug = cms.bool(False) ) diff --git a/RecoTracker/SiTrackerMRHTools/python/SimpleMultiRecHitCollector_cfi.py b/RecoTracker/SiTrackerMRHTools/python/SimpleMultiRecHitCollector_cfi.py index 0db85e8f0c873..16e7f5358cef4 100644 --- a/RecoTracker/SiTrackerMRHTools/python/SimpleMultiRecHitCollector_cfi.py +++ b/RecoTracker/SiTrackerMRHTools/python/SimpleMultiRecHitCollector_cfi.py @@ -6,7 +6,8 @@ ComponentName = cms.string('simpleMultiRecHitCollector'), MeasurementTrackerName = cms.string(''), estimator = cms.string('RelaxedChi2Simple'), - Mode = cms.string('Simple') + Mode = cms.string('Simple'), + Debug = cms.bool(False) ) diff --git a/RecoTracker/SiTrackerMRHTools/src/GroupedDAFHitCollector.cc b/RecoTracker/SiTrackerMRHTools/src/GroupedDAFHitCollector.cc index ee31d75a94c91..6a8de8bd62e89 100644 --- a/RecoTracker/SiTrackerMRHTools/src/GroupedDAFHitCollector.cc +++ b/RecoTracker/SiTrackerMRHTools/src/GroupedDAFHitCollector.cc @@ -21,7 +21,6 @@ vector GroupedDAFHitCollector::recHits(const Trajectory& const MeasurementTrackerEvent *theMTE) const { - std::cout << " Calling GroupedDAFHitCollector::recHits" << std::endl; LayerMeasurements theLM (theMTE->measurementTracker(), *theMTE); //WARNING: At the moment the trajectories has the measurements with reversed sorting after the track smoothing diff --git a/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc b/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc index f02b8e5f556c2..71948fbc5518c 100644 --- a/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc +++ b/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc @@ -12,11 +12,13 @@ SiTrackerMultiRecHitUpdator::SiTrackerMultiRecHitUpdator(const TransientTrackingRecHitBuilder* builder, const TrackingRecHitPropagator* hitpropagator, const float Chi2Cut, - const std::vector& anAnnealingProgram): + const std::vector& anAnnealingProgram, + bool debug): theBuilder(builder), theHitPropagator(hitpropagator), theChi2Cut(Chi2Cut), - theAnnealingProgram(anAnnealingProgram){ + theAnnealingProgram(anAnnealingProgram), + debug_(debug){ theHitCloner = static_cast(builder)->cloner(); } @@ -24,7 +26,9 @@ SiTrackerMultiRecHitUpdator::SiTrackerMultiRecHitUpdator(const TransientTracking TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::buildMultiRecHit(const std::vector& rhv, TrajectoryStateOnSurface tsos, float annealing) const{ -// std::cout << " Calling SiTrackerMultiRecHitUpdator::buildMultiRecHit with AnnealingFactor: " << annealing << std::endl; + if(debug_){ + std::cout << " Calling SiTrackerMultiRecHitUpdator::buildMultiRecHit with AnnealingFactor: " << annealing << std::endl; + } TransientTrackingRecHit::ConstRecHitContainer tcomponents; for (std::vector::const_iterator iter = rhv.begin(); iter != rhv.end(); iter++){ TransientTrackingRecHit::RecHitPointer transient = theBuilder->build(*iter); @@ -37,7 +41,9 @@ TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::buildMultiR TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( TransientTrackingRecHit::ConstRecHitPointer original, TrajectoryStateOnSurface tsos, double annealing) const{ -// std::cout << " Calling SiTrackerMultiRecHitUpdator::update with AnnealingFactor: " << annealing << std::endl; + if(debug_){ + std::cout << " Calling SiTrackerMultiRecHitUpdator::update with AnnealingFactor: " << annealing << std::endl; + } LogTrace("SiTrackerMultiRecHitUpdator") << "Calling SiTrackerMultiRecHitUpdator::update with AnnealingFactor: " << annealing; if (original->isValid()) @@ -146,18 +152,22 @@ TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( Tran << " position " << mymap[counter].first->localPosition() << " error " << mymap[counter].first->localPositionError() << " with weight " << p; -// std::cout << " Component hit type " << typeid(*mymap[counter].first).name() -// << " position " << mymap[counter].first->localPosition() -// << " \n\terror " << mymap[counter].first->localPositionError() -// << " with weight " << p << std::endl; + if(debug_){ + std::cout << " Component hit type " << typeid(*mymap[counter].first).name() + << " position " << mymap[counter].first->localPosition() + << " \n\terror " << mymap[counter].first->localPositionError() + << " with weight " << p << std::endl; + } counter++; } SiTrackerMultiRecHitUpdator::LocalParameters param = calcParameters(tsos, normmap); SiTrackerMultiRecHit updated(param.first, param.second, *normmap.front().first->det(), normmap, annealing); -// std::cout << " Updated Hit position " << updated.localPosition() -// << " updated error " << updated.localPositionError() << std::endl; + if(debug_){ + std::cout << " Updated Hit position " << updated.localPosition() + << " updated error " << updated.localPositionError() << std::endl; + } LogTrace("SiTrackerMultiRecHitUpdator") << " Updated Hit position " << updated.localPosition() << " updated error " << updated.localPositionError() << std::endl; diff --git a/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc b/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc index e42240fefccad..5a23665a463ba 100644 --- a/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc +++ b/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc @@ -15,7 +15,7 @@ using namespace std; vector SimpleDAFHitCollector::recHits(const Trajectory& traj, const MeasurementTrackerEvent *theMTE) const{ -// std::cout << " Calling SimpleDAFHitCollector::recHits" << std::endl; + if(debug_) std::cout << " Calling SimpleDAFHitCollector::recHits" << std::endl; //WARNING: At the moment the trajectories has the measurements //with reversed sorting after the track smoothing @@ -24,17 +24,19 @@ vector SimpleDAFHitCollector::recHits(const Trajectory& t if (meas.empty()) return vector(); //debug + if(debug_) std::cout << "Original measurements are:\n"; LogTrace("MultiRecHitCollector") << "Original measurements are:"; for(vector::const_iterator itrajmeas = meas.begin(); itrajmeas < meas.end(); itrajmeas++) { if (itrajmeas->recHit()->isValid()){ -// std::cout << " Valid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() -// << " local position " << itrajmeas->recHit()->hit()->localPosition() -// << " global position " << itrajmeas->recHit()->hit()->globalPosition() << "\n"; + if(debug_){ std::cout << " Valid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() + << " local position " << itrajmeas->recHit()->hit()->localPosition() + << " global position " << itrajmeas->recHit()->hit()->globalPosition() << "\n"; + } LogTrace("MultiRecHitCollector") << "Valid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() << " local position " << itrajmeas->recHit()->hit()->localPosition(); } else { -// std::cout << " Invalid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() << std::endl; + if(debug_) std::cout << " Invalid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() << std::endl; LogTrace("MultiRecHitCollector") << "Invalid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId(); } } @@ -56,18 +58,17 @@ vector SimpleDAFHitCollector::recHits(const Trajectory& t TrajectoryStateOnSurface state = itrajmeas->predictedState(); if (!state.isValid()){ -// std::cout << "Something wrong! no valid TSOS found for this meas \n"; + std::cout << "Something wrong! no valid TSOS found for this meas \n"; LogTrace("MultiRecHitCollector") << "Something wrong! no valid TSOS found in current group "; continue; } //collected hits compatible with the itrajmeas if( measDet.measurements(current, *(getEstimator()), tmps)){ -// std::cout << " Found " << tmps.size() << " compatible measurements." << std::endl; + if(debug_) std::cout << " Found " << tmps.size() << " compatible measurements"; for (std::size_t i=0; i!=tmps.size(); ++i){ DetId idtemps = tmps.hits[i]->geographicalId(); if( idtemps == id && tmps.hits[i]->hit()->isValid() ) { -// std::cout << " This hit is valid and has " << idtemps << " DetId."<< std::endl; LogTrace("MultiRecHitCollector") << "This hit is valid "; hits.push_back(tmps.hits[i]->hit()); } @@ -75,7 +76,7 @@ vector SimpleDAFHitCollector::recHits(const Trajectory& t //I will keep the Invalid hit, IF this is not the first one if (hits.empty()){ -// std::cout << " No valid hits found in current group.\n "; + std::cout << " -> but no valid hits found in current group.\n "; LogTrace("MultiRecHitCollector") << "No valid hits found in current group "; if( result.empty() ) continue; @@ -86,14 +87,14 @@ vector SimpleDAFHitCollector::recHits(const Trajectory& t //measurements in groups are sorted with increating chi2 //sort( *hits.begin(), *hits.end(), TrajMeasLessEstim()); -// std::cout << " Found " << hits.size() << " valid hits for this sensor.\n"; + if(debug_) std::cout << " -> " << hits.size() << " valid hits for this sensor.\n"; LogTrace("MultiRecHitCollector") << "Found " << hits.size() << " hits for this sensor"; //building a MultiRecHit out of each sensor group result.push_back(TrajectoryMeasurement(state,theUpdator->buildMultiRecHit(hits, state))); } } else { -// std::cout << " No measurements found in current group.\n "; + if(debug_) std::cout << " No measurements found in current group.\n "; LogTrace("MultiRecHitCollector") << "No valid hits found in current group "; if( result.empty() ) continue; @@ -104,7 +105,7 @@ vector SimpleDAFHitCollector::recHits(const Trajectory& t } } -// std::cout << " Ending SimpleDAFHitCollector::recHits >> " << result.size() << std::endl; + if(debug_) std::cout << " Ending SimpleDAFHitCollector::recHits >> " << result.size() << std::endl; LogTrace("MultiRecHitCollector") << "Original Measurement size " << meas.size() << " GroupedDAFHitCollector returned " << result.size() << " measurements"; //adding a protection against too few hits and invalid hits diff --git a/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc b/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc index 2aff73babbd5d..55fcd324fdec3 100644 --- a/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc +++ b/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc @@ -36,8 +36,6 @@ void DAFTrackProducerAlgorithm::runWithCandidate(const TrackingGeometry * theG, TrajAnnealingCollection& trajann, bool TrajAnnSaving_) const { -// std::cout << "////////////////////////////////////////////////////////\n" -// << "DAFTrackProducerAlgorithm::runWithCandidate: Number of Trajectories: " << theTrajectoryCollection.size() << "\n"; edm::LogInfo("TrackProducer") << "Number of Trajectories: " << theTrajectoryCollection.size() << "\n"; int cont = 0; @@ -197,7 +195,7 @@ Trajectory DAFTrackProducerAlgorithm::fit(const std::pair Date: Wed, 18 Jun 2014 16:43:45 +0200 Subject: [PATCH 12/16] adding cfg debug file --- .../test/DAFRecoTrack_debug_cfg.py | 62 +++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 RecoTracker/SiTrackerMRHTools/test/DAFRecoTrack_debug_cfg.py diff --git a/RecoTracker/SiTrackerMRHTools/test/DAFRecoTrack_debug_cfg.py b/RecoTracker/SiTrackerMRHTools/test/DAFRecoTrack_debug_cfg.py new file mode 100644 index 0000000000000..b1683a0e57073 --- /dev/null +++ b/RecoTracker/SiTrackerMRHTools/test/DAFRecoTrack_debug_cfg.py @@ -0,0 +1,62 @@ +import FWCore.ParameterSet.Config as cms + +# inspired from RecoTracker/TrackProducer/test/TrackRefit.py + +process = cms.Process("Refitting") + +### standard MessageLoggerConfiguration +process.load("FWCore.MessageService.MessageLogger_cfi") + +### Standard Configurations +process.load("Configuration.StandardSequences.Services_cff") +process.load('Configuration/StandardSequences/Geometry_cff') +process.load('Configuration/StandardSequences/Reconstruction_cff') +process.load('Configuration/StandardSequences/MagneticField_cff') + +### Conditions +process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") +#from Configuration.AlCa.GlobalTag import GlobalTag +#process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:startup', '') +process.GlobalTag.globaltag = 'START71_V1::All'#POSTLS171_V1::All' + +### Track Refitter +process.load("RecoTracker.TrackProducer.TrackRefitters_cff") +process.load("RecoTracker.TrackProducer.CTFFinalFitWithMaterialDAF_cff") +process.ctfWithMaterialTracksDAF.TrajectoryInEvent = True +process.ctfWithMaterialTracksDAF.src = 'TrackRefitter' +process.ctfWithMaterialTracksDAF.TrajAnnealingSaving = True +process.MRHFittingSmoother.EstimateCut = -1 +process.MRHFittingSmoother.MinNumberOfHits = 3 + +# debug +process.simpleMultiRecHitCollector.Debug = True +process.siTrackerMultiRecHitUpdator.Debug = True + +process.source = cms.Source("PoolSource", +# fileNames = cms.untracked.vstring('file:reco_trk_TTbar_13_5evts.root') + fileNames = cms.untracked.vstring('file:reco_trk_SingleMuPt10_UP15_10evts.root') +) +process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(1)) + +process.out = cms.OutputModule("PoolOutputModule", + outputCommands = cms.untracked.vstring('drop *_*_*_*', + 'keep *_siPixelClusters_*_*', + 'keep *_siStripClusters_*_*', + 'keep *_siPixelDigis_*_*', + 'keep *_siStripDigis_*_*', + 'keep *_offlineBeamSpot_*_*', + 'keep *_pixelVertices_*_*', + 'keep *_siStripMatchedRecHits_*_*', + 'keep *_initialStepSeeds_*_*', + 'keep recoTracks_*_*_*', + 'keep recoTrackExtras_*_*_*', + 'keep TrackingRecHitsOwned_*_*_*'), + fileName = cms.untracked.string('refit_DAF_SingleMuPt10_UP15_100evts.root') + ) + +process.p = cms.Path(process.MeasurementTrackerEvent*process.TrackRefitter*process.ctfWithMaterialTracksDAF) +process.o = cms.EndPath(process.out) + +process.schedule = cms.Schedule(process.p,process.o) + + From 552edeb4e6e9d2e071624994b3793883cadecc11 Mon Sep 17 00:00:00 2001 From: erica brondolin Date: Wed, 25 Jun 2014 18:02:02 +0200 Subject: [PATCH 13/16] Removing cout statements --- .../src/GroupedDAFHitCollector.cc | 24 ++++--------- .../src/SiTrackerMultiRecHitUpdator.cc | 35 +++---------------- .../src/SimpleDAFHitCollector.cc | 29 +++++---------- .../test/DAFRecoTrack_cfg.py | 11 ++++++ .../test/DAFRecoTrack_debug_cfg.py | 14 ++++++-- .../TrackProducer/plugins/DAFTrackProducer.cc | 2 -- .../src/DAFTrackProducerAlgorithm.cc | 9 ++--- .../src/MRHChi2MeasurementEstimator.cc | 3 -- .../TrackFitters/src/KFTrajectoryFitter.cc | 5 ++- .../TrackFitters/src/KFTrajectorySmoother.cc | 4 +-- 10 files changed, 50 insertions(+), 86 deletions(-) diff --git a/RecoTracker/SiTrackerMRHTools/src/GroupedDAFHitCollector.cc b/RecoTracker/SiTrackerMRHTools/src/GroupedDAFHitCollector.cc index 6a8de8bd62e89..8760d83a0565f 100644 --- a/RecoTracker/SiTrackerMRHTools/src/GroupedDAFHitCollector.cc +++ b/RecoTracker/SiTrackerMRHTools/src/GroupedDAFHitCollector.cc @@ -43,9 +43,6 @@ vector GroupedDAFHitCollector::recHits(const Trajectory& //add a protection if all the measurement are on the same layer if(mol.size()<2)return vector(); - //first layer - // cout<<"DAFHitCollectionFromRecTrack: first layer"< GroupedDAFHitCollector::recHits(const Trajectory& //remind that: //groupedMeasurements will return at least a measurement with an invalid hit with no detid LogDebug("MultiRecHitCollector") << "Layer " << mol.back().first << " has " << mol.back().second.size() << " measurements"; - //debug - std::cout << " Original measurements are:\n"; LogTrace("MultiRecHitCollector") << "Original measurements are:"; for( unsigned int iLay = 0; iLay < mol.size(); iLay++){ - std::cout << " Layer " << mol.at(iLay).first << " has " << mol.at(iLay).second.size() << " measurements:\n"; + LogTrace("MultiRecHitCollector") << " Layer " << mol.at(iLay).first << " has " << mol.at(iLay).second.size() << " measurements:"; vector::const_iterator ibeg = (mol.at(iLay)).second.begin(); vector::const_iterator iend = (mol.at(iLay)).second.end(); for (vector::const_iterator imeas = ibeg; imeas != iend; ++imeas){ if (imeas->recHit()->isValid()){ - std::cout << " Valid Hit with DetId " << imeas->recHit()->geographicalId().rawId() + LogTrace("MultiRecHitCollector") << " Valid Hit with DetId " << imeas->recHit()->geographicalId().rawId() << " local position " << imeas->recHit()->hit()->localPosition() - << " global position " << imeas->recHit()->hit()->globalPosition() << "\n"; - LogTrace("MultiRecHitCollector") << "Valid Hit with DetId " << imeas->recHit()->geographicalId().rawId() - << " local position " << imeas->recHit()->hit()->localPosition(); + << " global position " << imeas->recHit()->hit()->globalPosition() ; } else { - std::cout << " Invalid Hit with DetId " << imeas->recHit()->geographicalId().rawId() << std::endl; - LogTrace("MultiRecHitCollector") << "Invalid Hit with DetId " << imeas->recHit()->geographicalId().rawId(); + LogTrace("MultiRecHitCollector") << " Invalid Hit with DetId " << imeas->recHit()->geographicalId().rawId(); } } } //ERICA: I have to understand how are set the TM now. REPLACE THIS PART!! - std::cout << " Grouped measurements are:\n"; vector groupedMeas; if (mol.back().first) groupedMeas = theLM.groupedMeasurements(*(mol.back().first), current, @@ -120,9 +111,8 @@ vector GroupedDAFHitCollector::recHits(const Trajectory& //if (current.isValid()) current.rescaleError(10); } - std::cout << " Ending GroupedDAFHitCollector::recHits >> Original Measurement size " << meas.size() - << "\n >> GroupedDAFHitCollector returned " << result.size() << " measurements" << std::endl; - LogTrace("MultiRecHitCollector") << "Original Measurement size " << meas.size() << " GroupedDAFHitCollector returned " << result.size() << " measurements"; + LogTrace("MultiRecHitCollector") << " Ending GroupedDAFHitCollector::recHits >> Original Measurement size " << meas.size() + << "\n >> GroupedDAFHitCollector returned " << result.size() << " measurements"; //results are sorted in the fitting direction // adding a protection against too few hits and invalid hits (due to failed propagation on the same surface of the original hits) @@ -194,7 +184,7 @@ void GroupedDAFHitCollector::buildMultiRecHits(const vectorrecHit()->hit()); } else{ - std::cout << " This hit is not valid and will not enter in the MRH. " << std::endl; + LogTrace("MultiRecHitCollector") << " This hit is not valid and will not enter in the MRH. " ; } } diff --git a/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc b/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc index 71948fbc5518c..a9aee9d5268d3 100644 --- a/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc +++ b/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc @@ -26,9 +26,7 @@ SiTrackerMultiRecHitUpdator::SiTrackerMultiRecHitUpdator(const TransientTracking TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::buildMultiRecHit(const std::vector& rhv, TrajectoryStateOnSurface tsos, float annealing) const{ - if(debug_){ - std::cout << " Calling SiTrackerMultiRecHitUpdator::buildMultiRecHit with AnnealingFactor: " << annealing << std::endl; - } + LogTrace("SiTrackerMultiRecHitUpdator") << "Calling SiTrackerMultiRecHitUpdator::buildMultiRecHit with AnnealingFactor: " << annealing; TransientTrackingRecHit::ConstRecHitContainer tcomponents; for (std::vector::const_iterator iter = rhv.begin(); iter != rhv.end(); iter++){ TransientTrackingRecHit::RecHitPointer transient = theBuilder->build(*iter); @@ -41,16 +39,8 @@ TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::buildMultiR TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( TransientTrackingRecHit::ConstRecHitPointer original, TrajectoryStateOnSurface tsos, double annealing) const{ - if(debug_){ - std::cout << " Calling SiTrackerMultiRecHitUpdator::update with AnnealingFactor: " << annealing << std::endl; - } LogTrace("SiTrackerMultiRecHitUpdator") << "Calling SiTrackerMultiRecHitUpdator::update with AnnealingFactor: " << annealing; - if (original->isValid()) - LogTrace("SiTrackerMultiRecHitUpdator") << "Original Hit position " << original->localPosition() << " original error " - << original->parametersError(); - else LogTrace("SiTrackerMultiRecHitUpdator") << "Invalid hit"; - if(!tsos.isValid()) { //return original->clone(); throw cms::Exception("SiTrackerMultiRecHitUpdator") << "!!! MultiRecHitUpdator::update(..): tsos NOT valid!!! "; @@ -99,8 +89,6 @@ TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( Tran geomdet = (*iter)->det(); - LogTrace("SiTrackerMultiRecHitUpdator") << "Current reference surface located at " << geomdet->surface().position(); - LogTrace("SiTrackerMultiRecHitUpdator")<< "TSOS position " << tsos.localPosition(); } //if the rechit does not belong to the surface of the tsos @@ -109,15 +97,12 @@ TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( Tran TransientTrackingRecHit::RecHitPointer cloned = theHitPropagator->project(*iter, *geomdet, tsos, theBuilder); //if it is used a sensor by sensor grouping this should not appear - LogTrace("SiTrackerMultiRecHitUpdator") << "hit propagated"; if (cloned->isValid()) updatedcomponents.push_back(cloned); } else { - TransientTrackingRecHit::RecHitPointer cloned = theHitCloner.makeShared(*iter,tsos); if (cloned->isValid()){ updatedcomponents.push_back(cloned); - LogTrace("SiTrackerMultiRecHitUpdator") << "hit cloned"; } } } @@ -148,26 +133,16 @@ TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( Tran //ORCA: float p = ((mymap[counter].second)/total_sum > 0.01 ? (mymap[counter].second)/total_sum : 1.e-6); normmap.push_back(std::pair(mymap[counter].first, p)); - LogTrace("SiTrackerMultiRecHitUpdator")<< " Component hit type " << typeid(*mymap[counter].first).name() + LogTrace("SiTrackerMultiRecHitUpdator")<< " Component hit type " << typeid(*mymap[counter].first).name() << " position " << mymap[counter].first->localPosition() << " error " << mymap[counter].first->localPositionError() << " with weight " << p; - if(debug_){ - std::cout << " Component hit type " << typeid(*mymap[counter].first).name() - << " position " << mymap[counter].first->localPosition() - << " \n\terror " << mymap[counter].first->localPositionError() - << " with weight " << p << std::endl; - } counter++; } SiTrackerMultiRecHitUpdator::LocalParameters param = calcParameters(tsos, normmap); SiTrackerMultiRecHit updated(param.first, param.second, *normmap.front().first->det(), normmap, annealing); - if(debug_){ - std::cout << " Updated Hit position " << updated.localPosition() - << " updated error " << updated.localPositionError() << std::endl; - } LogTrace("SiTrackerMultiRecHitUpdator") << " Updated Hit position " << updated.localPosition() << " updated error " << updated.localPositionError() << std::endl; @@ -201,17 +176,17 @@ double SiTrackerMultiRecHitUpdator::ComputeWeight(const TrajectoryStateOnSurface if( N==1 ){ tsospos[0]=tsos.localPosition().x(); if(!CutWeight) - LogTrace("SiTrackerMultiRecHitUpdator")<< "TSOS position " << tsos.localPosition(); + LogTrace("SiTrackerMultiRecHitUpdator")<< " TSOS position " << tsos.localPosition(); } else if(N==2){ tsospos[0]=tsos.localPosition().x(); tsospos[1]=tsos.localPosition().y(); if(!CutWeight) - LogTrace("SiTrackerMultiRecHitUpdator")<< "TSOS position " << tsos.localPosition(); + LogTrace("SiTrackerMultiRecHitUpdator")<< " TSOS position " << tsos.localPosition(); } else{ if(!CutWeight) - LogTrace("SiTrackerMultiRecHitUpdator")<< "TSOS position not correct. Rec hit of invalid dimension (not 1, 2) but " + LogTrace("SiTrackerMultiRecHitUpdator")<< " TSOS position not correct. Rec hit of invalid dimension (not 1, 2) but " << aRecHit.dimension(); } diff --git a/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc b/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc index 5a23665a463ba..ef20c35b309e8 100644 --- a/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc +++ b/RecoTracker/SiTrackerMRHTools/src/SimpleDAFHitCollector.cc @@ -15,7 +15,7 @@ using namespace std; vector SimpleDAFHitCollector::recHits(const Trajectory& traj, const MeasurementTrackerEvent *theMTE) const{ - if(debug_) std::cout << " Calling SimpleDAFHitCollector::recHits" << std::endl; + LogTrace("MultiRecHitCollector") << " Calling SimpleDAFHitCollector::recHits" << std::endl; //WARNING: At the moment the trajectories has the measurements //with reversed sorting after the track smoothing @@ -24,20 +24,15 @@ vector SimpleDAFHitCollector::recHits(const Trajectory& t if (meas.empty()) return vector(); //debug - if(debug_) std::cout << "Original measurements are:\n"; LogTrace("MultiRecHitCollector") << "Original measurements are:"; for(vector::const_iterator itrajmeas = meas.begin(); itrajmeas < meas.end(); itrajmeas++) { if (itrajmeas->recHit()->isValid()){ - if(debug_){ std::cout << " Valid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() + LogTrace("MultiRecHitCollector") << " Valid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() << " local position " << itrajmeas->recHit()->hit()->localPosition() - << " global position " << itrajmeas->recHit()->hit()->globalPosition() << "\n"; - } - LogTrace("MultiRecHitCollector") << "Valid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() - << " local position " << itrajmeas->recHit()->hit()->localPosition(); + << " global position " << itrajmeas->recHit()->hit()->globalPosition() ; } else { - if(debug_) std::cout << " Invalid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId() << std::endl; - LogTrace("MultiRecHitCollector") << "Invalid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId(); + LogTrace("MultiRecHitCollector") << " Invalid Hit with DetId " << itrajmeas->recHit()->geographicalId().rawId(); } } @@ -58,26 +53,23 @@ vector SimpleDAFHitCollector::recHits(const Trajectory& t TrajectoryStateOnSurface state = itrajmeas->predictedState(); if (!state.isValid()){ - std::cout << "Something wrong! no valid TSOS found for this meas \n"; LogTrace("MultiRecHitCollector") << "Something wrong! no valid TSOS found in current group "; continue; } //collected hits compatible with the itrajmeas if( measDet.measurements(current, *(getEstimator()), tmps)){ - if(debug_) std::cout << " Found " << tmps.size() << " compatible measurements"; + LogTrace("MultiRecHitCollector") << " Found " << tmps.size() << " compatible measurements"; for (std::size_t i=0; i!=tmps.size(); ++i){ DetId idtemps = tmps.hits[i]->geographicalId(); if( idtemps == id && tmps.hits[i]->hit()->isValid() ) { - LogTrace("MultiRecHitCollector") << "This hit is valid "; hits.push_back(tmps.hits[i]->hit()); } } //I will keep the Invalid hit, IF this is not the first one if (hits.empty()){ - std::cout << " -> but no valid hits found in current group.\n "; - LogTrace("MultiRecHitCollector") << "No valid hits found in current group "; + LogTrace("MultiRecHitCollector") << " -> but no valid hits found in current group."; if( result.empty() ) continue; @@ -87,15 +79,13 @@ vector SimpleDAFHitCollector::recHits(const Trajectory& t //measurements in groups are sorted with increating chi2 //sort( *hits.begin(), *hits.end(), TrajMeasLessEstim()); - if(debug_) std::cout << " -> " << hits.size() << " valid hits for this sensor.\n"; - LogTrace("MultiRecHitCollector") << "Found " << hits.size() << " hits for this sensor"; + LogTrace("MultiRecHitCollector") << " -> " << hits.size() << " valid hits for this sensor."; //building a MultiRecHit out of each sensor group result.push_back(TrajectoryMeasurement(state,theUpdator->buildMultiRecHit(hits, state))); } } else { - if(debug_) std::cout << " No measurements found in current group.\n "; - LogTrace("MultiRecHitCollector") << "No valid hits found in current group "; + LogTrace("MultiRecHitCollector") << " No measurements found in current group."; if( result.empty() ) continue; @@ -105,8 +95,7 @@ vector SimpleDAFHitCollector::recHits(const Trajectory& t } } - if(debug_) std::cout << " Ending SimpleDAFHitCollector::recHits >> " << result.size() << std::endl; - LogTrace("MultiRecHitCollector") << "Original Measurement size " << meas.size() << " GroupedDAFHitCollector returned " << result.size() << " measurements"; + LogTrace("MultiRecHitCollector") << " Ending SimpleDAFHitCollector::recHits >> " << result.size(); //adding a protection against too few hits and invalid hits //(due to failed propagation on the same surface of the original hits) diff --git a/RecoTracker/SiTrackerMRHTools/test/DAFRecoTrack_cfg.py b/RecoTracker/SiTrackerMRHTools/test/DAFRecoTrack_cfg.py index 27165729231b8..01dac466a1bc2 100644 --- a/RecoTracker/SiTrackerMRHTools/test/DAFRecoTrack_cfg.py +++ b/RecoTracker/SiTrackerMRHTools/test/DAFRecoTrack_cfg.py @@ -28,6 +28,17 @@ process.MRHFittingSmoother.EstimateCut = -1 process.MRHFittingSmoother.MinNumberOfHits = 3 +process.MessageLogger = cms.Service("MessageLogger", + destinations = cms.untracked.vstring("debugTracking"), #1 + debugModules = cms.untracked.vstring("*"), #2 + categories = cms.untracked.vstring("SiTrackerMultiRecHitUpdator"), #3 + debugTracking = cms.untracked.PSet(threshold = cms.untracked.string("DEBUG"), #4 + DEBUG = cms.untracked.PSet(limit = cms.untracked.int32(0)), #5 + default = cms.untracked.PSet(limit = cms.untracked.int32(0)), #6 + SiTrackerMultiRecHitUpdator = cms.untracked.PSet(limit = cms.untracked.int32(-1)) #7 + ) + ) + process.source = cms.Source("PoolSource", # fileNames = cms.untracked.vstring('file:reco_trk_TTbar_13_5evts.root') fileNames = cms.untracked.vstring('file:reco_trk_SingleMuPt10_UP15_10evts.root') diff --git a/RecoTracker/SiTrackerMRHTools/test/DAFRecoTrack_debug_cfg.py b/RecoTracker/SiTrackerMRHTools/test/DAFRecoTrack_debug_cfg.py index b1683a0e57073..4981331088651 100644 --- a/RecoTracker/SiTrackerMRHTools/test/DAFRecoTrack_debug_cfg.py +++ b/RecoTracker/SiTrackerMRHTools/test/DAFRecoTrack_debug_cfg.py @@ -29,8 +29,18 @@ process.MRHFittingSmoother.MinNumberOfHits = 3 # debug -process.simpleMultiRecHitCollector.Debug = True -process.siTrackerMultiRecHitUpdator.Debug = True +process.MessageLogger = cms.Service("MessageLogger", + destinations = cms.untracked.vstring("debugTracking"), #1 + debugModules = cms.untracked.vstring("*"), #2 + #categories = cms.untracked.vstring("MultiRecHitCollector"),#SiTrackerMultiRecHitUpdator"), #3 + categories = cms.untracked.vstring("DAFTrackProducerAlgorithm"),#SiTrackerMultiRecHitUpdator"), #3 + debugTracking = cms.untracked.PSet(threshold = cms.untracked.string("DEBUG"), #4 + DEBUG = cms.untracked.PSet(limit = cms.untracked.int32(0)), #5 + default = cms.untracked.PSet(limit = cms.untracked.int32(0)), #6 + #MultiRecHitCollector = cms.untracked.PSet(limit = cms.untracked.int32(-1)) #7 + DAFTrackProducerAlgorithm = cms.untracked.PSet(limit = cms.untracked.int32(-1)) #7 + ) + ) process.source = cms.Source("PoolSource", # fileNames = cms.untracked.vstring('file:reco_trk_TTbar_13_5evts.root') diff --git a/RecoTracker/TrackProducer/plugins/DAFTrackProducer.cc b/RecoTracker/TrackProducer/plugins/DAFTrackProducer.cc index dc5dab12238a2..e831ae735c3bb 100644 --- a/RecoTracker/TrackProducer/plugins/DAFTrackProducer.cc +++ b/RecoTracker/TrackProducer/plugins/DAFTrackProducer.cc @@ -40,7 +40,6 @@ DAFTrackProducer::DAFTrackProducer(const edm::ParameterSet& iConfig): void DAFTrackProducer::produce(edm::Event& theEvent, const edm::EventSetup& setup) { -// std::cout << "Analyzing event number: " << theEvent.id() << "\n"; edm::LogInfo("DAFTrackProducer") << "Analyzing event number: " << theEvent.id() << "\n"; //empty output collections @@ -102,7 +101,6 @@ void DAFTrackProducer::produce(edm::Event& theEvent, const edm::EventSetup& setu outputTrajectoryColl, algoResults, theBuilder.product()); putInEvtTrajAnn(theEvent, trajannResults, outputTrajAnnColl); -// std::cout << "DAFTrackProducer: end the DAF algorithm." << "\n"; LogDebug("DAFTrackProducer") << "end the DAF algorithm." << "\n"; } diff --git a/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc b/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc index 55fcd324fdec3..d53879a039b32 100644 --- a/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc +++ b/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc @@ -87,9 +87,7 @@ void DAFTrackProducerAlgorithm::runWithCandidate(const TrackingGeometry * theG, } //end of annealing program - //std::cout << (1.*checkHits(*ivtraj, currentTraj))/(1.*(*ivtraj).measurements().size())*100. << std::endl; - - LogDebug("DAFTrackProducerAlgorithm") << "Ended annealing program " << std::endl; + LogDebug("DAFTrackProducerAlgorithm") << "Ended annealing program with " << (1.*checkHits(*ivtraj, currentTraj))/(1.*(*ivtraj).measurements().size())*100. << " unchanged." << std::endl; //computing the ndof keeping into account the weights ndof = calculateNdof(currentTraj); @@ -195,7 +193,7 @@ Trajectory DAFTrackProducerAlgorithm::fit(const std::pairdirection() == oppositeToMomentum) { innertsos = vtraj.firstMeasurement().updatedState(); - //std::cout << "Inner momentum " << innertsos.globalParameters().momentum().mag() << std::endl; } else { innertsos = vtraj.lastMeasurement().updatedState(); } @@ -339,7 +336,7 @@ int DAFTrackProducerAlgorithm::checkHits( Trajectory iInitTraj, const Trajectory int ihit = 0; if ( initmeasurements.empty() || finalmeasurements.empty() || initmeasurements.size() != finalmeasurements.size() ){ - //std::cout << "Initial or Final Trajectory empty or with different size." << std::endl; + LogDebug("DAFTrackProducerAlgorithm") << "Initial or Final Trajectory empty or with different size."; return 0; } diff --git a/TrackingTools/KalmanUpdators/src/MRHChi2MeasurementEstimator.cc b/TrackingTools/KalmanUpdators/src/MRHChi2MeasurementEstimator.cc index 2eb73482965fe..22587bf86b686 100644 --- a/TrackingTools/KalmanUpdators/src/MRHChi2MeasurementEstimator.cc +++ b/TrackingTools/KalmanUpdators/src/MRHChi2MeasurementEstimator.cc @@ -35,11 +35,9 @@ std::pair MRHChi2MeasurementEstimator::estimate(const TrajectorySt double est=0; double annealing = mHit.getAnnealingFactor(); -// std::cout << " Current annealing factor is " << annealing; LogDebug("MRHChi2MeasurementEstimator") << "Current annealing factor is " << annealing; std::vector components = mHit.recHits(); -// std::cout << "; this hit has " << components.size() << " components\n"; LogDebug("MRHChi2MeasurementEstimator") << "this hit has " << components.size() << " components"; int iComp = 0; @@ -65,7 +63,6 @@ std::pair MRHChi2MeasurementEstimator::estimate(const TrajectorySt edm::LogError("SiTrackerMultiRecHitUpdator")<<"SiTrackerMultiRecHitUpdator::ComputeParameters2dim: W not valid!"<geographicalId() << std::endl; - if (hit.isValid() && hit.geographicalId()<1000U) std::cout << "Problem 0 det id for " << typeid(hit).name() << ' ' << hit.det()->geographicalId() << std::endl; + //if (hit.det() && hit.geographicalId()<1000U) LogDebug("TrackFitters")<< "Problem 0 det id for " << typeid(hit).name() << ' ' << hit.det()->geographicalId() ; + //if (hit.isValid() && hit.geographicalId()<1000U) LogDebug("TrackFitters")<< "Problem 0 det id for " << typeid(hit).name() << ' ' << hit.det()->geographicalId(); #ifdef EDM_ML_DEBUG if (hit.isValid()) { diff --git a/TrackingTools/TrackFitters/src/KFTrajectorySmoother.cc b/TrackingTools/TrackFitters/src/KFTrajectorySmoother.cc index 18d1cfae4670d..31466b0802545 100644 --- a/TrackingTools/TrackFitters/src/KFTrajectorySmoother.cc +++ b/TrackingTools/TrackFitters/src/KFTrajectorySmoother.cc @@ -78,12 +78,10 @@ KFTrajectorySmoother::trajectory(const Trajectory& aTraj) const { //check surface just for safety: should never be ==0 because they are skipped in the fitter // if unlikely(hit->det() == nullptr) continue; if unlikely( hit->surface()==nullptr ) { - LogDebug("TrackFitters")<< " Error: invalid hit with no GeomDet attached .... skipping"; + LogDebug("TrackFitters") << " Error: invalid hit with no GeomDet attached .... skipping"; continue; } - if (hit->det() && hit->geographicalId()<1000U) std::cout << "Problem 0 det id for " << typeid(*hit).name() << ' ' << hit->det()->geographicalId() << std::endl; - if (hit->isValid() && hit->geographicalId()<1000U) std::cout << "Problem 0 det id for " << typeid(*hit).name() << ' ' << hit->det()->geographicalId() << std::endl; if (hitcounter != avtm.size())//no propagation needed for first smoothed (==last fitted) hit From 68c561744abf22482a5717e98b004bfb21b4aeb7 Mon Sep 17 00:00:00 2001 From: erica brondolin Date: Wed, 25 Jun 2014 18:12:44 +0200 Subject: [PATCH 14/16] cleaning up - second part --- .../TrackProducer/plugins/TrackRefitter.cc | 2 +- .../src/MRHChi2MeasurementEstimator.cc | 2 +- .../PatternTools/interface/TrajAnnealing.h | 1 - .../PatternTools/src/TrajAnnealing.cc | 21 ------------------- 4 files changed, 2 insertions(+), 24 deletions(-) diff --git a/RecoTracker/TrackProducer/plugins/TrackRefitter.cc b/RecoTracker/TrackProducer/plugins/TrackRefitter.cc index df172b048f79f..d670911bf3279 100644 --- a/RecoTracker/TrackProducer/plugins/TrackRefitter.cc +++ b/RecoTracker/TrackProducer/plugins/TrackRefitter.cc @@ -75,7 +75,7 @@ void TrackRefitter::produce(edm::Event& theEvent, const edm::EventSetup& setup) edm::Handle theTCollection; getFromEvt(theEvent,theTCollection,bs); -// std::cout << "TrackRefitter::produce(none):Number of Trajectories:" << (*theTCollection).size() < MRHChi2MeasurementEstimator::estimate(const TrajectorySt case 2: return estimate<2>(tsos,aRecHit); //avoid the not-2D hit due to the final sum case ( 1 || 3 || 4 || 5 ):{ -// std::cout << "WARNING:The hit is not 2D: does not count in the MRH Chi2 estimation." << std::endl; + LogDebug("MRHChi2MeasurementEstimator") << "WARNING:The hit is not 2D: does not count in the MRH Chi2 estimation." ; double est = 0.0; return HitReturnType(false, est); } diff --git a/TrackingTools/PatternTools/interface/TrajAnnealing.h b/TrackingTools/PatternTools/interface/TrajAnnealing.h index 10fa200ecd65e..512afdb13adfe 100644 --- a/TrackingTools/PatternTools/interface/TrajAnnealing.h +++ b/TrackingTools/PatternTools/interface/TrajAnnealing.h @@ -23,7 +23,6 @@ class TrajAnnealing TrajAnnealing( Trajectory, float ); - void Debug() const; float getAnnealing() const { return annealing_; } Trajectory getTraj() const { return traj_; } diff --git a/TrackingTools/PatternTools/src/TrajAnnealing.cc b/TrackingTools/PatternTools/src/TrajAnnealing.cc index 4ebf06e91d636..5e1f74c5df5a4 100644 --- a/TrackingTools/PatternTools/src/TrajAnnealing.cc +++ b/TrackingTools/PatternTools/src/TrajAnnealing.cc @@ -24,31 +24,10 @@ TrajAnnealing::TrajAnnealing( Trajectory traj, float ann ){ } } -void TrajAnnealing::Debug() const{ - - std::vector measurements = traj_.measurements(); - std::vector vmeas = traj_.measurements(); - std::vector::reverse_iterator imeas; - - //I run inversely on the trajectory obtained and update the state - for (imeas = vmeas.rbegin(); imeas != vmeas.rend(); imeas++){ - if (imeas->recHit()->isValid()){ - SiTrackerMultiRecHit const & mHit = dynamic_cast(*imeas->recHit()); - std::vector components = mHit.recHits(); - int iComp = 0; - std::cout << "Annealing: " << mHit.getAnnealingFactor(); - for(std::vector::const_iterator iter2 = components.begin(); iter2 != components.end(); iter2++, iComp++){ - std::cout << "\tHit weight in mrh " << mHit.weight(iComp) << "\t"; - } - } - } -} - std::pair > TrajAnnealing::getAnnealingWeight( const TrackingRecHit& aRecHit ) const { if (!aRecHit.isValid()) { std::vector dumpyVec = {0.0}; -// std::cout << "Invalid RecHit passed " << std::endl; return make_pair(0.0,dumpyVec); } From e316058c8a3c1b106cf7f1a1c309247732adf119 Mon Sep 17 00:00:00 2001 From: erica brondolin Date: Tue, 1 Jul 2014 10:00:45 +0200 Subject: [PATCH 15/16] @slava77 comments --- .../TrackerRecHit2D/interface/SiTrackerMultiRecHit.h | 3 ++- .../interface/SiTrackerMultiRecHitUpdator.h | 6 +++--- .../plugins/MultiRecHitCollectorESProducer.cc | 6 +++--- .../plugins/MultiRecHitCollectorESProducer.h | 2 +- RecoTracker/SiTrackerMRHTools/plugins/module.cc | 4 ---- .../SiTrackerMRHTools/src/GroupedDAFHitCollector.cc | 7 ++----- .../SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc | 6 +++--- 7 files changed, 14 insertions(+), 20 deletions(-) diff --git a/DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h b/DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h index 20565673ef958..5e64fde8303e8 100644 --- a/DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h +++ b/DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h @@ -16,7 +16,8 @@ class SiTrackerMultiRecHit : public BaseTrackerRecHit typedef BaseTrackerRecHit Base; SiTrackerMultiRecHit(): theHits(), - theWeights(){} + theWeights(), + annealing_(0){} virtual ~SiTrackerMultiRecHit(){} diff --git a/RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h b/RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h index 35dba6f79ad78..b4bad7fe1c183 100644 --- a/RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h +++ b/RecoTracker/SiTrackerMRHTools/interface/SiTrackerMultiRecHitUpdator.h @@ -37,18 +37,18 @@ class SiTrackerMultiRecHitUpdator{ //calls the update method in order to build a SiTrackerMultiRecHit virtual TransientTrackingRecHit::RecHitPointer buildMultiRecHit(const std::vector& rhv, - TrajectoryStateOnSurface tsos, + const TrajectoryStateOnSurface& tsos, float annealing=1.) const; //updates an existing SiTrackerMultiRecHit //in case a different kind of rechit is passed it returns clone(tsos) virtual TransientTrackingRecHit::RecHitPointer update( TransientTrackingRecHit::ConstRecHitPointer original, - TrajectoryStateOnSurface tsos, + const TrajectoryStateOnSurface& tsos, double annealing=1.) const; //returns a SiTrackerMultiRecHit out of the transient components TransientTrackingRecHit::RecHitPointer update( TransientTrackingRecHit::ConstRecHitContainer& tcomponents, - TrajectoryStateOnSurface tsos, + const TrajectoryStateOnSurface& tsos, double annealing=1.) const; //computes weights or the cut-off value (depending on CutWeight variable) diff --git a/RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.cc b/RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.cc index 2d77870064ce7..c43dc61c6b9da 100644 --- a/RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.cc +++ b/RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.cc @@ -55,20 +55,20 @@ MultiRecHitCollectorESProducer::produce(const MultiRecHitRecord& iRecord){ std::string propagatorOppositeName = conf_.getParameter("propagatorOpposite"); ESHandle propagatorOppositehandle; iRecord.getRecord().getRecord().get(propagatorOppositeName, propagatorOppositehandle); - _collector = boost::shared_ptr(new GroupedDAFHitCollector(measurementhandle.product(), + collector_ = boost::shared_ptr(new GroupedDAFHitCollector(measurementhandle.product(), mrhuhandle.product(), estimatorhandle.product(), propagatorhandle.product(), propagatorOppositehandle.product(), debug)); } else { - _collector = boost::shared_ptr(new SimpleDAFHitCollector(measurementhandle.product(), + collector_ = boost::shared_ptr(new SimpleDAFHitCollector(measurementhandle.product(), mrhuhandle.product(), estimatorhandle.product(), propagatorhandle.product(), debug)); } - return _collector; + return collector_; } diff --git a/RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.h b/RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.h index d520f19b10434..eb847da40d24a 100644 --- a/RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.h +++ b/RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.h @@ -26,7 +26,7 @@ class MultiRecHitCollectorESProducer: public edm::ESProducer{ void setConf(const edm::ParameterSet& conf){ conf_ = conf; } private: - boost::shared_ptr _collector; + boost::shared_ptr collector_; edm::ParameterSet conf_; }; diff --git a/RecoTracker/SiTrackerMRHTools/plugins/module.cc b/RecoTracker/SiTrackerMRHTools/plugins/module.cc index 0aa90fb47201f..d6aa149330662 100644 --- a/RecoTracker/SiTrackerMRHTools/plugins/module.cc +++ b/RecoTracker/SiTrackerMRHTools/plugins/module.cc @@ -3,8 +3,6 @@ #include "RecoTracker/SiTrackerMRHTools/plugins/SiTrackerMultiRecHitUpdatorESProducer.h" #include "RecoTracker/SiTrackerMRHTools/plugins/MultiRecHitCollectorESProducer.h" -//#include "RecoTracker/SiTrackerMRHTools/plugins/SiTrackerMultiRecHitUpdatorMTFESProducer.h" -//#include "RecoTracker/SiTrackerMRHTools/plugins/MultiTrackFilterCollectorESProducer.h" #include "FWCore/Framework/interface/ModuleFactory.h" #include "FWCore/Framework/interface/ESProducer.h" @@ -13,5 +11,3 @@ DEFINE_FWK_EVENTSETUP_MODULE(SiTrackerMultiRecHitUpdatorESProducer); DEFINE_FWK_EVENTSETUP_MODULE(MultiRecHitCollectorESProducer); -//DEFINE_FWK_EVENTSETUP_MODULE(SiTrackerMultiRecHitUpdatorMTFESProducer); -//DEFINE_FWK_EVENTSETUP_MODULE(MultiTrackFilterCollectorESProducer); diff --git a/RecoTracker/SiTrackerMRHTools/src/GroupedDAFHitCollector.cc b/RecoTracker/SiTrackerMRHTools/src/GroupedDAFHitCollector.cc index 8760d83a0565f..fba80bf4311a9 100644 --- a/RecoTracker/SiTrackerMRHTools/src/GroupedDAFHitCollector.cc +++ b/RecoTracker/SiTrackerMRHTools/src/GroupedDAFHitCollector.cc @@ -13,8 +13,6 @@ #include #include -#define _debug_GroupedDAFHitCollector_ - using namespace std; vector GroupedDAFHitCollector::recHits(const Trajectory& traj, @@ -194,7 +192,7 @@ void GroupedDAFHitCollector::buildMultiRecHits(const vector::iterator iter = hits.begin(); iter != hits.end(); iter++){ string validity = "valid"; @@ -206,8 +204,7 @@ void GroupedDAFHitCollector::buildMultiRecHits(const vectorgeomTracker()->idToDet((*iter)->geographicalId())->position() << " hit local position " << (*iter)->localPosition(); } -#endif - //ERICA: Why I pass all the hits and only the TSOS of igroup->measurements().front().predictedState() + result.push_back(TrajectoryMeasurement(state,theUpdator->buildMultiRecHit(hits, state))); } //can this happen? it means that the measgroup was not empty but no valid measurement was found inside diff --git a/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc b/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc index a9aee9d5268d3..55c41fa378383 100644 --- a/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc +++ b/RecoTracker/SiTrackerMRHTools/src/SiTrackerMultiRecHitUpdator.cc @@ -24,7 +24,7 @@ SiTrackerMultiRecHitUpdator::SiTrackerMultiRecHitUpdator(const TransientTracking TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::buildMultiRecHit(const std::vector& rhv, - TrajectoryStateOnSurface tsos, + const TrajectoryStateOnSurface& tsos, float annealing) const{ LogTrace("SiTrackerMultiRecHitUpdator") << "Calling SiTrackerMultiRecHitUpdator::buildMultiRecHit with AnnealingFactor: " << annealing; TransientTrackingRecHit::ConstRecHitContainer tcomponents; @@ -37,7 +37,7 @@ TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::buildMultiR } TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( TransientTrackingRecHit::ConstRecHitPointer original, - TrajectoryStateOnSurface tsos, + const TrajectoryStateOnSurface& tsos, double annealing) const{ LogTrace("SiTrackerMultiRecHitUpdator") << "Calling SiTrackerMultiRecHitUpdator::update with AnnealingFactor: " << annealing; @@ -61,7 +61,7 @@ TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( Tran /*------------------------------------------------------------------------------------------------------------------------*/ TransientTrackingRecHit::RecHitPointer SiTrackerMultiRecHitUpdator::update( TransientTrackingRecHit::ConstRecHitContainer& tcomponents, - TrajectoryStateOnSurface tsos, + const TrajectoryStateOnSurface& tsos, double annealing) const{ if (tcomponents.empty()){ From e9445630445fdcd1434940b0b74329ae34387726 Mon Sep 17 00:00:00 2001 From: erica brondolin Date: Wed, 2 Jul 2014 11:55:51 +0200 Subject: [PATCH 16/16] fixed things (like getByToken and other comments) --- .../interface/DAFTrackProducerAlgorithm.h | 4 +- .../TrackProducer/plugins/DAFTrackProducer.cc | 7 ++-- .../TrackProducer/plugins/DAFTrackProducer.h | 3 ++ .../src/DAFTrackProducerAlgorithm.cc | 25 +++++++---- .../PatternTools/interface/TrajAnnealing.h | 17 ++++---- .../PatternTools/src/TrajAnnealing.cc | 41 +++++++++++++------ 6 files changed, 61 insertions(+), 36 deletions(-) diff --git a/RecoTracker/TrackProducer/interface/DAFTrackProducerAlgorithm.h b/RecoTracker/TrackProducer/interface/DAFTrackProducerAlgorithm.h index d38c3806baf76..767590f6ad864 100644 --- a/RecoTracker/TrackProducer/interface/DAFTrackProducerAlgorithm.h +++ b/RecoTracker/TrackProducer/interface/DAFTrackProducerAlgorithm.h @@ -36,7 +36,7 @@ class DAFTrackProducerAlgorithm { public: - DAFTrackProducerAlgorithm(const edm::ParameterSet& pset):conf_(pset){} + DAFTrackProducerAlgorithm(const edm::ParameterSet& conf); ~DAFTrackProducerAlgorithm() {} /// Run the Final Fit taking TrackCandidates as input @@ -91,7 +91,7 @@ class DAFTrackProducerAlgorithm { int checkHits( Trajectory iInitTraj, const Trajectory iFinalTraj) const; edm::ParameterSet conf_; - + int minHits_; }; #endif diff --git a/RecoTracker/TrackProducer/plugins/DAFTrackProducer.cc b/RecoTracker/TrackProducer/plugins/DAFTrackProducer.cc index e831ae735c3bb..2752128ecf6ca 100644 --- a/RecoTracker/TrackProducer/plugins/DAFTrackProducer.cc +++ b/RecoTracker/TrackProducer/plugins/DAFTrackProducer.cc @@ -24,6 +24,7 @@ DAFTrackProducer::DAFTrackProducer(const edm::ParameterSet& iConfig): setSrc( consumes(iConfig.getParameter( "src" )), consumes(iConfig.getParameter( "beamSpot" )), consumes(iConfig.getParameter( "MeasurementTrackerEvent") )); + src_ = consumes(iConfig.getParameter( "src" )); setAlias( iConfig.getParameter( "@module_label" ) ); //register your products @@ -109,8 +110,7 @@ void DAFTrackProducer::getFromEvt(edm::Event& theEvent,edm::Handle( "src" ); - theEvent.getByLabel(src_,theTrajectoryCollection ); + theEvent.getByToken(src_,theTrajectoryCollection ); //get the BeamSpot edm::Handle recoBeamSpotHandle; @@ -125,8 +125,7 @@ void DAFTrackProducer::putInEvtTrajAnn(edm::Event& theEvent, TrajAnnealingCollec outputTrajAnnColl->reserve(size); for(unsigned int i = 0; i < trajannResults.size() ; i++){ -// trajannResults.at(i).Debug(); - outputTrajAnnColl->push_back(trajannResults.at(i)); + outputTrajAnnColl->push_back(trajannResults[i]); } theEvent.put( outputTrajAnnColl ); diff --git a/RecoTracker/TrackProducer/plugins/DAFTrackProducer.h b/RecoTracker/TrackProducer/plugins/DAFTrackProducer.h index faaac103133c3..c96068c706265 100644 --- a/RecoTracker/TrackProducer/plugins/DAFTrackProducer.h +++ b/RecoTracker/TrackProducer/plugins/DAFTrackProducer.h @@ -28,7 +28,10 @@ class DAFTrackProducer : public KfTrackProducerBase, public edm::EDProducer { void getFromEvt(edm::Event&, edm::Handle&, reco::BeamSpot&); void putInEvtTrajAnn(edm::Event& theEvent, TrajAnnealingCollection & trajannResults, std::auto_ptr& selTrajAnn); + bool TrajAnnSaving_; + edm::EDGetToken src_; + }; #endif diff --git a/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc b/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc index d53879a039b32..70ce70c720dc8 100644 --- a/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc +++ b/RecoTracker/TrackProducer/src/DAFTrackProducerAlgorithm.cc @@ -23,6 +23,12 @@ #include "DataFormats/TrackerRecHit2D/interface/TkCloner.h" #include "TrackingTools/PatternTools/interface/TrajAnnealing.h" + +DAFTrackProducerAlgorithm::DAFTrackProducerAlgorithm(const edm::ParameterSet& conf): + conf_(conf), + minHits_(conf.getParameter("MinHits")){} + + void DAFTrackProducerAlgorithm::runWithCandidate(const TrackingGeometry * theG, const MagneticField * theMF, const std::vector& theTrajectoryCollection, @@ -36,7 +42,7 @@ void DAFTrackProducerAlgorithm::runWithCandidate(const TrackingGeometry * theG, TrajAnnealingCollection& trajann, bool TrajAnnSaving_) const { - edm::LogInfo("TrackProducer") << "Number of Trajectories: " << theTrajectoryCollection.size() << "\n"; + LogDebug("DAFTrackProducerAlgorithm") << "Number of Trajectories: " << theTrajectoryCollection.size() << "\n"; int cont = 0; //running on src trajectory collection @@ -51,7 +57,7 @@ void DAFTrackProducerAlgorithm::runWithCandidate(const TrackingGeometry * theG, //no need to have std::vector vtraj ! if ( (*ivtraj).isValid() ){ - edm::LogInfo("TrackProducer") << "The trajectory is valid. \n"; + LogDebug("DAFTrackProducerAlgorithm") << "The trajectory is valid. \n"; //getting the MultiRecHit collection and the trajectory with a first fit-smooth round std::pair hits = @@ -96,9 +102,9 @@ void DAFTrackProducerAlgorithm::runWithCandidate(const TrackingGeometry * theG, //in order to remove tracks with too many outliers. //std::vector filtered; - //filter(theFitter, vtraj, conf_.getParameter("MinHits"), filtered, builder); + //filter(theFitter, vtraj, minHits_, filtered, builder); - if(currentTraj.foundHits() >= conf_.getParameter("MinHits")) { + if(currentTraj.foundHits() >= minHits_) { bool ok = buildTrack(currentTraj, algoResults, ndof, bs) ; if(ok) cont++; @@ -114,7 +120,7 @@ void DAFTrackProducerAlgorithm::runWithCandidate(const TrackingGeometry * theG, } //end run on track collection - LogDebug("TrackProducer") << "Number of Tracks found: " << cont << "\n"; + LogDebug("DAFTrackProducerAlgorithm") << "Number of Tracks found: " << cont << "\n"; } /*------------------------------------------------------------------------------------------------------*/ @@ -335,8 +341,13 @@ int DAFTrackProducerAlgorithm::checkHits( Trajectory iInitTraj, const Trajectory int nSame = 0; int ihit = 0; - if ( initmeasurements.empty() || finalmeasurements.empty() || initmeasurements.size() != finalmeasurements.size() ){ - LogDebug("DAFTrackProducerAlgorithm") << "Initial or Final Trajectory empty or with different size."; + if( initmeasurements.empty() || finalmeasurements.empty() ){ + LogDebug("DAFTrackProducerAlgorithm") << "Initial or Final Trajectory empty."; + return 0; + } + + if( initmeasurements.size() != finalmeasurements.size() ) { + LogDebug("DAFTrackProducerAlgorithm") << "Initial and Final Trajectory have different size."; return 0; } diff --git a/TrackingTools/PatternTools/interface/TrajAnnealing.h b/TrackingTools/PatternTools/interface/TrajAnnealing.h index 512afdb13adfe..8ae4fb9f4d6f9 100644 --- a/TrackingTools/PatternTools/interface/TrajAnnealing.h +++ b/TrackingTools/PatternTools/interface/TrajAnnealing.h @@ -1,17 +1,14 @@ -/** \class TrajAnnealing - * Allow to save all the traj info - * for each annealing cycle - * suitable for algorithm like DAF - * - * \author in May 2014 by brondolin - */ - #ifndef DataFormats_TrajAnnealing_h #define DataFormats_TrajAnnealing_h #include -//class +/** This class allow to save all the traj info + * for each annealing cycle + * suitable for algorithm like DAF + * (not used in default options) + */ + class TrajAnnealing { public: @@ -21,7 +18,7 @@ class TrajAnnealing theWeights(){} virtual ~TrajAnnealing(){} - TrajAnnealing( Trajectory, float ); + TrajAnnealing( const Trajectory&, float ); float getAnnealing() const { return annealing_; } Trajectory getTraj() const { return traj_; } diff --git a/TrackingTools/PatternTools/src/TrajAnnealing.cc b/TrackingTools/PatternTools/src/TrajAnnealing.cc index 5e1f74c5df5a4..b3624c45cf50e 100644 --- a/TrackingTools/PatternTools/src/TrajAnnealing.cc +++ b/TrackingTools/PatternTools/src/TrajAnnealing.cc @@ -3,25 +3,40 @@ #include "TrackingTools/PatternTools/interface/TrajectoryMeasurement.h" #include "DataFormats/TrackerRecHit2D/interface/SiTrackerMultiRecHit.h" -TrajAnnealing::TrajAnnealing( Trajectory traj, float ann ){ +TrajAnnealing::TrajAnnealing( const Trajectory& traj, float ann ){ traj_ = traj; annealing_ = ann; - std::vector measurements = traj_.measurements(); - std::vector vmeas = traj_.measurements(); - std::vector::reverse_iterator imeas; - - for (imeas = vmeas.rbegin(); imeas != vmeas.rend(); imeas++){ - theHits_.push_back(imeas->recHit()); - if (imeas->recHit()->isValid()){ - SiTrackerMultiRecHit const & mHit = dynamic_cast(*imeas->recHit()); - std::vector components = mHit.recHits(); - int iComp = 0; - for(std::vector::const_iterator iter2 = components.begin(); iter2 != components.end(); iter2++, iComp++){ - theWeights.push_back(mHit.weight(iComp)); + const Trajectory::DataContainer& measurements = traj_.measurements(); + if( measurements.size() > 2 ){ + + Trajectory::DataContainer::const_iterator ibegin,iend; + int increment(0); + if( traj.direction() == alongMomentum ){ + ibegin = measurements.begin(); + iend = measurements.end(); + increment = 1; + } else { + ibegin = measurements.end(); + iend = measurements.begin(); + increment = -1; + } + + for( Trajectory::DataContainer::const_iterator imeas = ibegin; imeas != iend; imeas += increment ){ + theHits_.push_back(imeas->recHit()); + if (imeas->recHit()->isValid()){ + SiTrackerMultiRecHit const & mHit = dynamic_cast(*imeas->recHit()); + std::vector components = mHit.recHits(); + int iComp = 0; + for(std::vector::const_iterator iter = components.begin(); + iter != components.end(); iter++, iComp++){ + theWeights.push_back(mHit.weight(iComp)); + } } } + } + } std::pair > TrajAnnealing::getAnnealingWeight( const TrackingRecHit& aRecHit ) const {