File indexing completed on 2023-01-17 23:57:58
0001
0002
0003
0004
0005
0006
0007 #include <memory>
0008 #include <string>
0009 #include <iostream>
0010
0011 #include "DataFormats/Common/interface/Handle.h"
0012 #include "FWCore/Framework/interface/ESHandle.h"
0013 #include "FWCore/Framework/interface/EventSetup.h"
0014
0015 #include "FWCore/Framework/interface/Frameworkfwd.h"
0016 #include "FWCore/Framework/interface/one/EDAnalyzer.h"
0017
0018 #include "FWCore/Framework/interface/Event.h"
0019 #include "FWCore/Framework/interface/MakerMacros.h"
0020
0021
0022 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0023 #include "FWCore/ServiceRegistry/interface/Service.h"
0024 #include "FWCore/Utilities/interface/InputTag.h"
0025
0026
0027 #include "DataFormats/SiPixelCluster/interface/SiPixelCluster.h"
0028 #include "DataFormats/TrackerRecHit2D/interface/SiPixelRecHitCollection.h"
0029 #include "DataFormats/Common/interface/DetSetVector.h"
0030 #include "DataFormats/Common/interface/Ref.h"
0031 #include "DataFormats/DetId/interface/DetId.h"
0032
0033 #include "DataFormats/SiPixelDetId/interface/PXBDetId.h"
0034 #include "DataFormats/SiPixelDetId/interface/PXFDetId.h"
0035 #include "DataFormats/SiPixelDetId/interface/PixelSubdetector.h"
0036
0037 #include "DataFormats/TrackerCommon/interface/PixelBarrelName.h"
0038
0039 #include "Geometry/CommonDetUnit/interface/PixelGeomDetUnit.h"
0040 #include "Geometry/CommonDetUnit/interface/PixelGeomDetType.h"
0041 #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
0042 #include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
0043 #include "Geometry/CommonDetUnit/interface/GeomDetType.h"
0044 #include "Geometry/CommonDetUnit/interface/GeomDet.h"
0045
0046
0047
0048 #include "L1Trigger/GlobalTriggerAnalyzer/interface/L1GtUtils.h"
0049 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutSetupFwd.h"
0050 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutSetup.h"
0051 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutRecord.h"
0052 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerObjectMapRecord.h"
0053
0054
0055 #include "DataFormats/HLTReco/interface/TriggerEvent.h"
0056 #include "DataFormats/HLTReco/interface/TriggerTypeDefs.h"
0057 #include "DataFormats/Common/interface/TriggerResults.h"
0058 #include "HLTrigger/HLTcore/interface/HLTConfigProvider.h"
0059 #include "FWCore/Common/interface/TriggerNames.h"
0060
0061
0062 #include "DataFormats/TrackReco/interface/Track.h"
0063 #include "TrackingTools/PatternTools/interface/Trajectory.h"
0064
0065
0066
0067 #include "TrackingTools/TransientTrack/interface/TransientTrack.h"
0068
0069 #include "TrackingTools/PatternTools/interface/TrajTrackAssociation.h"
0070
0071
0072 #include "TrackingTools/TrackFitters/interface/TrajectoryStateCombiner.h"
0073
0074
0075
0076
0077
0078
0079
0080
0081
0082
0083
0084
0085 #include "RecoVertex/VertexPrimitives/interface/TransientVertex.h"
0086 #include <DataFormats/VertexReco/interface/VertexFwd.h>
0087
0088
0089 #include "DataFormats/Luminosity/interface/LumiSummary.h"
0090 #include "DataFormats/Common/interface/ConditionsInEdm.h"
0091
0092
0093 #include "FWCore/ServiceRegistry/interface/Service.h"
0094 #include "CommonTools/UtilAlgos/interface/TFileService.h"
0095
0096 #include "DataFormats/Provenance/interface/RunLumiEventNumber.h"
0097
0098
0099 #include <TROOT.h>
0100 #include <TChain.h>
0101 #include <TFile.h>
0102 #include <TF1.h>
0103 #include <TH2F.h>
0104 #include <TH1F.h>
0105 #include <TProfile.h>
0106 #include <TVector3.h>
0107
0108 #define HISTOS
0109
0110
0111
0112 #define VDM_STUDIES
0113
0114 const bool isData = false;
0115
0116 using namespace std;
0117
0118 class TestWithTracks : public edm::one::EDAnalyzer<edm::one::SharedResources> {
0119 public:
0120 explicit TestWithTracks(const edm::ParameterSet &conf);
0121 virtual ~TestWithTracks();
0122 virtual void analyze(const edm::Event &e, const edm::EventSetup &c) override;
0123 virtual void beginJob() override;
0124 virtual void endJob() override;
0125
0126 private:
0127 edm::EDGetTokenT<LumiSummary> lumiToken_;
0128 edm::EDGetTokenT<edm::ConditionsInLumiBlock> condToken_;
0129 edm::EDGetTokenT<L1GlobalTriggerReadoutRecord> l1gtrrToken_;
0130 edm::EDGetTokenT<edm::TriggerResults> hltToken_;
0131 edm::EDGetTokenT<reco::VertexCollection> vtxToken_;
0132 edm::EDGetTokenT<reco::TrackCollection> srcToken_;
0133 edm::EDGetTokenT<TrajTrackAssociationCollection> trackAssocToken_;
0134
0135 edm::ESGetToken<TrackerGeometry, TrackerDigiGeometryRecord> trackerGeomToken_;
0136
0137 bool PRINT;
0138 float countTracks, countGoodTracks, countTracksInPix, countPVs, countEvents, countLumi;
0139
0140 TH1D *hcharge1, *hcharge2, *hcharge3, *hcharge4, *hcharge5;
0141 TH1D *hsize1, *hsize2, *hsize3, *hsizex1, *hsizex2, *hsizex3, *hsizey1, *hsizey2, *hsizey3;
0142 TH1D *hsize4, *hsize5,
0143 *hsizex4, *hsizex5, *hsizey4, *hsizey5;
0144
0145 TH1D *hclusPerTrk1, *hclusPerTrk2, *hclusPerTrk3, *hclusPerTrk4, *hclusPerTrk5;
0146 TH1D *hclusPerLay1, *hclusPerLay2, *hclusPerLay3;
0147 TH1D *hclusPerDisk1, *hclusPerDisk2, *hclusPerDisk3, *hclusPerDisk4;
0148 TH1D *hclusPerTrk, *hclusPerTrkB, *hclusPerTrkF;
0149
0150 TH2F *hDetMap1, *hDetMap2, *hDetMap3;
0151 TH2F *hcluDetMap1, *hcluDetMap2, *hcluDetMap3;
0152
0153 TH2F *hpvxy, *hclusMap1, *hclusMap2, *hclusMap3;
0154
0155 TH1D *hpvz, *hpvr, *hNumPv, *hNumPvClean;
0156 TH1D *hPt, *hEta, *hDz, *hD0, *hzdiff;
0157
0158 TH1D *hl1a, *hl1t, *hlt1;
0159
0160 TH1D *hclusBpix, *hpixBpix;
0161 TH1D *htracks, *htracksGood, *htracksGoodInPix;
0162
0163 TProfile *hclumult1, *hclumult2, *hclumult3;
0164 TProfile *hclumultx1, *hclumultx2, *hclumultx3;
0165 TProfile *hclumulty1, *hclumulty2, *hclumulty3;
0166 TProfile *hcluchar1, *hcluchar2, *hcluchar3;
0167
0168 TProfile *hclumultld1, *hclumultld2, *hclumultld3;
0169 TProfile *hclumultxld1, *hclumultxld2, *hclumultxld3;
0170 TProfile *hclumultyld1, *hclumultyld2, *hclumultyld3;
0171 TProfile *hclucharld1, *hclucharld2, *hclucharld3;
0172
0173 TProfile *htracksls, *hpvsls, *htrackslsn, *hpvslsn, *hintgl, *hinstl, *hbeam1, *hbeam2;
0174 TProfile *hmult1, *hmult2, *hmult3;
0175 TProfile *hclusPerTrkVsEta, *hclusPerTrkVsPt, *hclusPerTrkVsls, *hclusPerTrkVsEtaB, *hclusPerTrkVsEtaF;
0176
0177 TH1D *hlumi, *hlumi0, *hbx, *hbx0;
0178
0179 TH1D *recHitXError1, *recHitXError2, *recHitXError3;
0180 TH1D *recHitYError1, *recHitYError2, *recHitYError3;
0181 TH1D *recHitXAlignError1, *recHitXAlignError2, *recHitXAlignError3;
0182 TH1D *recHitYAlignError1, *recHitYAlignError2, *recHitYAlignError3;
0183 TH1D *recHitXError4, *recHitXError5, *recHitXError6, *recHitXError7;
0184 TH1D *recHitYError4, *recHitYError5, *recHitYError6, *recHitYError7;
0185 TH1D *recHitXAlignError4, *recHitXAlignError5, *recHitXAlignError6, *recHitXAlignError7;
0186 TH1D *recHitYAlignError4, *recHitYAlignError5, *recHitYAlignError6, *recHitYAlignError7;
0187 TProfile *hErrorXB, *hErrorYB, *hErrorXF, *hErrorYF;
0188 TProfile *hAErrorXB, *hAErrorYB, *hAErrorXF, *hAErrorYF;
0189
0190 #ifdef VDM_STUDIES
0191 TProfile *hcharCluls, *hcharPixls, *hsizeCluls, *hsizeXCluls;
0192 TProfile *hcharCluls1, *hcharPixls1, *hsizeCluls1, *hsizeXCluls1;
0193 TProfile *hcharCluls2, *hcharPixls2, *hsizeCluls2, *hsizeXCluls2;
0194 TProfile *hcharCluls3, *hcharPixls3, *hsizeCluls3, *hsizeXCluls3;
0195 TProfile *hclusls;
0196 TProfile *hclusls1, *hclusls2, *hclusls3;
0197 TProfile *hclubx, *hpvbx, *htrackbx;
0198 #endif
0199 };
0200
0201
0202 TestWithTracks::TestWithTracks(edm::ParameterSet const &conf) {
0203 usesResource(TFileService::kSharedResource);
0204 PRINT = conf.getUntrackedParameter<bool>("Verbosity", false);
0205 lumiToken_ = consumes<LumiSummary>(edm::InputTag("lumiProducer"));
0206 condToken_ = consumes<edm::ConditionsInLumiBlock>(edm::InputTag("conditionsInEdm"));
0207 l1gtrrToken_ = consumes<L1GlobalTriggerReadoutRecord>(edm::InputTag("gtDigis"));
0208 hltToken_ = consumes<edm::TriggerResults>(edm::InputTag("TriggerResults", "", "HLT"));
0209 vtxToken_ = consumes<reco::VertexCollection>(edm::InputTag("offlinePrimaryVertices"));
0210 srcToken_ = consumes<reco::TrackCollection>(conf.getParameter<edm::InputTag>("src"));
0211 trackAssocToken_ =
0212 consumes<TrajTrackAssociationCollection>(edm::InputTag(conf.getParameter<std::string>("trajectoryInput")));
0213 trackerGeomToken_ = esConsumes<TrackerGeometry, TrackerDigiGeometryRecord>();
0214
0215 }
0216
0217
0218 TestWithTracks::~TestWithTracks() = default;
0219
0220
0221 void TestWithTracks::beginJob() {
0222 edm::LogPrint("TestWithTracks") << "BeginJob, Verbosity " << PRINT;
0223
0224 countTracks = 0.;
0225 countGoodTracks = 0.;
0226 countTracksInPix = 0.;
0227 countPVs = 0.;
0228 countEvents = 0.;
0229 countLumi = 0.;
0230
0231 #ifdef HISTOS
0232 edm::Service<TFileService> fs;
0233
0234 int sizeH = 20;
0235 float lowH = -0.5;
0236 float highH = 19.5;
0237 hclusPerTrk1 = fs->make<TH1D>("hclusPerTrk1", "Clus per track l1", sizeH, lowH, highH);
0238 hclusPerTrk2 = fs->make<TH1D>("hclusPerTrk2", "Clus per track l2", sizeH, lowH, highH);
0239 hclusPerTrk3 = fs->make<TH1D>("hclusPerTrk3", "Clus per track l3", sizeH, lowH, highH);
0240 hclusPerTrk4 = fs->make<TH1D>("hclusPerTrk4", "Clus per track d1", sizeH, lowH, highH);
0241 hclusPerTrk5 = fs->make<TH1D>("hclusPerTrk5", "Clus per track d2", sizeH, lowH, highH);
0242 hclusPerTrk = fs->make<TH1D>("hclusPerTrk", "Clus per track", sizeH, lowH, highH);
0243 hclusPerTrkB = fs->make<TH1D>("hclusPerTrkB", "B Clus per track", sizeH, lowH, highH);
0244 hclusPerTrkF = fs->make<TH1D>("hclusPerTrkF", "F Clus per track", sizeH, lowH, highH);
0245
0246 sizeH = 2000;
0247 highH = 1999.5;
0248 hclusPerLay1 = fs->make<TH1D>("hclusPerLay1", "Clus per layer l1", sizeH, lowH, highH);
0249 hclusPerLay2 = fs->make<TH1D>("hclusPerLay2", "Clus per layer l2", sizeH, lowH, highH);
0250 hclusPerLay3 = fs->make<TH1D>("hclusPerLay3", "Clus per layer l3", sizeH, lowH, highH);
0251 hclusPerDisk1 = fs->make<TH1D>("hclusPerDisk1", "Clus per disk 1", sizeH, lowH, highH);
0252 hclusPerDisk2 = fs->make<TH1D>("hclusPerDisk2", "Clus per disk 2", sizeH, lowH, highH);
0253 hclusPerDisk3 = fs->make<TH1D>("hclusPerDisk3", "Clus per disk 3", sizeH, lowH, highH);
0254 hclusPerDisk4 = fs->make<TH1D>("hclusPerDisk4", "Clus per disk 4", sizeH, lowH, highH);
0255
0256 hcharge1 = fs->make<TH1D>("hcharge1", "Clu charge l1", 400, 0., 200.);
0257 hcharge2 = fs->make<TH1D>("hcharge2", "Clu charge l2", 400, 0., 200.);
0258 hcharge3 = fs->make<TH1D>("hcharge3", "Clu charge l3", 400, 0., 200.);
0259 hcharge4 = fs->make<TH1D>("hcharge4", "Clu charge d1", 400, 0., 200.);
0260 hcharge5 = fs->make<TH1D>("hcharge5", "Clu charge d2", 400, 0., 200.);
0261
0262 hsize1 = fs->make<TH1D>("hsize1", "layer 1 clu size", 100, -0.5, 99.5);
0263 hsize2 = fs->make<TH1D>("hsize2", "layer 2 clu size", 100, -0.5, 99.5);
0264 hsize3 = fs->make<TH1D>("hsize3", "layer 3 clu size", 100, -0.5, 99.5);
0265 hsizex1 = fs->make<TH1D>("hsizex1", "lay1 clu size in x", 20, -0.5, 19.5);
0266 hsizex2 = fs->make<TH1D>("hsizex2", "lay2 clu size in x", 20, -0.5, 19.5);
0267 hsizex3 = fs->make<TH1D>("hsizex3", "lay3 clu size in x", 20, -0.5, 19.5);
0268 hsizey1 = fs->make<TH1D>("hsizey1", "lay1 clu size in y", 30, -0.5, 29.5);
0269 hsizey2 = fs->make<TH1D>("hsizey2", "lay2 clu size in y", 30, -0.5, 29.5);
0270 hsizey3 = fs->make<TH1D>("hsizey3", "lay3 clu size in y", 30, -0.5, 29.5);
0271
0272 hsize4 = fs->make<TH1D>("hsize4", "disk 1 clu size", 100, -0.5, 99.5);
0273 hsize5 = fs->make<TH1D>("hsize5", "disk 2 clu size", 100, -0.5, 99.5);
0274 hsizex4 = fs->make<TH1D>("hsizex4", "d1 clu size in x", 20, -0.5, 19.5);
0275 hsizex5 = fs->make<TH1D>("hsizex5", "d2 clu size in x", 20, -0.5, 19.5);
0276 hsizey4 = fs->make<TH1D>("hsizey4", "d1 clu size in y", 30, -0.5, 29.5);
0277 hsizey5 = fs->make<TH1D>("hsizey5", "d2 clu size in y", 30, -0.5, 29.5);
0278
0279 hDetMap1 = fs->make<TH2F>("hDetMap1", "layer 1 clus map", 9, 0., 9., 23, 0., 23.);
0280 hDetMap2 = fs->make<TH2F>("hDetMap2", "layer 2 clus map", 9, 0., 9., 33, 0., 33.);
0281 hDetMap3 = fs->make<TH2F>("hDetMap3", "layer 3 clus map", 9, 0., 9., 45, 0., 45.);
0282
0283
0284
0285
0286
0287
0288 hcluDetMap1 = fs->make<TH2F>("hcluDetMap1", "clu det layer 1", 416, 0., 416., 160, 0., 160.);
0289 hcluDetMap2 = fs->make<TH2F>("hcluDetMap2", "clu det layer 2", 416, 0., 416., 160, 0., 160.);
0290 hcluDetMap3 = fs->make<TH2F>("hcluDetMap3", "clu det layer 3", 416, 0., 416., 160, 0., 160.);
0291
0292 htracksGoodInPix = fs->make<TH1D>("htracksGoodInPix", "count good tracks in pix", 2000, -0.5, 1999.5);
0293 htracksGood = fs->make<TH1D>("htracksGood", "count good tracks", 2000, -0.5, 1999.5);
0294 htracks = fs->make<TH1D>("htracks", "count tracks", 2000, -0.5, 1999.5);
0295 hclusBpix = fs->make<TH1D>("hclusBpix", "count clus in bpix", 200, -0.5, 1999.5);
0296 hpixBpix = fs->make<TH1D>("hpixBpix", "count pixels", 200, -0.5, 1999.5);
0297
0298 hpvxy = fs->make<TH2F>("hpvxy", "pv xy", 100, -1., 1., 100, -1., 1.);
0299 hpvz = fs->make<TH1D>("hpvz", "pv z", 1000, -50., 50.);
0300 hpvr = fs->make<TH1D>("hpvr", "pv r", 100, 0., 1.);
0301 hNumPv = fs->make<TH1D>("hNumPv", "num of pv", 100, 0., 100.);
0302 hNumPvClean = fs->make<TH1D>("hNumPvClean", "num of pv clean", 100, 0., 100.);
0303
0304 hPt = fs->make<TH1D>("hPt", "pt", 120, 0., 120.);
0305 hEta = fs->make<TH1D>("hEta", "eta", 50, -2.5, 2.5);
0306 hD0 = fs->make<TH1D>("hD0", "d0", 500, 0., 5.);
0307 hDz = fs->make<TH1D>("hDz", "pt", 250, -25., 25.);
0308 hzdiff = fs->make<TH1D>("hzdiff", "PVz-Trackz", 200, -10., 10.);
0309
0310 hl1a = fs->make<TH1D>("hl1a", "l1a", 128, -0.5, 127.5);
0311 hl1t = fs->make<TH1D>("hl1t", "l1t", 128, -0.5, 127.5);
0312 hlt1 = fs->make<TH1D>("hlt1", "hlt1", 256, -0.5, 255.5);
0313
0314 hclumult1 = fs->make<TProfile>("hclumult1", "cluster size layer 1", 60, -3., 3., 0.0, 100.);
0315 hclumult2 = fs->make<TProfile>("hclumult2", "cluster size layer 2", 60, -3., 3., 0.0, 100.);
0316 hclumult3 = fs->make<TProfile>("hclumult3", "cluster size layer 3", 60, -3., 3., 0.0, 100.);
0317
0318 hclumultx1 = fs->make<TProfile>("hclumultx1", "cluster x-size layer 1", 60, -3., 3., 0.0, 100.);
0319 hclumultx2 = fs->make<TProfile>("hclumultx2", "cluster x-size layer 2", 60, -3., 3., 0.0, 100.);
0320 hclumultx3 = fs->make<TProfile>("hclumultx3", "cluster x-size layer 3", 60, -3., 3., 0.0, 100.);
0321
0322 hclumulty1 = fs->make<TProfile>("hclumulty1", "cluster y-size layer 1", 60, -3., 3., 0.0, 100.);
0323 hclumulty2 = fs->make<TProfile>("hclumulty2", "cluster y-size layer 2", 60, -3., 3., 0.0, 100.);
0324 hclumulty3 = fs->make<TProfile>("hclumulty3", "cluster y-size layer 3", 60, -3., 3., 0.0, 100.);
0325
0326 hcluchar1 = fs->make<TProfile>("hcluchar1", "cluster char layer 1", 60, -3., 3., 0.0, 1000.);
0327 hcluchar2 = fs->make<TProfile>("hcluchar2", "cluster char layer 2", 60, -3., 3., 0.0, 1000.);
0328 hcluchar3 = fs->make<TProfile>("hcluchar3", "cluster char layer 3", 60, -3., 3., 0.0, 1000.);
0329
0330
0331 hclumultld1 = fs->make<TProfile>("hclumultld1", "cluster size layer 1", 23, -11.5, 11.5, 0.0, 100.);
0332 hclumultld2 = fs->make<TProfile>("hclumultld2", "cluster size layer 2", 35, -17.5, 17.5, 0.0, 100.);
0333 hclumultld3 = fs->make<TProfile>("hclumultld3", "cluster size layer 3", 47, -23.5, 23.5, 0.0, 100.);
0334
0335 hclumultxld1 = fs->make<TProfile>("hclumultxld1", "cluster x-size layer 1", 23, -11.5, 11.5, 0.0, 100.);
0336 hclumultxld2 = fs->make<TProfile>("hclumultxld2", "cluster x-size layer 2", 35, -17.5, 17.5, 0.0, 100.);
0337 hclumultxld3 = fs->make<TProfile>("hclumultxld3", "cluster x-size layer 3", 47, -23.5, 23.5, 0.0, 100.);
0338
0339 hclumultyld1 = fs->make<TProfile>("hclumultyld1", "cluster y-size layer 1", 23, -11.5, 11.5, 0.0, 100.);
0340 hclumultyld2 = fs->make<TProfile>("hclumultyld2", "cluster y-size layer 2", 35, -17.5, 17.5, 0.0, 100.);
0341 hclumultyld3 = fs->make<TProfile>("hclumultyld3", "cluster y-size layer 3", 47, -23.5, 23.5, 0.0, 100.);
0342
0343 hclucharld1 = fs->make<TProfile>("hclucharld1", "cluster char layer 1", 23, -11.5, 11.5, 0.0, 1000.);
0344 hclucharld2 = fs->make<TProfile>("hclucharld2", "cluster char layer 2", 35, -17.5, 17.5, 0.0, 1000.);
0345 hclucharld3 = fs->make<TProfile>("hclucharld3", "cluster char layer 3", 47, -23.5, 23.5, 0.0, 1000.);
0346
0347 hintgl = fs->make<TProfile>("hintgl", "inst lumi vs ls ", 1000, 0., 3000., 0.0, 10000.);
0348 hinstl = fs->make<TProfile>("hinstl", "intg lumi vs ls ", 1000, 0., 3000., 0.0, 100.);
0349 hbeam1 = fs->make<TProfile>("hbeam1", "beam1 vs ls ", 1000, 0., 3000., 0.0, 1000.);
0350 hbeam2 = fs->make<TProfile>("hbeam2", "beam2 vs ls ", 1000, 0., 3000., 0.0, 1000.);
0351
0352 htracksls = fs->make<TProfile>("htracksls", "tracks with pix hits vs ls", 1000, 0., 3000., 0.0, 10000.);
0353 hpvsls = fs->make<TProfile>("hpvsls", "pvs vs ls", 1000, 0., 3000., 0.0, 1000.);
0354 htrackslsn = fs->make<TProfile>("htrackslsn", "tracks with pix hits/lumi vs ls", 1000, 0., 3000., 0.0, 10000.);
0355 hpvslsn = fs->make<TProfile>("hpvslsn", "pvs/lumi vs ls", 1000, 0., 3000., 0.0, 1000.);
0356
0357 hmult1 = fs->make<TProfile>("hmult1", "clu mult layer 1", 10, 0., 10., 0.0, 1000.);
0358 hmult2 = fs->make<TProfile>("hmult2", "clu mult layer 2", 10, 0., 10., 0.0, 1000.);
0359 hmult3 = fs->make<TProfile>("hmult3", "clu mult layer 3", 10, 0., 10., 0.0, 1000.);
0360
0361 hclusPerTrkVsEta = fs->make<TProfile>("hclusPerTrkVsEta", "clus per trk vs.eta", 60, -3., 3., 0.0, 100.);
0362 hclusPerTrkVsPt = fs->make<TProfile>("hclusPerTrkVsPt", "clus per trk vs.pt", 120, 0., 120., 0.0, 100.);
0363 hclusPerTrkVsls = fs->make<TProfile>("hclusPerTrkVsls", "clus per trk vs.ls", 300, 0., 3000., 0.0, 100.);
0364 hclusPerTrkVsEtaF = fs->make<TProfile>("hclusPerTrkVsEtaF", "F clus per trk vs.eta", 60, -3., 3., 0.0, 100.);
0365 hclusPerTrkVsEtaB = fs->make<TProfile>("hclusPerTrkVsEtaB", "B clus per trk vs.eta", 60, -3., 3., 0.0, 100.);
0366
0367 hlumi0 = fs->make<TH1D>("hlumi0", "lumi", 2000, 0, 2000.);
0368 hlumi = fs->make<TH1D>("hlumi", "lumi", 2000, 0, 2000.);
0369 hbx0 = fs->make<TH1D>("hbx0", "bx", 4000, 0, 4000.);
0370 hbx = fs->make<TH1D>("hbx", "bx", 4000, 0, 4000.);
0371
0372 hclusMap1 = fs->make<TH2F>("hclusMap1", "clus - lay1", 260, -26., 26., 350, -3.5, 3.5);
0373 hclusMap2 = fs->make<TH2F>("hclusMap2", "clus - lay2", 260, -26., 26., 350, -3.5, 3.5);
0374 hclusMap3 = fs->make<TH2F>("hclusMap3", "clus - lay3", 260, -26., 26., 350, -3.5, 3.5);
0375
0376
0377
0378 recHitXAlignError1 = fs->make<TH1D>("recHitXAlignError1", "RecHit X Alignment errors bpix 1", 100, 0., 100.);
0379 recHitYAlignError1 = fs->make<TH1D>("recHitYAlignError1", "RecHit Y Alignment errors bpix 1", 100, 0., 100.);
0380 recHitXAlignError2 = fs->make<TH1D>("recHitXAlignError2", "RecHit X Alignment errors bpix 2", 100, 0., 100.);
0381 recHitYAlignError2 = fs->make<TH1D>("recHitYAlignError2", "RecHit Y Alignment errors bpix 2", 100, 0., 100.);
0382 recHitXAlignError3 = fs->make<TH1D>("recHitXAlignError3", "RecHit X Alignment errors bpix 3", 100, 0., 100.);
0383 recHitYAlignError3 = fs->make<TH1D>("recHitYAlignError3", "RecHit Y Alignment errors bpix 3", 100, 0., 100.);
0384 recHitXAlignError4 = fs->make<TH1D>("recHitXAlignError4", "RecHit X Alignment errors fpix -d2", 100, 0., 100.);
0385 recHitYAlignError4 = fs->make<TH1D>("recHitYAlignError4", "RecHit Y Alignment errors fpix -d2", 100, 0., 100.);
0386 recHitXAlignError5 = fs->make<TH1D>("recHitXAlignError5", "RecHit X Alignment errors fpix -d1", 100, 0., 100.);
0387 recHitYAlignError5 = fs->make<TH1D>("recHitYAlignError5", "RecHit Y Alignment errors fpix -d1", 100, 0., 100.);
0388 recHitXAlignError6 = fs->make<TH1D>("recHitXAlignError6", "RecHit X Alignment errors fpix +d1", 100, 0., 100.);
0389 recHitYAlignError6 = fs->make<TH1D>("recHitYAlignError6", "RecHit Y Alignment errors fpix +d1", 100, 0., 100.);
0390 recHitXAlignError7 = fs->make<TH1D>("recHitXAlignError7", "RecHit X Alignment errors fpix +d2", 100, 0., 100.);
0391 recHitYAlignError7 = fs->make<TH1D>("recHitYAlignError7", "RecHit Y Alignment errors fpix +d2", 100, 0., 100.);
0392
0393 recHitXError1 = fs->make<TH1D>("recHitXError1", "RecHit X errors bpix 1", 100, 0., 100.);
0394 recHitYError1 = fs->make<TH1D>("recHitYError1", "RecHit Y errors bpix 1", 100, 0., 100.);
0395 recHitXError2 = fs->make<TH1D>("recHitXError2", "RecHit X errors bpix 2", 100, 0., 100.);
0396 recHitYError2 = fs->make<TH1D>("recHitYError2", "RecHit Y errors bpix 2", 100, 0., 100.);
0397 recHitXError3 = fs->make<TH1D>("recHitXError3", "RecHit X errors bpix 3", 100, 0., 100.);
0398 recHitYError3 = fs->make<TH1D>("recHitYError3", "RecHit Y errors bpix 3", 100, 0., 100.);
0399 recHitXError4 = fs->make<TH1D>("recHitXError4", "RecHit X errors fpix -d2", 100, 0., 100.);
0400 recHitYError4 = fs->make<TH1D>("recHitYError4", "RecHit Y errors fpix -d2", 100, 0., 100.);
0401 recHitXError5 = fs->make<TH1D>("recHitXError5", "RecHit X errors fpix -d1", 100, 0., 100.);
0402 recHitYError5 = fs->make<TH1D>("recHitYError5", "RecHit Y errors fpix -d1", 100, 0., 100.);
0403 recHitXError6 = fs->make<TH1D>("recHitXError6", "RecHit X errors fpix +d1", 100, 0., 100.);
0404 recHitYError6 = fs->make<TH1D>("recHitYError6", "RecHit Y errors fpix +d1", 100, 0., 100.);
0405 recHitXError7 = fs->make<TH1D>("recHitXError7", "RecHit X errors fpix +d2", 100, 0., 100.);
0406 recHitYError7 = fs->make<TH1D>("recHitYError7", "RecHit Y errors fpix +d2", 100, 0., 100.);
0407
0408 hErrorXB = fs->make<TProfile>("hErrorXB", "bpix x errors per ladder", 220, 0., 220., 0.0, 1000.);
0409 hErrorXF = fs->make<TProfile>("hErrorXF", "fpix x errors per ladder", 100, 0., 100., 0.0, 1000.);
0410 hErrorYB = fs->make<TProfile>("hErrorYB", "bpix y errors per ladder", 220, 0., 220., 0.0, 1000.);
0411 hErrorYF = fs->make<TProfile>("hErrorYF", "fpix y errors per ladder", 100, 0., 100., 0.0, 1000.);
0412
0413 hAErrorXB = fs->make<TProfile>("hAErrorXB", "bpix x errors per ladder", 220, 0., 220., 0.0, 1000.);
0414 hAErrorXF = fs->make<TProfile>("hAErrorXF", "fpix x errors per ladder", 100, 0., 100., 0.0, 1000.);
0415 hAErrorYB = fs->make<TProfile>("hAErrorYB", "bpix y errors per ladder", 220, 0., 220., 0.0, 1000.);
0416 hAErrorYF = fs->make<TProfile>("hAErrorYF", "fpix y errors per ladder", 100, 0., 100., 0.0, 1000.);
0417
0418 #ifdef VDM_STUDIES
0419 highH = 3000.;
0420 sizeH = 1000;
0421
0422 hclusls = fs->make<TProfile>("hclusls", "clus vs ls", sizeH, 0., highH, 0.0, 30000.);
0423
0424
0425 hcharCluls = fs->make<TProfile>("hcharCluls", "clu char vs ls", sizeH, 0., highH, 0.0, 100.);
0426
0427 hsizeCluls = fs->make<TProfile>("hsizeCluls", "clu size vs ls", sizeH, 0., highH, 0.0, 1000.);
0428 hsizeXCluls = fs->make<TProfile>("hsizeXCluls", "clu size-x vs ls", sizeH, 0., highH, 0.0, 100.);
0429
0430 hcharCluls1 = fs->make<TProfile>("hcharCluls1", "clu char vs ls", sizeH, 0., highH, 0.0, 100.);
0431
0432 hsizeCluls1 = fs->make<TProfile>("hsizeCluls1", "clu size vs ls", sizeH, 0., highH, 0.0, 1000.);
0433 hsizeXCluls1 = fs->make<TProfile>("hsizeXCluls1", "clu size-x vs ls", sizeH, 0., highH, 0.0, 100.);
0434 hcharCluls2 = fs->make<TProfile>("hcharCluls2", "clu char vs ls", sizeH, 0., highH, 0.0, 100.);
0435
0436 hsizeCluls2 = fs->make<TProfile>("hsizeCluls2", "clu size vs ls", sizeH, 0., highH, 0.0, 1000.);
0437 hsizeXCluls2 = fs->make<TProfile>("hsizeXCluls2", "clu size-x vs ls", sizeH, 0., highH, 0.0, 100.);
0438 hcharCluls3 = fs->make<TProfile>("hcharCluls3", "clu char vs ls", sizeH, 0., highH, 0.0, 100.);
0439
0440 hsizeCluls3 = fs->make<TProfile>("hsizeCluls3", "clu size vs ls", sizeH, 0., highH, 0.0, 1000.);
0441 hsizeXCluls3 = fs->make<TProfile>("hsizeXCluls3", "clu size-x vs ls", sizeH, 0., highH, 0.0, 100.);
0442 hclusls1 = fs->make<TProfile>("hclusls1", "clus vs ls", sizeH, 0., highH, 0.0, 30000.);
0443
0444 hclusls2 = fs->make<TProfile>("hclusls2", "clus vs ls", sizeH, 0., highH, 0.0, 30000.);
0445
0446 hclusls3 = fs->make<TProfile>("hclusls3", "clus vs ls", sizeH, 0., highH, 0.0, 30000.);
0447
0448
0449
0450
0451 hclubx = fs->make<TProfile>("hclubx", "clus vs bx ", 4000, -0.5, 3999.5, 0.0, 1000000.);
0452 hpvbx = fs->make<TProfile>("hpvbx", "pvs vs bx ", 4000, -0.5, 3999.5, 0.0, 1000000.);
0453 htrackbx = fs->make<TProfile>("htrackbx", "tracks vs bx ", 4000, -0.5, 3999.5, 0.0, 1000000.);
0454
0455 #endif
0456
0457 #endif
0458 }
0459
0460 void TestWithTracks::endJob() {
0461 edm::LogPrint("TestWithTracks") << " End PixelTracksTest, events = " << countEvents;
0462
0463 if (countEvents > 0.) {
0464 countTracks /= countEvents;
0465 countGoodTracks /= countEvents;
0466 countTracksInPix /= countEvents;
0467 countPVs /= countEvents;
0468 countLumi /= 1000.;
0469 edm::LogPrint("TestWithTracks") << " Average tracks/event " << countTracks << " good " << countGoodTracks
0470 << " in pix " << countTracksInPix << " PVs " << countPVs << " events "
0471 << countEvents << " lumi pb-1 " << countLumi << "/10, bug!";
0472 }
0473 }
0474
0475
0476 void TestWithTracks::analyze(const edm::Event &e, const edm::EventSetup &es) {
0477 using namespace edm;
0478 using namespace reco;
0479 static LuminosityBlockNumber_t lumiBlockOld = -9999;
0480
0481 const float CLU_SIZE_PT_CUT = 1.;
0482
0483 int trackNumber = 0;
0484 int countNiceTracks = 0;
0485 int countPixTracks = 0;
0486
0487 int numberOfClusters = 0;
0488 int numberOfPixels = 0;
0489
0490 int numOfClusPerTrk1 = 0;
0491 int numOfClustersPerLay1 = 0;
0492
0493
0494 int numOfClusPerTrk2 = 0;
0495 int numOfClustersPerLay2 = 0;
0496
0497
0498 int numOfClusPerTrk3 = 0;
0499 int numOfClustersPerLay3 = 0;
0500
0501
0502 int numOfClusPerTrk4 = 0;
0503 int numOfClustersPerLay4 = 0;
0504
0505
0506 int numOfClusPerTrk5 = 0;
0507 int numOfClustersPerLay5 = 0;
0508
0509
0510 int numOfClustersPerDisk1 = 0;
0511 int numOfClustersPerDisk2 = 0;
0512 int numOfClustersPerDisk3 = 0;
0513 int numOfClustersPerDisk4 = 0;
0514
0515 RunNumber_t const run = e.id().run();
0516 EventNumber_t const event = e.id().event();
0517 LuminosityBlockNumber_t const lumiBlock = e.luminosityBlock();
0518
0519 int bx = e.bunchCrossing();
0520
0521
0522 if (PRINT)
0523 edm::LogPrint("TestWithTracks") << "Run " << run << " Event " << event << " LS " << lumiBlock;
0524
0525 hbx0->Fill(float(bx));
0526 hlumi0->Fill(float(lumiBlock));
0527
0528 edm::LuminosityBlock const &iLumi = e.getLuminosityBlock();
0529 edm::Handle<LumiSummary> lumi;
0530 iLumi.getByToken(lumiToken_, lumi);
0531 edm::Handle<edm::ConditionsInLumiBlock> cond;
0532 float intlumi = 0, instlumi = 0;
0533 int beamint1 = 0, beamint2 = 0;
0534 iLumi.getByToken(condToken_, cond);
0535
0536
0537
0538
0539 if (lumi.isValid()) {
0540 intlumi = (lumi->intgRecLumi()) / 1000.;
0541 instlumi = (lumi->avgInsDelLumi()) / 1000.;
0542 beamint1 = (cond->totalIntensityBeam1) / 1000;
0543 beamint2 = (cond->totalIntensityBeam2) / 1000;
0544 } else {
0545
0546 }
0547
0548 hinstl->Fill(float(lumiBlock), float(instlumi));
0549 hintgl->Fill(float(lumiBlock), float(intlumi));
0550 hbeam1->Fill(float(lumiBlock), float(beamint1));
0551 hbeam2->Fill(float(lumiBlock), float(beamint2));
0552
0553 #ifdef L1
0554
0555 Handle<L1GlobalTriggerReadoutRecord> L1GTRR;
0556 e.getByToken(l1gtrrToken_, L1GTRR);
0557
0558 if (L1GTRR.isValid()) {
0559
0560
0561 for (unsigned int i = 0; i < L1GTRR->decisionWord().size(); ++i) {
0562 int l1flag = L1GTRR->decisionWord()[i];
0563 int t1flag = L1GTRR->technicalTriggerWord()[i];
0564
0565 if (l1flag > 0)
0566 hl1a->Fill(float(i));
0567 if (t1flag > 0 && i < 64)
0568 hl1t->Fill(float(i));
0569 }
0570 }
0571 #endif
0572
0573 #ifdef HLT
0574
0575 bool hlt[256];
0576 for (int i = 0; i < 256; ++i)
0577 hlt[i] = false;
0578
0579 edm::TriggerNames TrigNames;
0580 edm::Handle<edm::TriggerResults> HLTResults;
0581
0582
0583 e.getByToken(hltToken_, HLTResults);
0584 if ((HLTResults.isValid() == true) && (HLTResults->size() > 0)) {
0585
0586 const edm::TriggerNames &TrigNames = e.triggerNames(*HLTResults);
0587
0588
0589
0590 for (unsigned int i = 0; i < TrigNames.triggerNames().size(); i++) {
0591
0592
0593 if ((HLTResults->wasrun(TrigNames.triggerIndex(TrigNames.triggerName(i))) == true) &&
0594 (HLTResults->accept(TrigNames.triggerIndex(TrigNames.triggerName(i))) == true) &&
0595 (HLTResults->error(TrigNames.triggerIndex(TrigNames.triggerName(i))) == false)) {
0596 hlt[i] = true;
0597 hlt1->Fill(float(i));
0598
0599 }
0600
0601 }
0602 }
0603 #endif
0604
0605
0606 edm::ESHandle<TrackerGeometry> geom = es.getHandle(trackerGeomToken_);
0607 const TrackerGeometry &theTracker(*geom);
0608
0609
0610
0611 edm::Handle<reco::VertexCollection> vertices;
0612 e.getByToken(vtxToken_, vertices);
0613
0614 if (PRINT)
0615 edm::LogPrint("TestWithTracks") << " PV list " << vertices->size();
0616 int pvNotFake = 0, pvsTrue = 0;
0617 vector<float> pvzVector;
0618 for (reco::VertexCollection::const_iterator iv = vertices->begin(); iv != vertices->end(); ++iv) {
0619 if ((iv->isFake()) == 1)
0620 continue;
0621 pvNotFake++;
0622 float pvx = iv->x();
0623 float pvy = iv->y();
0624 float pvz = iv->z();
0625 int numTracksPerPV = iv->tracksSize();
0626
0627
0628
0629
0630
0631
0632
0633
0634 if (PRINT)
0635 edm::LogPrint("TestWithTracks") << " PV " << pvNotFake << " pos = " << pvx << "/" << pvy << "/" << pvz
0636 << ", Num of tracks " << numTracksPerPV;
0637
0638 hpvz->Fill(pvz);
0639 if (pvz > -22. && pvz < 22.) {
0640 float pvr = sqrt(pvx * pvx + pvy * pvy);
0641 hpvxy->Fill(pvx, pvy);
0642 hpvr->Fill(pvr);
0643 if (pvr < 0.3) {
0644 pvsTrue++;
0645 pvzVector.push_back(pvz);
0646
0647 }
0648 }
0649
0650
0651
0652 }
0653 hNumPv->Fill(float(pvNotFake));
0654 hNumPvClean->Fill(float(pvsTrue));
0655
0656 if (PRINT)
0657 edm::LogPrint("TestWithTracks") << " Not fake PVs = " << pvNotFake << " good position " << pvsTrue;
0658
0659
0660
0661 Handle<reco::TrackCollection> recTracks;
0662 e.getByToken(srcToken_, recTracks);
0663
0664 if (PRINT)
0665 edm::LogPrint("TestWithTracks") << " Tracks " << recTracks->size();
0666 for (reco::TrackCollection::const_iterator t = recTracks->begin(); t != recTracks->end(); ++t) {
0667 trackNumber++;
0668 numOfClusPerTrk1 = 0;
0669 numOfClusPerTrk2 = 0;
0670 numOfClusPerTrk3 = 0;
0671 numOfClusPerTrk4 = 0;
0672 numOfClusPerTrk5 = 0;
0673 int pixelHits = 0;
0674
0675 int size = t->recHitsSize();
0676 float pt = t->pt();
0677 float eta = t->eta();
0678 float phi = t->phi();
0679
0680 float d0 = t->d0();
0681 float dz = t->dz();
0682
0683
0684
0685
0686 if (PRINT)
0687 edm::LogPrint("TestWithTracks") << "Track " << trackNumber << " Pt " << pt << " Eta " << eta << " d0/dz " << d0
0688 << " " << dz << " Hits " << size;
0689
0690 hEta->Fill(eta);
0691 hDz->Fill(dz);
0692 if (abs(eta) > 2.8 || abs(dz) > 25.)
0693 continue;
0694
0695 hD0->Fill(d0);
0696 if (d0 > 1.0)
0697 continue;
0698
0699 bool goodTrack = false;
0700 for (vector<float>::iterator m = pvzVector.begin(); m != pvzVector.end(); ++m) {
0701 float z = *m;
0702 float tmp = abs(z - dz);
0703 hzdiff->Fill(tmp);
0704 if (tmp < 1.)
0705 goodTrack = true;
0706 }
0707
0708 if (isData && !goodTrack)
0709 continue;
0710 countNiceTracks++;
0711 hPt->Fill(pt);
0712
0713
0714 for (trackingRecHit_iterator recHit = t->recHitsBegin(); recHit != t->recHitsEnd(); ++recHit) {
0715 if (!((*recHit)->isValid()))
0716 continue;
0717
0718 if ((*recHit)->geographicalId().det() != DetId::Tracker)
0719 continue;
0720
0721 const DetId &hit_detId = (*recHit)->geographicalId();
0722 uint IntSubDetID = (hit_detId.subdetId());
0723
0724
0725 if (IntSubDetID == 0)
0726 continue;
0727
0728 int layer = 0, ladder = 0, zindex = 0, ladderOn = 0, module = 0, shell = 0;
0729 unsigned int disk = 0;
0730 unsigned int blade = 0;
0731 unsigned int zindexF = 0;
0732 unsigned int side = 0;
0733 unsigned int panel = 0;
0734
0735 if (IntSubDetID == PixelSubdetector::PixelBarrel) {
0736
0737
0738 PXBDetId pdetId = PXBDetId(hit_detId);
0739
0740
0741
0742 layer = pdetId.layer();
0743
0744 ladder = pdetId.ladder();
0745
0746 zindex = pdetId.module();
0747 if (zindex < 5)
0748 side = 1;
0749 else
0750 side = 2;
0751
0752
0753 PixelBarrelName pbn(pdetId);
0754
0755 PixelBarrelName::Shell sh = pbn.shell();
0756
0757 ladderOn = pbn.ladderName();
0758
0759 module = pbn.moduleName();
0760
0761 shell = int(sh);
0762
0763 if (shell == 1 || shell == 2)
0764 module = -module;
0765
0766 if (shell == 1 || shell == 3)
0767 ladderOn = -ladderOn;
0768
0769 if (PRINT)
0770 edm::LogPrint("TestWithTracks") << "barrel layer/ladder/module: " << layer << "/" << ladder << "/" << zindex;
0771
0772 } else if (IntSubDetID == PixelSubdetector::PixelEndcap) {
0773
0774 PXFDetId pdetId = PXFDetId(hit_detId);
0775 disk = pdetId.disk();
0776 blade = pdetId.blade();
0777 zindexF = pdetId.module();
0778 side = pdetId.side();
0779 panel = pdetId.panel();
0780
0781 if (PRINT)
0782 edm::LogPrint("TestWithTracks") << " forward det, disk " << disk << ", blade " << blade << ", module "
0783 << zindexF << ", side " << side << ", panel " << panel;
0784
0785 } else {
0786 continue;
0787 }
0788
0789
0790 const PixelGeomDetUnit *theGeomDet = dynamic_cast<const PixelGeomDetUnit *>(theTracker.idToDet(hit_detId));
0791
0792
0793 const PixelTopology *topol = &(theGeomDet->specificTopology());
0794
0795
0796
0797
0798 const SiPixelRecHit *hit = dynamic_cast<const SiPixelRecHit *>((*recHit));
0799
0800
0801
0802 if (hit) {
0803 if (pt > 1.) {
0804
0805 double xloc = hit->localPosition().x();
0806 double yloc = hit->localPosition().y();
0807
0808 LocalError lerr = hit->localPositionError();
0809 float lerr_x = sqrt(lerr.xx()) * 1E4;
0810 float lerr_y = sqrt(lerr.yy()) * 1E4;
0811
0812 if (layer == 1) {
0813 recHitXError1->Fill(lerr_x);
0814 recHitYError1->Fill(lerr_y);
0815 hErrorXB->Fill(float(ladder + (110 * (side - 1))), lerr_x);
0816 hErrorYB->Fill(float(ladder + (110 * (side - 1))), lerr_y);
0817 } else if (layer == 2) {
0818 recHitXError2->Fill(lerr_x);
0819 recHitYError2->Fill(lerr_y);
0820 hErrorXB->Fill(float(ladder + 25 + (110 * (side - 1))), lerr_x);
0821 hErrorYB->Fill(float(ladder + 25 + (110 * (side - 1))), lerr_y);
0822
0823 } else if (layer == 3) {
0824 recHitXError3->Fill(lerr_x);
0825 recHitYError3->Fill(lerr_y);
0826 hErrorXB->Fill(float(ladder + 60 + (110 * (side - 1))), lerr_x);
0827 hErrorYB->Fill(float(ladder + 60 + (110 * (side - 1))), lerr_y);
0828 } else if ((disk == 2) && (side == 1)) {
0829 recHitXError4->Fill(lerr_x);
0830 recHitYError4->Fill(lerr_y);
0831 hErrorXF->Fill(float(blade), lerr_x);
0832 hErrorYF->Fill(float(blade), lerr_y);
0833
0834 } else if ((disk == 1) && (side == 1)) {
0835 recHitXError5->Fill(lerr_x);
0836 recHitYError5->Fill(lerr_y);
0837 hErrorXF->Fill(float(blade + 25), lerr_x);
0838 hErrorYF->Fill(float(blade + 25), lerr_y);
0839
0840 } else if ((disk == 1) && (side == 2)) {
0841 recHitXError6->Fill(lerr_x);
0842 recHitYError6->Fill(lerr_y);
0843 hErrorXF->Fill(float(blade + 50), lerr_x);
0844 hErrorYF->Fill(float(blade + 50), lerr_y);
0845 } else if ((disk == 2) && (side == 2)) {
0846 recHitXError7->Fill(lerr_x);
0847 recHitYError7->Fill(lerr_y);
0848 hErrorXF->Fill(float(blade + 75), lerr_x);
0849 hErrorYF->Fill(float(blade + 75), lerr_y);
0850 }
0851
0852 LocalError lape = theGeomDet->localAlignmentError();
0853 if (lape.valid()) {
0854 float tmp11 = 0.;
0855 if (lape.xx() > 0.)
0856 tmp11 = sqrt(lape.xx()) * 1E4;
0857
0858 float tmp13 = 0.;
0859 if (lape.yy() > 0.)
0860 tmp13 = sqrt(lape.yy()) * 1E4;
0861
0862 if (layer == 1) {
0863 recHitXAlignError1->Fill(tmp11);
0864 recHitYAlignError1->Fill(tmp13);
0865 hAErrorXB->Fill(float(ladder + (110 * (side - 1))), tmp11);
0866 hAErrorYB->Fill(float(ladder + (110 * (side - 1))), tmp13);
0867 } else if (layer == 2) {
0868 recHitXAlignError2->Fill(tmp11);
0869 recHitYAlignError2->Fill(tmp13);
0870 hAErrorXB->Fill(float(ladder + 25 + (110 * (side - 1))), tmp11);
0871 hAErrorYB->Fill(float(ladder + 25 + (110 * (side - 1))), tmp13);
0872 } else if (layer == 3) {
0873 recHitXAlignError3->Fill(tmp11);
0874 recHitYAlignError3->Fill(tmp13);
0875 hAErrorXB->Fill(float(ladder + 60 + (110 * (side - 1))), tmp11);
0876 hAErrorYB->Fill(float(ladder + 60 + (110 * (side - 1))), tmp13);
0877
0878 } else if ((disk == 2) && (side == 1)) {
0879 recHitXAlignError4->Fill(tmp11);
0880 recHitYAlignError4->Fill(tmp13);
0881 hAErrorXF->Fill(float(blade), tmp11);
0882 hAErrorYF->Fill(float(blade), tmp13);
0883
0884 } else if ((disk == 1) && (side == 1)) {
0885 recHitXAlignError5->Fill(tmp11);
0886 recHitYAlignError5->Fill(tmp13);
0887 hAErrorXF->Fill(float(blade + 25), tmp11);
0888 hAErrorYF->Fill(float(blade + 25), tmp13);
0889 } else if ((disk == 1) && (side == 2)) {
0890 recHitXAlignError6->Fill(tmp11);
0891 recHitYAlignError6->Fill(tmp13);
0892 hAErrorXF->Fill(float(blade + 50), tmp11);
0893 hAErrorYF->Fill(float(blade + 50), tmp13);
0894 } else if ((disk == 2) && (side == 2)) {
0895 recHitXAlignError7->Fill(tmp11);
0896 recHitYAlignError7->Fill(tmp13);
0897 hAErrorXF->Fill(float(blade + 75), tmp11);
0898 hAErrorYF->Fill(float(blade + 75), tmp13);
0899 }
0900
0901
0902 if (PRINT)
0903 edm::LogPrint("TestWithTracks") << " align error " << layer << tmp11 << " " << tmp13;
0904 } else {
0905 edm::LogPrint("TestWithTracks") << " lape = 0";
0906 }
0907
0908 if (PRINT)
0909 edm::LogPrint("TestWithTracks") << " rechit loc " << xloc << " " << yloc << " " << lerr_x << " " << lerr_y;
0910 }
0911
0912 edm::Ref<edmNew::DetSetVector<SiPixelCluster>, SiPixelCluster> const &clust = hit->cluster();
0913
0914 if (!clust.isNonnull())
0915 continue;
0916
0917 numberOfClusters++;
0918 pixelHits++;
0919 float charge = (clust->charge()) / 1000.0;
0920 int size = clust->size();
0921 int sizeX = clust->sizeX();
0922 int sizeY = clust->sizeY();
0923 float row = clust->x();
0924 float col = clust->y();
0925 numberOfPixels += size;
0926
0927
0928
0929 if (PRINT)
0930 edm::LogPrint("TestWithTracks")
0931 << " cluster " << numberOfClusters << " charge = " << charge << " size = " << size;
0932
0933 LocalPoint lp = topol->localPosition(MeasurementPoint(clust->x(), clust->y()));
0934
0935
0936
0937
0938 GlobalPoint clustgp = theGeomDet->surface().toGlobal(lp);
0939 double gX = clustgp.x();
0940 double gY = clustgp.y();
0941 double gZ = clustgp.z();
0942
0943
0944
0945 TVector3 v(gX, gY, gZ);
0946
0947
0948
0949
0950
0951
0952
0953
0954
0955
0956
0957
0958
0959
0960
0961
0962
0963
0964
0965
0966
0967
0968 if (layer == 1) {
0969 hDetMap1->Fill(float(zindex), float(ladder));
0970 hcluDetMap1->Fill(col, row);
0971 hcharge1->Fill(charge);
0972
0973
0974
0975 hclusMap1->Fill(gZ, phi);
0976 hmult1->Fill(zindex, float(size));
0977
0978 if (pt > CLU_SIZE_PT_CUT) {
0979 hsize1->Fill(float(size));
0980 hsizex1->Fill(float(sizeX));
0981 hsizey1->Fill(float(sizeY));
0982
0983 hclumult1->Fill(eta, float(size));
0984 hclumultx1->Fill(eta, float(sizeX));
0985 hclumulty1->Fill(eta, float(sizeY));
0986 hcluchar1->Fill(eta, float(charge));
0987
0988
0989
0990 hclumultld1->Fill(float(ladderOn), size);
0991 hclumultxld1->Fill(float(ladderOn), sizeX);
0992 hclumultyld1->Fill(float(ladderOn), sizeY);
0993 hclucharld1->Fill(float(ladderOn), charge);
0994 }
0995
0996 #ifdef VDM_STUDIES
0997 hcharCluls->Fill(lumiBlock, charge);
0998 hsizeCluls->Fill(lumiBlock, size);
0999 hsizeXCluls->Fill(lumiBlock, sizeX);
1000 hcharCluls1->Fill(lumiBlock, charge);
1001 hsizeCluls1->Fill(lumiBlock, size);
1002 hsizeXCluls1->Fill(lumiBlock, sizeX);
1003 #endif
1004
1005 numOfClusPerTrk1++;
1006 numOfClustersPerLay1++;
1007
1008
1009 } else if (layer == 2) {
1010 hDetMap2->Fill(float(zindex), float(ladder));
1011 hcluDetMap2->Fill(col, row);
1012 hcharge2->Fill(charge);
1013
1014
1015
1016 hclusMap2->Fill(gZ, phi);
1017 hmult2->Fill(zindex, float(size));
1018
1019 if (pt > CLU_SIZE_PT_CUT) {
1020 hsize2->Fill(float(size));
1021 hsizex2->Fill(float(sizeX));
1022 hsizey2->Fill(float(sizeY));
1023
1024 hclumult2->Fill(eta, float(size));
1025 hclumultx2->Fill(eta, float(sizeX));
1026 hclumulty2->Fill(eta, float(sizeY));
1027 hcluchar2->Fill(eta, float(charge));
1028
1029 hclumultld2->Fill(float(ladderOn), size);
1030 hclumultxld2->Fill(float(ladderOn), sizeX);
1031 hclumultyld2->Fill(float(ladderOn), sizeY);
1032 hclucharld2->Fill(float(ladderOn), charge);
1033 }
1034
1035 #ifdef VDM_STUDIES
1036 hcharCluls->Fill(lumiBlock, charge);
1037 hsizeCluls->Fill(lumiBlock, size);
1038 hsizeXCluls->Fill(lumiBlock, sizeX);
1039 hcharCluls2->Fill(lumiBlock, charge);
1040 hsizeCluls2->Fill(lumiBlock, size);
1041 hsizeXCluls2->Fill(lumiBlock, sizeX);
1042 #endif
1043
1044 numOfClusPerTrk2++;
1045 numOfClustersPerLay2++;
1046
1047
1048 } else if (layer == 3) {
1049 hDetMap3->Fill(float(zindex), float(ladder));
1050 hcluDetMap3->Fill(col, row);
1051 hcharge3->Fill(charge);
1052
1053
1054
1055 hclusMap3->Fill(gZ, phi);
1056 hmult3->Fill(zindex, float(size));
1057
1058 if (pt > CLU_SIZE_PT_CUT) {
1059 hsize3->Fill(float(size));
1060 hsizex3->Fill(float(sizeX));
1061 hsizey3->Fill(float(sizeY));
1062 hclumult3->Fill(eta, float(size));
1063 hclumultx3->Fill(eta, float(sizeX));
1064 hclumulty3->Fill(eta, float(sizeY));
1065 hcluchar3->Fill(eta, float(charge));
1066
1067 hclumultld3->Fill(float(ladderOn), size);
1068 hclumultxld3->Fill(float(ladderOn), sizeX);
1069 hclumultyld3->Fill(float(ladderOn), sizeY);
1070 hclucharld3->Fill(float(ladderOn), charge);
1071 }
1072
1073 #ifdef VDM_STUDIES
1074 hcharCluls->Fill(lumiBlock, charge);
1075 hsizeCluls->Fill(lumiBlock, size);
1076 hsizeXCluls->Fill(lumiBlock, sizeX);
1077 hcharCluls3->Fill(lumiBlock, charge);
1078 hsizeCluls3->Fill(lumiBlock, size);
1079 hsizeXCluls3->Fill(lumiBlock, sizeX);
1080 #endif
1081
1082 numOfClusPerTrk3++;
1083 numOfClustersPerLay3++;
1084
1085
1086 } else if (disk == 1) {
1087 numOfClusPerTrk4++;
1088 numOfClustersPerLay4++;
1089
1090
1091 hcharge4->Fill(charge);
1092 if (pt > CLU_SIZE_PT_CUT) {
1093 hsize4->Fill(float(size));
1094 hsizex4->Fill(float(sizeX));
1095 hsizey4->Fill(float(sizeY));
1096 }
1097
1098 if (side == 1)
1099 numOfClustersPerDisk2++;
1100 else if (side == 2)
1101 numOfClustersPerDisk3++;
1102
1103 } else if (disk == 2) {
1104 numOfClusPerTrk5++;
1105 numOfClustersPerLay5++;
1106
1107
1108 hcharge5->Fill(charge);
1109 if (pt > CLU_SIZE_PT_CUT) {
1110 hsize5->Fill(float(size));
1111 hsizex5->Fill(float(sizeX));
1112 hsizey5->Fill(float(sizeY));
1113 }
1114
1115 if (side == 1)
1116 numOfClustersPerDisk1++;
1117 else if (side == 2)
1118 numOfClustersPerDisk4++;
1119
1120 } else {
1121 edm::LogPrint("TestWithTracks") << " which layer is this? " << layer << " " << disk;
1122 }
1123
1124 }
1125
1126 }
1127
1128 if (pixelHits > 0)
1129 countPixTracks++;
1130
1131 if (PRINT)
1132 edm::LogPrint("TestWithTracks") << " Clusters for track " << trackNumber << " num of clusters "
1133 << numberOfClusters << " num of pixels " << pixelHits;
1134
1135 #ifdef HISTOS
1136
1137 if (numberOfClusters > 0) {
1138 hclusPerTrk1->Fill(float(numOfClusPerTrk1));
1139 if (PRINT)
1140 edm::LogPrint("TestWithTracks") << "Lay1: number of clusters per track = " << numOfClusPerTrk1;
1141 hclusPerTrk2->Fill(float(numOfClusPerTrk2));
1142 if (PRINT)
1143 edm::LogPrint("TestWithTracks") << "Lay2: number of clusters per track = " << numOfClusPerTrk1;
1144 hclusPerTrk3->Fill(float(numOfClusPerTrk3));
1145 if (PRINT)
1146 edm::LogPrint("TestWithTracks") << "Lay3: number of clusters per track = " << numOfClusPerTrk1;
1147 hclusPerTrk4->Fill(float(numOfClusPerTrk4));
1148 hclusPerTrk5->Fill(float(numOfClusPerTrk5));
1149
1150 float clusPerTrkB = numOfClusPerTrk1 + numOfClusPerTrk2 + numOfClusPerTrk3;
1151 float clusPerTrkF = numOfClusPerTrk4 + numOfClusPerTrk5;
1152 float clusPerTrk = clusPerTrkB + clusPerTrkF;
1153
1154 hclusPerTrkB->Fill(clusPerTrkB);
1155 hclusPerTrkF->Fill(clusPerTrkF);
1156 hclusPerTrk->Fill(clusPerTrk);
1157
1158 hclusPerTrkVsEta->Fill(eta, clusPerTrk);
1159 hclusPerTrkVsEtaB->Fill(eta, clusPerTrkB);
1160 hclusPerTrkVsEtaF->Fill(eta, clusPerTrkF);
1161 hclusPerTrkVsPt->Fill(pt, clusPerTrk);
1162 hclusPerTrkVsls->Fill(lumiBlock, clusPerTrk);
1163 }
1164 #endif
1165
1166 }
1167
1168 #ifdef HISTOS
1169
1170 if (numberOfClusters > 0) {
1171 hclusPerLay1->Fill(float(numOfClustersPerLay1));
1172 hclusPerLay2->Fill(float(numOfClustersPerLay2));
1173 hclusPerLay3->Fill(float(numOfClustersPerLay3));
1174
1175 hclusPerDisk1->Fill(float(numOfClustersPerDisk1));
1176 hclusPerDisk2->Fill(float(numOfClustersPerDisk2));
1177 hclusPerDisk3->Fill(float(numOfClustersPerDisk3));
1178 hclusPerDisk4->Fill(float(numOfClustersPerDisk4));
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188 hclusBpix->Fill(float(numberOfClusters));
1189 hpixBpix->Fill(float(numberOfPixels));
1190 }
1191 htracksGood->Fill(float(countNiceTracks));
1192 htracksGoodInPix->Fill(float(countPixTracks));
1193 htracks->Fill(float(trackNumber));
1194
1195 hbx->Fill(float(bx));
1196 hlumi->Fill(float(lumiBlock));
1197
1198 htracksls->Fill(float(lumiBlock), float(countPixTracks));
1199 hpvsls->Fill(float(lumiBlock), float(pvsTrue));
1200 if (instlumi > 0.) {
1201 float tmp = float(countPixTracks) / instlumi;
1202 htrackslsn->Fill(float(lumiBlock), tmp);
1203 tmp = float(pvsTrue) / instlumi;
1204 hpvslsn->Fill(float(lumiBlock), tmp);
1205 }
1206
1207 #ifdef VDM_STUDIES
1208
1209 hclusls->Fill(float(lumiBlock), float(numberOfClusters));
1210
1211
1212 hclubx->Fill(float(bx), float(numberOfClusters));
1213
1214 hpvbx->Fill(float(bx), float(pvsTrue));
1215 htrackbx->Fill(float(bx), float(countPixTracks));
1216
1217 hclusls1->Fill(float(lumiBlock), float(numOfClustersPerLay1));
1218
1219 hclusls2->Fill(float(lumiBlock), float(numOfClustersPerLay2));
1220
1221 hclusls3->Fill(float(lumiBlock), float(numOfClustersPerLay3));
1222
1223 #endif
1224
1225 #endif
1226
1227
1228 countTracks += float(trackNumber);
1229 countGoodTracks += float(countNiceTracks);
1230 countTracksInPix += float(countPixTracks);
1231 countPVs += float(pvsTrue);
1232 countEvents++;
1233 if (lumiBlock != lumiBlockOld) {
1234 countLumi += intlumi;
1235 lumiBlockOld = lumiBlock;
1236 }
1237
1238 if (PRINT)
1239 edm::LogPrint("TestWithTracks") << " event with tracks = " << trackNumber << " " << countNiceTracks;
1240
1241 return;
1242
1243 #ifdef USE_TRAJ
1244
1245
1246
1247
1248
1249 edm::Handle<TrajTrackAssociationCollection> trajTrackCollectionHandle;
1250 e.getByToken(trackAssocToken_, trajTrackCollectionHandle);
1251
1252 TrajectoryStateCombiner tsoscomb;
1253
1254 int NbrTracks = trajTrackCollectionHandle->size();
1255 std::edm::LogPrint("TestWithTracks") << " track measurements " << trajTrackCollectionHandle->size() << std::endl;
1256
1257 int trackNumber = 0;
1258 int numberOfClusters = 0;
1259
1260 for (TrajTrackAssociationCollection::const_iterator it = trajTrackCollectionHandle->begin(),
1261 itEnd = trajTrackCollectionHandle->end();
1262 it != itEnd;
1263 ++it) {
1264 int pixelHits = 0;
1265 int stripHits = 0;
1266 const Track &track = *it->val;
1267 const Trajectory &traj = *it->key;
1268
1269 std::vector<TrajectoryMeasurement> checkColl = traj.measurements();
1270 for (std::vector<TrajectoryMeasurement>::const_iterator checkTraj = checkColl.begin(); checkTraj != checkColl.end();
1271 ++checkTraj) {
1272 if (!checkTraj->updatedState().isValid())
1273 continue;
1274 TransientTrackingRecHit::ConstRecHitPointer testhit = checkTraj->recHit();
1275 if (!testhit->isValid() || testhit->geographicalId().det() != DetId::Tracker)
1276 continue;
1277 uint testSubDetID = (testhit->geographicalId().subdetId());
1278 if (testSubDetID == PixelSubdetector::PixelBarrel || testSubDetID == PixelSubdetector::PixelEndcap)
1279 pixelHits++;
1280 else if (testSubDetID == StripSubdetector::TIB || testSubDetID == StripSubdetector::TOB ||
1281 testSubDetID == StripSubdetector::TID || testSubDetID == StripSubdetector::TEC)
1282 stripHits++;
1283 }
1284
1285 if (pixelHits == 0)
1286 continue;
1287
1288 trackNumber++;
1289 std::edm::LogPrint("TestWithTracks") << " track " << trackNumber << " has pixelhits " << pixelHits << std::endl;
1290 pixelHits = 0;
1291
1292
1293 for (std::vector<TrajectoryMeasurement>::const_iterator itTraj = checkColl.begin(); itTraj != checkColl.end();
1294 ++itTraj) {
1295 if (!itTraj->updatedState().isValid())
1296 continue;
1297
1298 TrajectoryStateOnSurface tsos = tsoscomb(itTraj->forwardPredictedState(), itTraj->backwardPredictedState());
1299 TransientTrackingRecHit::ConstRecHitPointer hit = itTraj->recHit();
1300 if (!hit->isValid() || hit->geographicalId().det() != DetId::Tracker)
1301 continue;
1302
1303 const DetId &hit_detId = hit->geographicalId();
1304 uint IntSubDetID = (hit_detId.subdetId());
1305
1306 if (IntSubDetID == 0)
1307 continue;
1308 if (IntSubDetID != PixelSubdetector::PixelBarrel)
1309 continue;
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320 const TrackingRecHit *persistentHit = hit->hit();
1321
1322 if ((persistentHit != 0) && (typeid(*persistentHit) == typeid(SiPixelRecHit))) {
1323
1324 const SiPixelRecHit *pixhit = dynamic_cast<const SiPixelRecHit *>(hit->hit());
1325
1326 edm::Ref<edmNew::DetSetVector<SiPixelCluster>, SiPixelCluster> const &clust = (*pixhit).cluster();
1327
1328 if (clust.isNonnull()) {
1329 numberOfClusters++;
1330 pixelHits++;
1331 float charge = (clust->charge()) / 1000.0;
1332 int size = clust->size();
1333 int size_x = clust->sizeX();
1334 int size_y = clust->sizeY();
1335 float row = clust->x();
1336 float col = clust->y();
1337
1338
1339
1340
1341
1342 int maxPixelCol = clust->maxPixelCol();
1343 int maxPixelRow = clust->maxPixelRow();
1344 int minPixelCol = clust->minPixelCol();
1345 int minPixelRow = clust->minPixelRow();
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367 }
1368 }
1369
1370 }
1371
1372 if (PRINT)
1373 edm::LogPrint("TestWithTracks") << " Cluster for track " << trackNumber << " cluaters " << numberOfClusters << " "
1374 << pixelHits;
1375
1376 }
1377
1378 #endif
1379
1380 edm::LogPrint("TestWithTracks") << " event with tracks = " << trackNumber << " " << countGoodTracks;
1381
1382 }
1383
1384
1385 DEFINE_FWK_MODULE(TestWithTracks);