From dffcba12a0b82a003011ebc365da32c5094fd189 Mon Sep 17 00:00:00 2001 From: Volker Adler Date: Mon, 19 May 2014 17:49:01 +0200 Subject: [PATCH 01/11] Check for unschedule attribute only, if available. --- PhysicsTools/PatUtils/python/tools/metUncertaintyTools.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/PhysicsTools/PatUtils/python/tools/metUncertaintyTools.py b/PhysicsTools/PatUtils/python/tools/metUncertaintyTools.py index b308a947f55fd..c256c5c85b1a1 100644 --- a/PhysicsTools/PatUtils/python/tools/metUncertaintyTools.py +++ b/PhysicsTools/PatUtils/python/tools/metUncertaintyTools.py @@ -1605,7 +1605,9 @@ def toolCode(self, process): postfix) # insert metUncertaintySequence into patDefaultSequence - if addToPatDefaultSequence and process.options.allowUnscheduled == False: + if hasattr(process,'options') and hasattr(process.options,'allowUnscheduled') and process.options.allowUnscheduled == True: + addToPatDefaultSequence = False + if addToPatDefaultSequence: if not hasattr(process, "patDefaultSequence"): raise ValueError("PAT default sequence is not defined !!") process.patDefaultSequence += metUncertaintySequence From 701a29b4800cf4324df3b7193f3f257d074acb43 Mon Sep 17 00:00:00 2001 From: paolo Date: Thu, 22 May 2014 11:48:14 +0200 Subject: [PATCH 02/11] added configuration for new P6 and P8 tunes --- ...hTuneCUEP6S1_13TeV_madgraph_pythia6_cff.py | 33 ++++++++++++ ...TuneCUEP6S1_13TeV_madgraph_pythia6_cff.pyc | Bin 0 -> 1493 bytes ...chTuneCUEP6S1_8TeV_madgraph_pythia6_cff.py | 33 ++++++++++++ ...hTuneCUEP6S1_8TeV_madgraph_pythia6_cff.pyc | Bin 0 -> 1492 bytes ...EQ6L1_13TeV_madgraph_pythia8_Tauola_cff.py | 45 +++++++++++++++++ ...Q6L1_13TeV_madgraph_pythia8_Tauola_cff.pyc | Bin 0 -> 1743 bytes ...Q6L1_13TeV_madgraph_pythia8_Tauola_cff.py~ | 44 ++++++++++++++++ ...TEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.py | 45 +++++++++++++++++ ...EQ6L1_8TeV_madgraph_pythia8_Tauola_cff.pyc | Bin 0 -> 1742 bytes ...EQ6L1_8TeV_madgraph_pythia8_Tauola_cff.py~ | 44 ++++++++++++++++ ...f15LO_13TeV_madgraph_pythia8_Tauola_cff.py | 47 ++++++++++++++++++ ...15LO_13TeV_madgraph_pythia8_Tauola_cff.pyc | Bin 0 -> 1842 bytes ...15LO_13TeV_madgraph_pythia8_Tauola_cff.py~ | 46 +++++++++++++++++ ...df15LO_8TeV_madgraph_pythia8_Tauola_cff.py | 47 ++++++++++++++++++ ...f15LO_8TeV_madgraph_pythia8_Tauola_cff.pyc | Bin 0 -> 1841 bytes ...f15LO_8TeV_madgraph_pythia8_Tauola_cff.py~ | 46 +++++++++++++++++ .../python/Pythia6CUEP6S1Settings_cfi.py | 37 ++++++++++++++ .../Pythia8CUEP8S1CTEQ6L1Settings_cfi.py | 13 +++++ .../Pythia8CUEP8S1Herapdf15LOSettings_cfi.py | 15 ++++++ 19 files changed, 495 insertions(+) create mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP6S1_13TeV_madgraph_pythia6_cff.py create mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP6S1_13TeV_madgraph_pythia6_cff.pyc create mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP6S1_8TeV_madgraph_pythia6_cff.py create mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP6S1_8TeV_madgraph_pythia6_cff.pyc create mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_13TeV_madgraph_pythia8_Tauola_cff.py create mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_13TeV_madgraph_pythia8_Tauola_cff.pyc create mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_13TeV_madgraph_pythia8_Tauola_cff.py~ create mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.py create mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.pyc create mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.py~ create mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1Herapdf15LO_13TeV_madgraph_pythia8_Tauola_cff.py create mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1Herapdf15LO_13TeV_madgraph_pythia8_Tauola_cff.pyc create mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1Herapdf15LO_13TeV_madgraph_pythia8_Tauola_cff.py~ create mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1Herapdf15LO_8TeV_madgraph_pythia8_Tauola_cff.py create mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1Herapdf15LO_8TeV_madgraph_pythia8_Tauola_cff.pyc create mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1Herapdf15LO_8TeV_madgraph_pythia8_Tauola_cff.py~ create mode 100644 Configuration/Generator/python/Pythia6CUEP6S1Settings_cfi.py create mode 100644 Configuration/Generator/python/Pythia8CUEP8S1CTEQ6L1Settings_cfi.py create mode 100644 Configuration/Generator/python/Pythia8CUEP8S1Herapdf15LOSettings_cfi.py diff --git a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP6S1_13TeV_madgraph_pythia6_cff.py b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP6S1_13TeV_madgraph_pythia6_cff.py new file mode 100644 index 0000000000000..ed618705035f0 --- /dev/null +++ b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP6S1_13TeV_madgraph_pythia6_cff.py @@ -0,0 +1,33 @@ +import FWCore.ParameterSet.Config as cms + +from Configuration.Generator.Pythia6_CUEP6S1Settings_cfi import * + +generator = cms.EDFilter("Pythia6HadronizerFilter", + pythiaHepMCVerbosity = cms.untracked.bool(True), + maxEventsToPrint = cms.untracked.int32(0), + pythiaPylistVerbosity = cms.untracked.int32(1), + comEnergy = cms.double(13000.0), + PythiaParameters = cms.PSet( + pythia6CUEP6S1SettingsBlock, + processParameters = cms.vstring('MSEL=0 ! User defined processes', + 'PMAS(5,1)=4.8 ! b quark mass', + 'PMAS(6,1)=172.5 ! t quark mass', +'MSTJ(1)=1 ! Fragmentation/hadronization on or off', +'MSTP(61)=1 ! Parton showering on or off'), + # This is a vector of ParameterSet names to be read, in this order + parameterSets = cms.vstring('pythia6CUEP6S1Settings', + 'processParameters') + ), + jetMatching = cms.untracked.PSet( + scheme = cms.string("Madgraph"), + mode = cms.string("auto"), # soup, or "inclusive" / "exclusive" + MEMAIN_nqmatch = cms.int32(5), + MEMAIN_etaclmax = cms.double(-1), + MEMAIN_qcut = cms.double(-1), + MEMAIN_minjets = cms.int32(-1), + MEMAIN_maxjets = cms.int32(-1), + MEMAIN_showerkt = cms.double(0), + MEMAIN_excres = cms.string(""), + outTree_flag = cms.int32(0) + ) +) diff --git a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP6S1_13TeV_madgraph_pythia6_cff.pyc b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP6S1_13TeV_madgraph_pythia6_cff.pyc new file mode 100644 index 0000000000000000000000000000000000000000..0d3ee68e69bffd631fee3abe640563e12a0ed484 GIT binary patch literal 1493 zcmZuwZFAE`5MJ4d!Hz>9<)yq7MEQVW7^fzX_5*aFsZ-ji8PC{(8NO&Py0a`t(m8i4 znslb0{H4FFGyOgN0kF4{;-sxkKHWagv$wZ<>-s#eY%r1bs2n!G7YK1gGHW(qQ&=68+nvAqSwpg&n zCe3Y-ZCm6I2GT5;te=jhYX3-zjsTZHy;)nTS*z_dlu( z?N|>@oMB8D;I&hi;Yku(JoSk=W|Qbpr~OQs=p=F;Apd^F`xS>63L{cQ!7W}Pa&B~} ztX-n^9-)I#|JRq_`1k#NtBfzzB+iudOD)OokY+e|J?cDv(tGssS@%1V9{5MOFo%9B zthIM5!HyI3zJ1z#P7*vT>2aL#FC8Z!a?gk;rE~?xI@_9-rDDt1nXiqnClmXy@EUe@ zN;f(=5^bmYH$_#7mRejV?Yv5Nq|oAZhZJ|QyWbz~jCuqkd0AW|YNl`?Fq{&A4YF-G zRaC2sv>XT-88M&Y3K^-EiWeeBjh7tVAH4qgZIB(M?7vD7ZY*(yB24H$IZCNL3UfT` zo5mT%x91>n%+Q&giaZaIlPh;p$DvUcDI8#%CY|HhC>2Z+5p`TA;Vqi>-tTIox~Dfy znRj<}Hi;v4I*W7iC08fcFtxZ%-vY`FUrP5UMNKA9n{L_O!M|!6gp-(y*Z;BXch{YH zhDL;kN^%7cv`%<2Hn~DqH|q55r+fmb^Mj-)^w8bYZDRlb_I^loc!(E>|7g*5L2-S> z(glsGvv$aU0MDiaQR+hg@ENXs4x%0p8A slP;}Y|Gc1{$rJUx=i)u1X|vX z6Ava8_*iA60`US2R23$RAPHIkx30nD45+g(^FS_^NF8L25u$PpA-Sf`NCRYp1xsww z+yvR=^)g6$&w*S4c^>2im{GXZlDg<*vkLiE zdnQUTA`I~Iu}kkLjw~MgL>#kDbfA+?s!VtkIuF?VbCdVW5784wB#MGtyg=mC=s;OJ zN9`R#yZz3)SC9O={;pNVmueKHO8SMC%Q){o;_T@|LSS`1xfe(gG`uxKM~g2 z+ofQ`3D%!KZa*Ulo|LR}oWa|c6A-y=M3_*z0wbNSjf+yTCm0W|w;uHGjP-gg2+P^7kGJ)E(i}oJ=r>4VT6mju7zZU)Ox-(1B zh+tnyuHc^5F)s!tQ|RhOo&Mx8pFrwtFU||ybN6(E*#E!1Ut%5X;~C;VS#({HUthj- zLBsN_Eizy}*+0m%CRjU_+S+kyYc3wORyw$mG8#CZcuhx literal 0 HcmV?d00001 diff --git a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_13TeV_madgraph_pythia8_Tauola_cff.py b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_13TeV_madgraph_pythia8_Tauola_cff.py new file mode 100644 index 0000000000000..af1a204f96677 --- /dev/null +++ b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_13TeV_madgraph_pythia8_Tauola_cff.py @@ -0,0 +1,45 @@ +import FWCore.ParameterSet.Config as cms +from GeneratorInterface.ExternalDecays.TauolaSettings_cff import * + +generator = cms.EDFilter("Pythia8HadronizerFilter", + ExternalDecays = cms.PSet( + Tauola = cms.untracked.PSet( + TauolaPolar, + TauolaDefaultInputCards + ), + parameterSets = cms.vstring('Tauola') + ), + UseExternalGenerators = cms.untracked.bool(True), + maxEventsToPrint = cms.untracked.int32(1), + pythiaPylistVerbosity = cms.untracked.int32(1), + filterEfficiency = cms.untracked.double(1.0), + pythiaHepMCVerbosity = cms.untracked.bool(False), + comEnergy = cms.double(13000.), + jetMatching = cms.untracked.PSet( + scheme = cms.string("Madgraph"), + mode = cms.string("auto"),# soup, or "inclusive" / "exclusive" + MEMAIN_etaclmax = cms.double(-1), + MEMAIN_qcut = cms.double(-1), + MEMAIN_minjets = cms.int32(-1), + MEMAIN_maxjets = cms.int32(-1), + MEMAIN_showerkt = cms.double(0), # use 1=yes only for pt-ordered showers ! + MEMAIN_nqmatch = cms.int32(5), #PID of the flavor until which the QCD radiation are kept in the matching procedure; + # if nqmatch=4, then all showered partons from b's are NOT taken into account + # Note (JY): I think the default should be 5 (b); anyway, don't try -1 as it'll result in a throw... + MEMAIN_excres = cms.string(""), + outTree_flag = cms.int32(0) # 1=yes, write out the tree for future sanity check + ), + PythiaParameters = cms.PSet( + processParameters = cms.vstring( + 'Main:timesAllowErrors = 10000', + 'ParticleDecays:tauMax = 10', + 'Tune:ee 3', + 'Tune:pp 5', + 'MultipleInteractions:pT0Ref=2.1006', + 'MultipleInteractions:ecmPow=0.21057', + 'MultipleInteractions:expPow=1.6089', + 'BeamRemnants:reconnectRange=3.31257', + ), + parameterSets = cms.vstring('processParameters') + ) +) diff --git a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_13TeV_madgraph_pythia8_Tauola_cff.pyc b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_13TeV_madgraph_pythia8_Tauola_cff.pyc new file mode 100644 index 0000000000000000000000000000000000000000..da06b3666d28d0f838d85c875b30aefceae718c7 GIT binary patch literal 1743 zcmZ`(ZEqVz5Z<%%W;clw(^4oD+!mi{zNU#QKnD7t2f%w8V_O!sN0QR*ej63<_+TW0GXD7L9f4uqn&Q z)r@w7!MXt@k%>c&8%&ZHA;otPBBz{9CR4AC3?Wm=dTm;S2&uZ25omAQR^DQ=Y?&Wq z>P@TO${d+hKfJEqwkqu{wSIJ6{Wv4vvA&;V)=#Z^*Q&JcXIA|@vs&_$6=lUDw8MK= zphVqg@&S`yF!?2uUorWR$tsgyv+3GGGVhsal+3A9c(rXV>8$#QZq56Tp66A%I)-L? zgtuw#O>pG#gJ)c-DD-{N zCp-wnWJqj!{`moK(ku0Q264ANcPo%VL_vqv9?tmkuP1ne;0wSmM=|okp*@HeBcR={ zk*Uk&Q1N(#OQZym1S{|aBPU&9FBjL7SudWpU4LNsm@D^`&J zt>>t|YeI4_Y@ru`e(L+tWk)Hxqsn2WQKv`WAqF|1Cwxe6y@fpK^08%Tliz+4LJOeM zoNIAh+0*w;@We+i_TeO?vfu)}DAcXEUq1!+aJNQF?CS^bqk#x|(dA*iw%e%hJ$`>U z7{`X!sO{GezO~_g1Rk715OS)omI4ulAqYI>;Sdg+wPs^??{T$E%c42m@vrSjLG3Cl zRJ^rz6uRCJO==f$TPHJHo@^q}_zk_UYTF*um1FR z%M@DAm`y^H5Ghx$LE6enU3=7I%JyffAA!p$wnLwqBd*p+B3)~IrmfWnEM*i21tF)4u)B?R!L#=Ne85AC3eyzB-GG!qdQmU-!V-{ z!2IJe=nezhW~NHoFFL)0vqrn$`DOp-#-P#c!^=T1Yqmk!zz2i$fF?&Zf=oYtM?IMM t@V)s)=wq77PBFLc6lmm~Lav-EJJ~2X>rUzV$d{aQuHdW?cX1SQ{{t^gxDEgS literal 0 HcmV?d00001 diff --git a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_13TeV_madgraph_pythia8_Tauola_cff.py~ b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_13TeV_madgraph_pythia8_Tauola_cff.py~ new file mode 100644 index 0000000000000..495f9b9f627d4 --- /dev/null +++ b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_13TeV_madgraph_pythia8_Tauola_cff.py~ @@ -0,0 +1,44 @@ +import FWCore.ParameterSet.Config as cms +from GeneratorInterface.ExternalDecays.TauolaSettings_cff import * + +generator = cms.EDFilter("Pythia8HadronizerFilter", + ExternalDecays = cms.PSet( + Tauola = cms.untracked.PSet( + TauolaPolar, + TauolaDefaultInputCards + ), + parameterSets = cms.vstring('Tauola') + ), + UseExternalGenerators = cms.untracked.bool(True), + maxEventsToPrint = cms.untracked.int32(1), + pythiaPylistVerbosity = cms.untracked.int32(1), + filterEfficiency = cms.untracked.double(1.0), + pythiaHepMCVerbosity = cms.untracked.bool(False), + comEnergy = cms.double(13000.), + jetMatching = cms.untracked.PSet( + scheme = cms.string("Madgraph"), + mode = cms.string("auto"),# soup, or "inclusive" / "exclusive" + MEMAIN_etaclmax = cms.double(-1), + MEMAIN_qcut = cms.double(-1), + MEMAIN_minjets = cms.int32(-1), + MEMAIN_maxjets = cms.int32(-1), + MEMAIN_showerkt = cms.double(0), # use 1=yes only for pt-ordered showers ! + MEMAIN_nqmatch = cms.int32(5), #PID of the flavor until which the QCD radiation are kept in the matching procedure; + # if nqmatch=4, then all showered partons from b's are NOT taken into account + # Note (JY): I think the default should be 5 (b); anyway, don't try -1 as it'll result in a throw... + MEMAIN_excres = cms.string(""), + outTree_flag = cms.int32(0) # 1=yes, write out the tree for future sanity check + ), + PythiaParameters = cms.PSet( + processParameters = cms.vstring( + 'Main:timesAllowErrors = 10000', + 'ParticleDecays:tauMax = 10', + 'Tune:ee 3', + 'Tune:pp 5', + 'MultipleInteractions:pT0Ref=2.1006', + 'MultipleInteractions:ecmPow=0.21057', + 'MultipleInteractions:expPow=1.6089', + 'BeamRemnants:reconnectRange=3.31257', + ), + parameterSets = cms.vstring('processParameters') + ) diff --git a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.py b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.py new file mode 100644 index 0000000000000..50c058b77d2ed --- /dev/null +++ b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.py @@ -0,0 +1,45 @@ +import FWCore.ParameterSet.Config as cms +from GeneratorInterface.ExternalDecays.TauolaSettings_cff import * + +generator = cms.EDFilter("Pythia8HadronizerFilter", + ExternalDecays = cms.PSet( + Tauola = cms.untracked.PSet( + TauolaPolar, + TauolaDefaultInputCards + ), + parameterSets = cms.vstring('Tauola') + ), + UseExternalGenerators = cms.untracked.bool(True), + maxEventsToPrint = cms.untracked.int32(1), + pythiaPylistVerbosity = cms.untracked.int32(1), + filterEfficiency = cms.untracked.double(1.0), + pythiaHepMCVerbosity = cms.untracked.bool(False), + comEnergy = cms.double(8000.), + jetMatching = cms.untracked.PSet( + scheme = cms.string("Madgraph"), + mode = cms.string("auto"),# soup, or "inclusive" / "exclusive" + MEMAIN_etaclmax = cms.double(-1), + MEMAIN_qcut = cms.double(-1), + MEMAIN_minjets = cms.int32(-1), + MEMAIN_maxjets = cms.int32(-1), + MEMAIN_showerkt = cms.double(0), # use 1=yes only for pt-ordered showers ! + MEMAIN_nqmatch = cms.int32(5), #PID of the flavor until which the QCD radiation are kept in the matching procedure; + # if nqmatch=4, then all showered partons from b's are NOT taken into account + # Note (JY): I think the default should be 5 (b); anyway, don't try -1 as it'll result in a throw... + MEMAIN_excres = cms.string(""), + outTree_flag = cms.int32(0) # 1=yes, write out the tree for future sanity check + ), + PythiaParameters = cms.PSet( + processParameters = cms.vstring( + 'Main:timesAllowErrors = 10000', + 'ParticleDecays:tauMax = 10', + 'Tune:ee 3', + 'Tune:pp 5', + 'MultipleInteractions:pT0Ref=2.1006', + 'MultipleInteractions:ecmPow=0.21057', + 'MultipleInteractions:expPow=1.6089', + 'BeamRemnants:reconnectRange=3.31257', + ), + parameterSets = cms.vstring('processParameters') + ) +) diff --git a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.pyc b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e1a8139913a11ad833c77aab57ebe2efa0b7d10b GIT binary patch literal 1742 zcmZ`(UvnEZ5ZBrHXE%ux(^4oD+<(;c!HE-+8V`XK$Dx_Q9h10arY|1lv}a#>r@Kmf zjm->C{yKaI-gx4}FvACcmChGC)9K09?f&++D`~ZR`G41nfB*ISnaifnV|pLbU;p7S zCg|s|fUygQUF6v7yhU;>SYSQKvx`M02wGr9USeX=3d=@@6$S-1$uU7PS&POxaoB|A z#BxTv!C=*Zg2==n$2BI%i;&`b2$56HIuohaT85CRWWClcLWES^$OyEzO)GCOQMSyF zGWDiaZ)J|msvlohZ(Ei2mRdi#u6~-4?^xf@GVAA7y=zrk_Y13jnOQA)!iu6|5!&HB zD^Q~DGx30lhfF+T;wvT|Gf`#YYc^S#OXfWjjgmQW3a>ZKC7o5D(5?CZ(et88SI5vy zPw+O)-7yY*-gwT1ilqM=sAE4sP`FOE_J}0OgClVHSmP2wJ)T4X$2AgTu6PKYM`KbL4Bu?!x%QcKz-+@HM^ybslLS$JWQQ8)h9N2?scL=om z6*6_W7$_bOae*#9`A6aNF zk{(8vpx&TQ!Pz`lz76db7Y%MwoGm?a6=<~dRhpv&dkUcM1$F|+dXp`SwBB2RT z*_~-|T-nq2P4FZ@KMvqTQdw{p{YdI&+}l0{?_j4!OYG|hAEJR9cB9LK?b=R#d++Io z!@(#vyn1bayYa0J_apG|6hg_VzM2Z$NJ?<=l*<7e?ACVcJ9|&7Wm*=^>5hMGMG9(H zS)t;swIb>H12n0f$8DWVZF#b}p~i3MeO24`m>zebmX&>)vs&6E6dI}Abl>$nTWIa0 zX>*xE>l(93Xd;nv^#+8ktkktjO{Q#rruq?hoN{|2;{;n=360C-`A#D>)4-PNc@za! z=&1zIR1me+1Yl zrU?m{eLVV|L1^2|R7vY)yW2Rcw|ebg_J6MT8$Ec{52wA>Py4sgPtRvkR3pf=<9F18 uNdVuQPlP_Esq7SUt4@JN-YMkDxw4aulC$cRu8(}lDd!5#5^?88A@@Iu&$p}q literal 0 HcmV?d00001 diff --git a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.py~ b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.py~ new file mode 100644 index 0000000000000..672849494afad --- /dev/null +++ b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.py~ @@ -0,0 +1,44 @@ +import FWCore.ParameterSet.Config as cms +from GeneratorInterface.ExternalDecays.TauolaSettings_cff import * + +generator = cms.EDFilter("Pythia8HadronizerFilter", + ExternalDecays = cms.PSet( + Tauola = cms.untracked.PSet( + TauolaPolar, + TauolaDefaultInputCards + ), + parameterSets = cms.vstring('Tauola') + ), + UseExternalGenerators = cms.untracked.bool(True), + maxEventsToPrint = cms.untracked.int32(1), + pythiaPylistVerbosity = cms.untracked.int32(1), + filterEfficiency = cms.untracked.double(1.0), + pythiaHepMCVerbosity = cms.untracked.bool(False), + comEnergy = cms.double(8000.), + jetMatching = cms.untracked.PSet( + scheme = cms.string("Madgraph"), + mode = cms.string("auto"),# soup, or "inclusive" / "exclusive" + MEMAIN_etaclmax = cms.double(-1), + MEMAIN_qcut = cms.double(-1), + MEMAIN_minjets = cms.int32(-1), + MEMAIN_maxjets = cms.int32(-1), + MEMAIN_showerkt = cms.double(0), # use 1=yes only for pt-ordered showers ! + MEMAIN_nqmatch = cms.int32(5), #PID of the flavor until which the QCD radiation are kept in the matching procedure; + # if nqmatch=4, then all showered partons from b's are NOT taken into account + # Note (JY): I think the default should be 5 (b); anyway, don't try -1 as it'll result in a throw... + MEMAIN_excres = cms.string(""), + outTree_flag = cms.int32(0) # 1=yes, write out the tree for future sanity check + ), + PythiaParameters = cms.PSet( + processParameters = cms.vstring( + 'Main:timesAllowErrors = 10000', + 'ParticleDecays:tauMax = 10', + 'Tune:ee 3', + 'Tune:pp 5', + 'MultipleInteractions:pT0Ref=2.1006', + 'MultipleInteractions:ecmPow=0.21057', + 'MultipleInteractions:expPow=1.6089', + 'BeamRemnants:reconnectRange=3.31257', + ), + parameterSets = cms.vstring('processParameters') + ) diff --git a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1Herapdf15LO_13TeV_madgraph_pythia8_Tauola_cff.py b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1Herapdf15LO_13TeV_madgraph_pythia8_Tauola_cff.py new file mode 100644 index 0000000000000..23021f66505a9 --- /dev/null +++ b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1Herapdf15LO_13TeV_madgraph_pythia8_Tauola_cff.py @@ -0,0 +1,47 @@ +import FWCore.ParameterSet.Config as cms +from GeneratorInterface.ExternalDecays.TauolaSettings_cff import * + +generator = cms.EDFilter("Pythia8HadronizerFilter", + ExternalDecays = cms.PSet( + Tauola = cms.untracked.PSet( + TauolaPolar, + TauolaDefaultInputCards + ), + parameterSets = cms.vstring('Tauola') + ), + UseExternalGenerators = cms.untracked.bool(True), + maxEventsToPrint = cms.untracked.int32(1), + pythiaPylistVerbosity = cms.untracked.int32(1), + filterEfficiency = cms.untracked.double(1.0), + pythiaHepMCVerbosity = cms.untracked.bool(False), + comEnergy = cms.double(13000.), + jetMatching = cms.untracked.PSet( + scheme = cms.string("Madgraph"), + mode = cms.string("auto"),# soup, or "inclusive" / "exclusive" + MEMAIN_etaclmax = cms.double(-1), + MEMAIN_qcut = cms.double(-1), + MEMAIN_minjets = cms.int32(-1), + MEMAIN_maxjets = cms.int32(-1), + MEMAIN_showerkt = cms.double(0), # use 1=yes only for pt-ordered showers ! + MEMAIN_nqmatch = cms.int32(5), #PID of the flavor until which the QCD radiation are kept in the matching procedure; + # if nqmatch=4, then all showered partons from b's are NOT taken into account + # Note (JY): I think the default should be 5 (b); anyway, don't try -1 as it'll result in a throw... + MEMAIN_excres = cms.string(""), + outTree_flag = cms.int32(0) # 1=yes, write out the tree for future sanity check + ), + PythiaParameters = cms.PSet( + processParameters = cms.vstring( + 'Main:timesAllowErrors = 10000', + 'ParticleDecays:tauMax = 10', + 'Tune:ee 3', + 'Tune:pp 5', + 'PDF:useLHAPDF=on', + 'PDF:LHAPDFset=HERAPDF1.5LO_EIG.LHgrid', + 'MultipleInteractions:pT0Ref=2.000072e+00', + 'MultipleInteractions:ecmPow=2.498802e-01', + 'MultipleInteractions:expPow=1.690506e+00', + 'BeamRemnants:reconnectRange=6.096364e+00', + ), + parameterSets = cms.vstring('processParameters') + ) +) diff --git a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1Herapdf15LO_13TeV_madgraph_pythia8_Tauola_cff.pyc b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1Herapdf15LO_13TeV_madgraph_pythia8_Tauola_cff.pyc new file mode 100644 index 0000000000000000000000000000000000000000..148887fc9157ee683c705754e333161a09e4cd0e GIT binary patch literal 1842 zcmaJ>>2e!I5T2EMN%1KX0)Y?(2oVX$k}qTxh8S6nOj$u?E1@cXRO6lA^*VcbrZ<+U z;+NithoFk5;1#Ii0ib7AYuQk+Yp=S${(7dTkIDbJQ2hPZpO0-eejd~BGx}G*Sd0n! zvzX7=nZ?d>>~-ECIp$BXKIGZiG!q0(F)hz9F>QodEyEmx0vqL+AepR1Z5>%`#ByRb zqupXKuR%d%;*jG46XZom@m~m$Q_dn2snw+#d}stp z)W=MG!o;UcJYwQACLS|UVd8Tpo-py0jfilS(uaCYO6kZdyk60zI<9;{we$X>=S77I z$WVWt;9dImF7edkjSd$w3ca5|?t4Ch#6_~Tha`pE-vgUpDx4vx&y&dKxIkjeB@ciY z$AAj&5b{z%=JFgukQ^haaG5LtAGY5@h^im;q!*%RqR>9E*}r$`dkSBHJc*Qtm&V62 zfwUdRvpopyOPAR6{P8W`rk~WW197)CaVwC)j)FGr?T-24w`X{Z;4{E3NBh(ZU2_m+ zp8`ccN2V?puH^A4PLUEs0*t^DjBrVt+uhxR7Xv_U`*aSo+88^x6Ev9`>wy>2KI#U< zhX%T~k~)npK)ykb7H8MF;dx*}oYuHbakll)mY~qk=jj_I*p~nU$LFp|Ra(SeRuF|N z#ENBPgHjVz-PcQUFKnV0fZFx_=%Otp)u_BvuGi>M_lQ9b=-ED`Rc|6sx_oFDO6Rwq zgwO;iuTQi%E^jJb=HA|ZGf{BZ*(GTw3e}@Am?8>rr_(;t#(H)0@P|SB;Cc11<4RAc z3NgEhk6!G|0IJQ^r8zQZ)`UjwKe#%R{tOJ zFxKRHb!)q}S=+i=`8(jj5dUv$rP4kUyd9vAo!VUVp8W?kUhucuiW+^R1H61-#8mWiXz;+zd zz3sj6#Om(tX|t|U5+Y^r4G7b&scVlWSDK+u^*wMnW&9wF6KruQ6wZ?8TZJ^Cu9<<8 zDDsWamkFS5OPbyFHFE|LB`1Cg?sK0?tFMQ#ua3aYZU9{@Hubi^S>wS1N2*y)9NN+j1L45S^8LlVe-9NC*T%93aFbAWOaoS%tvHmLpSEP}xeT%8P2e)4N`0Z<*fZ2UZ?-(C7wzgUb3 z`m>nN*oDO|a_m*!AUWnwu^!~v#WWKHO))LcFfna}SuMjHg901nm>`*~^V&MH*ofuC zY(~4qU_pa|$iyMXMJC9LkokWhL{2$NOr&0m8A7I_@mewn5mI$IBT#HBMqXy3WSH+{ z>TRRm$sCzc-@U2cH7doHTHm{=zMqlr8Q%{w>xV|YZ&cd%BcndZtcE;d^J3K?6yZZ7 zP@+C&;u9u5W#SPNpE2>6i8UrZXW|JHPuYkFS1Em{*QAt=tir1mU8>WyFQ|6jU-Ud* zqXIJ2pC@>izTF|7d%WJ}LPnwY6Ual)N07Kgw$^~8koyN<^P$2Sf_glOe2$AG#$56M zh;a(2@D3p_6l5;XAOy)Vk_wl}67WImErh6gQCE5)dL|0(6Px|JL*G;Q669H=JRBMy z#{|-H9MAS3w1+OS>G|VZyiGr;UmN1i{=}_720IE`w6{Cv@BX@rw+Oxf>~OTtz0frW zQT91d^mAnDaN$ZGpW_rMK_tKkJi!Qy+T7~w9X;;@a@(hKnAOJE8#_Uhsj(h-A?>4X zKzv}JYb&Yq=n~{>^k{K*og2OhOo-DO*D21n9@r8T8u|i#qXc^rpzrwHHK|IA*v$%} zaD`a0jBHS9f~xy^N$!OW^a43gM z?Ij^J09H3AS{$!#D_!R9!C@m&aNOP_sTqap(HKk-1=wu2PPDOF-ah`J-#U6$K5o0x z6Kai^oy12k_Tea`uHrU&v_d29RZhTZZj^O^Uv0os3iCh7UNoG`Z3YeX1XT!ztrOVVvMTmqOtzdA?Oh6Y827 zIEy0R2tAnq>b9iW-P|x|5K(gGr{E#?skHif82jo7-0TL>#bT3>iZxH#>uC}ax+SR2 z>sRMr*ON`a Date: Fri, 23 May 2014 23:00:59 +0200 Subject: [PATCH 03/11] cleanup fragments --- ...hTuneCUEP6S1_13TeV_madgraph_pythia6_cff.py | 33 ------------ ...TuneCUEP6S1_13TeV_madgraph_pythia6_cff.pyc | Bin 1493 -> 0 bytes ...chTuneCUEP6S1_8TeV_madgraph_pythia6_cff.py | 33 ------------ ...hTuneCUEP6S1_8TeV_madgraph_pythia6_cff.pyc | Bin 1492 -> 0 bytes ...Q6L1_13TeV_madgraph_pythia8_Tauola_cff.pyc | Bin 1743 -> 0 bytes ...Q6L1_13TeV_madgraph_pythia8_Tauola_cff.py~ | 44 ---------------- ...TEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.py | 45 ----------------- ...EQ6L1_8TeV_madgraph_pythia8_Tauola_cff.pyc | Bin 1742 -> 0 bytes ...EQ6L1_8TeV_madgraph_pythia8_Tauola_cff.py~ | 44 ---------------- ...15LO_13TeV_madgraph_pythia8_Tauola_cff.pyc | Bin 1842 -> 0 bytes ...15LO_13TeV_madgraph_pythia8_Tauola_cff.py~ | 46 ----------------- ...df15LO_8TeV_madgraph_pythia8_Tauola_cff.py | 47 ------------------ ...f15LO_8TeV_madgraph_pythia8_Tauola_cff.pyc | Bin 1841 -> 0 bytes ...f15LO_8TeV_madgraph_pythia8_Tauola_cff.py~ | 46 ----------------- ...L1_13TeV_generic_LHE_pythia8_Tauola_cff.py | 32 ++++++++++++ ...LO_13TeV_generic_LHE_pythia8_Tauola_cff.py | 34 +++++++++++++ 16 files changed, 66 insertions(+), 338 deletions(-) delete mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP6S1_13TeV_madgraph_pythia6_cff.py delete mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP6S1_13TeV_madgraph_pythia6_cff.pyc delete mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP6S1_8TeV_madgraph_pythia6_cff.py delete mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP6S1_8TeV_madgraph_pythia6_cff.pyc delete mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_13TeV_madgraph_pythia8_Tauola_cff.pyc delete mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_13TeV_madgraph_pythia8_Tauola_cff.py~ delete mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.py delete mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.pyc delete mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.py~ delete mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1Herapdf15LO_13TeV_madgraph_pythia8_Tauola_cff.pyc delete mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1Herapdf15LO_13TeV_madgraph_pythia8_Tauola_cff.py~ delete mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1Herapdf15LO_8TeV_madgraph_pythia8_Tauola_cff.py delete mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1Herapdf15LO_8TeV_madgraph_pythia8_Tauola_cff.pyc delete mode 100644 Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1Herapdf15LO_8TeV_madgraph_pythia8_Tauola_cff.py~ create mode 100644 Configuration/Generator/python/Hadronizer_TuneCUEP8S1CTEQ6L1_13TeV_generic_LHE_pythia8_Tauola_cff.py create mode 100644 Configuration/Generator/python/Hadronizer_TuneCUEP8S1Herapdf15LO_13TeV_generic_LHE_pythia8_Tauola_cff.py diff --git a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP6S1_13TeV_madgraph_pythia6_cff.py b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP6S1_13TeV_madgraph_pythia6_cff.py deleted file mode 100644 index ed618705035f0..0000000000000 --- a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP6S1_13TeV_madgraph_pythia6_cff.py +++ /dev/null @@ -1,33 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -from Configuration.Generator.Pythia6_CUEP6S1Settings_cfi import * - -generator = cms.EDFilter("Pythia6HadronizerFilter", - pythiaHepMCVerbosity = cms.untracked.bool(True), - maxEventsToPrint = cms.untracked.int32(0), - pythiaPylistVerbosity = cms.untracked.int32(1), - comEnergy = cms.double(13000.0), - PythiaParameters = cms.PSet( - pythia6CUEP6S1SettingsBlock, - processParameters = cms.vstring('MSEL=0 ! User defined processes', - 'PMAS(5,1)=4.8 ! b quark mass', - 'PMAS(6,1)=172.5 ! t quark mass', -'MSTJ(1)=1 ! Fragmentation/hadronization on or off', -'MSTP(61)=1 ! Parton showering on or off'), - # This is a vector of ParameterSet names to be read, in this order - parameterSets = cms.vstring('pythia6CUEP6S1Settings', - 'processParameters') - ), - jetMatching = cms.untracked.PSet( - scheme = cms.string("Madgraph"), - mode = cms.string("auto"), # soup, or "inclusive" / "exclusive" - MEMAIN_nqmatch = cms.int32(5), - MEMAIN_etaclmax = cms.double(-1), - MEMAIN_qcut = cms.double(-1), - MEMAIN_minjets = cms.int32(-1), - MEMAIN_maxjets = cms.int32(-1), - MEMAIN_showerkt = cms.double(0), - MEMAIN_excres = cms.string(""), - outTree_flag = cms.int32(0) - ) -) diff --git a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP6S1_13TeV_madgraph_pythia6_cff.pyc b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP6S1_13TeV_madgraph_pythia6_cff.pyc deleted file mode 100644 index 0d3ee68e69bffd631fee3abe640563e12a0ed484..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1493 zcmZuwZFAE`5MJ4d!Hz>9<)yq7MEQVW7^fzX_5*aFsZ-ji8PC{(8NO&Py0a`t(m8i4 znslb0{H4FFGyOgN0kF4{;-sxkKHWagv$wZ<>-s#eY%r1bs2n!G7YK1gGHW(qQ&=68+nvAqSwpg&n zCe3Y-ZCm6I2GT5;te=jhYX3-zjsTZHy;)nTS*z_dlu( z?N|>@oMB8D;I&hi;Yku(JoSk=W|Qbpr~OQs=p=F;Apd^F`xS>63L{cQ!7W}Pa&B~} ztX-n^9-)I#|JRq_`1k#NtBfzzB+iudOD)OokY+e|J?cDv(tGssS@%1V9{5MOFo%9B zthIM5!HyI3zJ1z#P7*vT>2aL#FC8Z!a?gk;rE~?xI@_9-rDDt1nXiqnClmXy@EUe@ zN;f(=5^bmYH$_#7mRejV?Yv5Nq|oAZhZJ|QyWbz~jCuqkd0AW|YNl`?Fq{&A4YF-G zRaC2sv>XT-88M&Y3K^-EiWeeBjh7tVAH4qgZIB(M?7vD7ZY*(yB24H$IZCNL3UfT` zo5mT%x91>n%+Q&giaZaIlPh;p$DvUcDI8#%CY|HhC>2Z+5p`TA;Vqi>-tTIox~Dfy znRj<}Hi;v4I*W7iC08fcFtxZ%-vY`FUrP5UMNKA9n{L_O!M|!6gp-(y*Z;BXch{YH zhDL;kN^%7cv`%<2Hn~DqH|q55r+fmb^Mj-)^w8bYZDRlb_I^loc!(E>|7g*5L2-S> z(glsGvv$aU0MDiaQR+hg@ENXs4x%0p8A slP;}Y|Gc1{$rJUx=i)u1X|vX z6Ava8_*iA60`US2R23$RAPHIkx30nD45+g(^FS_^NF8L25u$PpA-Sf`NCRYp1xsww z+yvR=^)g6$&w*S4c^>2im{GXZlDg<*vkLiE zdnQUTA`I~Iu}kkLjw~MgL>#kDbfA+?s!VtkIuF?VbCdVW5784wB#MGtyg=mC=s;OJ zN9`R#yZz3)SC9O={;pNVmueKHO8SMC%Q){o;_T@|LSS`1xfe(gG`uxKM~g2 z+ofQ`3D%!KZa*Ulo|LR}oWa|c6A-y=M3_*z0wbNSjf+yTCm0W|w;uHGjP-gg2+P^7kGJ)E(i}oJ=r>4VT6mju7zZU)Ox-(1B zh+tnyuHc^5F)s!tQ|RhOo&Mx8pFrwtFU||ybN6(E*#E!1Ut%5X;~C;VS#({HUthj- zLBsN_Eizy}*+0m%CRjU_+S+kyYc3wORyw$mG8#CZcuhx diff --git a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_13TeV_madgraph_pythia8_Tauola_cff.pyc b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_13TeV_madgraph_pythia8_Tauola_cff.pyc deleted file mode 100644 index da06b3666d28d0f838d85c875b30aefceae718c7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1743 zcmZ`(ZEqVz5Z<%%W;clw(^4oD+!mi{zNU#QKnD7t2f%w8V_O!sN0QR*ej63<_+TW0GXD7L9f4uqn&Q z)r@w7!MXt@k%>c&8%&ZHA;otPBBz{9CR4AC3?Wm=dTm;S2&uZ25omAQR^DQ=Y?&Wq z>P@TO${d+hKfJEqwkqu{wSIJ6{Wv4vvA&;V)=#Z^*Q&JcXIA|@vs&_$6=lUDw8MK= zphVqg@&S`yF!?2uUorWR$tsgyv+3GGGVhsal+3A9c(rXV>8$#QZq56Tp66A%I)-L? zgtuw#O>pG#gJ)c-DD-{N zCp-wnWJqj!{`moK(ku0Q264ANcPo%VL_vqv9?tmkuP1ne;0wSmM=|okp*@HeBcR={ zk*Uk&Q1N(#OQZym1S{|aBPU&9FBjL7SudWpU4LNsm@D^`&J zt>>t|YeI4_Y@ru`e(L+tWk)Hxqsn2WQKv`WAqF|1Cwxe6y@fpK^08%Tliz+4LJOeM zoNIAh+0*w;@We+i_TeO?vfu)}DAcXEUq1!+aJNQF?CS^bqk#x|(dA*iw%e%hJ$`>U z7{`X!sO{GezO~_g1Rk715OS)omI4ulAqYI>;Sdg+wPs^??{T$E%c42m@vrSjLG3Cl zRJ^rz6uRCJO==f$TPHJHo@^q}_zk_UYTF*um1FR z%M@DAm`y^H5Ghx$LE6enU3=7I%JyffAA!p$wnLwqBd*p+B3)~IrmfWnEM*i21tF)4u)B?R!L#=Ne85AC3eyzB-GG!qdQmU-!V-{ z!2IJe=nezhW~NHoFFL)0vqrn$`DOp-#-P#c!^=T1Yqmk!zz2i$fF?&Zf=oYtM?IMM t@V)s)=wq77PBFLc6lmm~Lav-EJJ~2X>rUzV$d{aQuHdW?cX1SQ{{t^gxDEgS diff --git a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_13TeV_madgraph_pythia8_Tauola_cff.py~ b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_13TeV_madgraph_pythia8_Tauola_cff.py~ deleted file mode 100644 index 495f9b9f627d4..0000000000000 --- a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_13TeV_madgraph_pythia8_Tauola_cff.py~ +++ /dev/null @@ -1,44 +0,0 @@ -import FWCore.ParameterSet.Config as cms -from GeneratorInterface.ExternalDecays.TauolaSettings_cff import * - -generator = cms.EDFilter("Pythia8HadronizerFilter", - ExternalDecays = cms.PSet( - Tauola = cms.untracked.PSet( - TauolaPolar, - TauolaDefaultInputCards - ), - parameterSets = cms.vstring('Tauola') - ), - UseExternalGenerators = cms.untracked.bool(True), - maxEventsToPrint = cms.untracked.int32(1), - pythiaPylistVerbosity = cms.untracked.int32(1), - filterEfficiency = cms.untracked.double(1.0), - pythiaHepMCVerbosity = cms.untracked.bool(False), - comEnergy = cms.double(13000.), - jetMatching = cms.untracked.PSet( - scheme = cms.string("Madgraph"), - mode = cms.string("auto"),# soup, or "inclusive" / "exclusive" - MEMAIN_etaclmax = cms.double(-1), - MEMAIN_qcut = cms.double(-1), - MEMAIN_minjets = cms.int32(-1), - MEMAIN_maxjets = cms.int32(-1), - MEMAIN_showerkt = cms.double(0), # use 1=yes only for pt-ordered showers ! - MEMAIN_nqmatch = cms.int32(5), #PID of the flavor until which the QCD radiation are kept in the matching procedure; - # if nqmatch=4, then all showered partons from b's are NOT taken into account - # Note (JY): I think the default should be 5 (b); anyway, don't try -1 as it'll result in a throw... - MEMAIN_excres = cms.string(""), - outTree_flag = cms.int32(0) # 1=yes, write out the tree for future sanity check - ), - PythiaParameters = cms.PSet( - processParameters = cms.vstring( - 'Main:timesAllowErrors = 10000', - 'ParticleDecays:tauMax = 10', - 'Tune:ee 3', - 'Tune:pp 5', - 'MultipleInteractions:pT0Ref=2.1006', - 'MultipleInteractions:ecmPow=0.21057', - 'MultipleInteractions:expPow=1.6089', - 'BeamRemnants:reconnectRange=3.31257', - ), - parameterSets = cms.vstring('processParameters') - ) diff --git a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.py b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.py deleted file mode 100644 index 50c058b77d2ed..0000000000000 --- a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.py +++ /dev/null @@ -1,45 +0,0 @@ -import FWCore.ParameterSet.Config as cms -from GeneratorInterface.ExternalDecays.TauolaSettings_cff import * - -generator = cms.EDFilter("Pythia8HadronizerFilter", - ExternalDecays = cms.PSet( - Tauola = cms.untracked.PSet( - TauolaPolar, - TauolaDefaultInputCards - ), - parameterSets = cms.vstring('Tauola') - ), - UseExternalGenerators = cms.untracked.bool(True), - maxEventsToPrint = cms.untracked.int32(1), - pythiaPylistVerbosity = cms.untracked.int32(1), - filterEfficiency = cms.untracked.double(1.0), - pythiaHepMCVerbosity = cms.untracked.bool(False), - comEnergy = cms.double(8000.), - jetMatching = cms.untracked.PSet( - scheme = cms.string("Madgraph"), - mode = cms.string("auto"),# soup, or "inclusive" / "exclusive" - MEMAIN_etaclmax = cms.double(-1), - MEMAIN_qcut = cms.double(-1), - MEMAIN_minjets = cms.int32(-1), - MEMAIN_maxjets = cms.int32(-1), - MEMAIN_showerkt = cms.double(0), # use 1=yes only for pt-ordered showers ! - MEMAIN_nqmatch = cms.int32(5), #PID of the flavor until which the QCD radiation are kept in the matching procedure; - # if nqmatch=4, then all showered partons from b's are NOT taken into account - # Note (JY): I think the default should be 5 (b); anyway, don't try -1 as it'll result in a throw... - MEMAIN_excres = cms.string(""), - outTree_flag = cms.int32(0) # 1=yes, write out the tree for future sanity check - ), - PythiaParameters = cms.PSet( - processParameters = cms.vstring( - 'Main:timesAllowErrors = 10000', - 'ParticleDecays:tauMax = 10', - 'Tune:ee 3', - 'Tune:pp 5', - 'MultipleInteractions:pT0Ref=2.1006', - 'MultipleInteractions:ecmPow=0.21057', - 'MultipleInteractions:expPow=1.6089', - 'BeamRemnants:reconnectRange=3.31257', - ), - parameterSets = cms.vstring('processParameters') - ) -) diff --git a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.pyc b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.pyc deleted file mode 100644 index e1a8139913a11ad833c77aab57ebe2efa0b7d10b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1742 zcmZ`(UvnEZ5ZBrHXE%ux(^4oD+<(;c!HE-+8V`XK$Dx_Q9h10arY|1lv}a#>r@Kmf zjm->C{yKaI-gx4}FvACcmChGC)9K09?f&++D`~ZR`G41nfB*ISnaifnV|pLbU;p7S zCg|s|fUygQUF6v7yhU;>SYSQKvx`M02wGr9USeX=3d=@@6$S-1$uU7PS&POxaoB|A z#BxTv!C=*Zg2==n$2BI%i;&`b2$56HIuohaT85CRWWClcLWES^$OyEzO)GCOQMSyF zGWDiaZ)J|msvlohZ(Ei2mRdi#u6~-4?^xf@GVAA7y=zrk_Y13jnOQA)!iu6|5!&HB zD^Q~DGx30lhfF+T;wvT|Gf`#YYc^S#OXfWjjgmQW3a>ZKC7o5D(5?CZ(et88SI5vy zPw+O)-7yY*-gwT1ilqM=sAE4sP`FOE_J}0OgClVHSmP2wJ)T4X$2AgTu6PKYM`KbL4Bu?!x%QcKz-+@HM^ybslLS$JWQQ8)h9N2?scL=om z6*6_W7$_bOae*#9`A6aNF zk{(8vpx&TQ!Pz`lz76db7Y%MwoGm?a6=<~dRhpv&dkUcM1$F|+dXp`SwBB2RT z*_~-|T-nq2P4FZ@KMvqTQdw{p{YdI&+}l0{?_j4!OYG|hAEJR9cB9LK?b=R#d++Io z!@(#vyn1bayYa0J_apG|6hg_VzM2Z$NJ?<=l*<7e?ACVcJ9|&7Wm*=^>5hMGMG9(H zS)t;swIb>H12n0f$8DWVZF#b}p~i3MeO24`m>zebmX&>)vs&6E6dI}Abl>$nTWIa0 zX>*xE>l(93Xd;nv^#+8ktkktjO{Q#rruq?hoN{|2;{;n=360C-`A#D>)4-PNc@za! z=&1zIR1me+1Yl zrU?m{eLVV|L1^2|R7vY)yW2Rcw|ebg_J6MT8$Ec{52wA>Py4sgPtRvkR3pf=<9F18 uNdVuQPlP_Esq7SUt4@JN-YMkDxw4aulC$cRu8(}lDd!5#5^?88A@@Iu&$p}q diff --git a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.py~ b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.py~ deleted file mode 100644 index 672849494afad..0000000000000 --- a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1CTEQ6L1_8TeV_madgraph_pythia8_Tauola_cff.py~ +++ /dev/null @@ -1,44 +0,0 @@ -import FWCore.ParameterSet.Config as cms -from GeneratorInterface.ExternalDecays.TauolaSettings_cff import * - -generator = cms.EDFilter("Pythia8HadronizerFilter", - ExternalDecays = cms.PSet( - Tauola = cms.untracked.PSet( - TauolaPolar, - TauolaDefaultInputCards - ), - parameterSets = cms.vstring('Tauola') - ), - UseExternalGenerators = cms.untracked.bool(True), - maxEventsToPrint = cms.untracked.int32(1), - pythiaPylistVerbosity = cms.untracked.int32(1), - filterEfficiency = cms.untracked.double(1.0), - pythiaHepMCVerbosity = cms.untracked.bool(False), - comEnergy = cms.double(8000.), - jetMatching = cms.untracked.PSet( - scheme = cms.string("Madgraph"), - mode = cms.string("auto"),# soup, or "inclusive" / "exclusive" - MEMAIN_etaclmax = cms.double(-1), - MEMAIN_qcut = cms.double(-1), - MEMAIN_minjets = cms.int32(-1), - MEMAIN_maxjets = cms.int32(-1), - MEMAIN_showerkt = cms.double(0), # use 1=yes only for pt-ordered showers ! - MEMAIN_nqmatch = cms.int32(5), #PID of the flavor until which the QCD radiation are kept in the matching procedure; - # if nqmatch=4, then all showered partons from b's are NOT taken into account - # Note (JY): I think the default should be 5 (b); anyway, don't try -1 as it'll result in a throw... - MEMAIN_excres = cms.string(""), - outTree_flag = cms.int32(0) # 1=yes, write out the tree for future sanity check - ), - PythiaParameters = cms.PSet( - processParameters = cms.vstring( - 'Main:timesAllowErrors = 10000', - 'ParticleDecays:tauMax = 10', - 'Tune:ee 3', - 'Tune:pp 5', - 'MultipleInteractions:pT0Ref=2.1006', - 'MultipleInteractions:ecmPow=0.21057', - 'MultipleInteractions:expPow=1.6089', - 'BeamRemnants:reconnectRange=3.31257', - ), - parameterSets = cms.vstring('processParameters') - ) diff --git a/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1Herapdf15LO_13TeV_madgraph_pythia8_Tauola_cff.pyc b/Configuration/Generator/python/Hadronizer_MgmMatchTuneCUEP8S1Herapdf15LO_13TeV_madgraph_pythia8_Tauola_cff.pyc deleted file mode 100644 index 148887fc9157ee683c705754e333161a09e4cd0e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1842 zcmaJ>>2e!I5T2EMN%1KX0)Y?(2oVX$k}qTxh8S6nOj$u?E1@cXRO6lA^*VcbrZ<+U z;+NithoFk5;1#Ii0ib7AYuQk+Yp=S${(7dTkIDbJQ2hPZpO0-eejd~BGx}G*Sd0n! zvzX7=nZ?d>>~-ECIp$BXKIGZiG!q0(F)hz9F>QodEyEmx0vqL+AepR1Z5>%`#ByRb zqupXKuR%d%;*jG46XZom@m~m$Q_dn2snw+#d}stp z)W=MG!o;UcJYwQACLS|UVd8Tpo-py0jfilS(uaCYO6kZdyk60zI<9;{we$X>=S77I z$WVWt;9dImF7edkjSd$w3ca5|?t4Ch#6_~Tha`pE-vgUpDx4vx&y&dKxIkjeB@ciY z$AAj&5b{z%=JFgukQ^haaG5LtAGY5@h^im;q!*%RqR>9E*}r$`dkSBHJc*Qtm&V62 zfwUdRvpopyOPAR6{P8W`rk~WW197)CaVwC)j)FGr?T-24w`X{Z;4{E3NBh(ZU2_m+ zp8`ccN2V?puH^A4PLUEs0*t^DjBrVt+uhxR7Xv_U`*aSo+88^x6Ev9`>wy>2KI#U< zhX%T~k~)npK)ykb7H8MF;dx*}oYuHbakll)mY~qk=jj_I*p~nU$LFp|Ra(SeRuF|N z#ENBPgHjVz-PcQUFKnV0fZFx_=%Otp)u_BvuGi>M_lQ9b=-ED`Rc|6sx_oFDO6Rwq zgwO;iuTQi%E^jJb=HA|ZGf{BZ*(GTw3e}@Am?8>rr_(;t#(H)0@P|SB;Cc11<4RAc z3NgEhk6!G|0IJQ^r8zQZ)`UjwKe#%R{tOJ zFxKRHb!)q}S=+i=`8(jj5dUv$rP4kUyd9vAo!VUVp8W?kUhucuiW+^R1H61-#8mWiXz;+zd zz3sj6#Om(tX|t|U5+Y^r4G7b&scVlWSDK+u^*wMnW&9wF6KruQ6wZ?8TZJ^Cu9<<8 zDDsWamkFS5OPbyFHFE|LB`1Cg?sK0?tFMQ#ua3aYZU9{@Hubi^S>wS1N2*y)9NN+j1L45S^8LlVe-9NC*T%93aFbAWOaoS%tvHmLpSEP}xeT%8P2e)4N`0Z<*fZ2UZ?-(C7wzgUb3 z`m>nN*oDO|a_m*!AUWnwu^!~v#WWKHO))LcFfna}SuMjHg901nm>`*~^V&MH*ofuC zY(~4qU_pa|$iyMXMJC9LkokWhL{2$NOr&0m8A7I_@mewn5mI$IBT#HBMqXy3WSH+{ z>TRRm$sCzc-@U2cH7doHTHm{=zMqlr8Q%{w>xV|YZ&cd%BcndZtcE;d^J3K?6yZZ7 zP@+C&;u9u5W#SPNpE2>6i8UrZXW|JHPuYkFS1Em{*QAt=tir1mU8>WyFQ|6jU-Ud* zqXIJ2pC@>izTF|7d%WJ}LPnwY6Ual)N07Kgw$^~8koyN<^P$2Sf_glOe2$AG#$56M zh;a(2@D3p_6l5;XAOy)Vk_wl}67WImErh6gQCE5)dL|0(6Px|JL*G;Q669H=JRBMy z#{|-H9MAS3w1+OS>G|VZyiGr;UmN1i{=}_720IE`w6{Cv@BX@rw+Oxf>~OTtz0frW zQT91d^mAnDaN$ZGpW_rMK_tKkJi!Qy+T7~w9X;;@a@(hKnAOJE8#_Uhsj(h-A?>4X zKzv}JYb&Yq=n~{>^k{K*og2OhOo-DO*D21n9@r8T8u|i#qXc^rpzrwHHK|IA*v$%} zaD`a0jBHS9f~xy^N$!OW^a43gM z?Ij^J09H3AS{$!#D_!R9!C@m&aNOP_sTqap(HKk-1=wu2PPDOF-ah`J-#U6$K5o0x z6Kai^oy12k_Tea`uHrU&v_d29RZhTZZj^O^Uv0os3iCh7UNoG`Z3YeX1XT!ztrOVVvMTmqOtzdA?Oh6Y827 zIEy0R2tAnq>b9iW-P|x|5K(gGr{E#?skHif82jo7-0TL>#bT3>iZxH#>uC}ax+SR2 z>sRMr*ON`a Date: Wed, 4 Jun 2014 11:29:21 -0500 Subject: [PATCH 04/11] typo --- L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME11GEM.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME11GEM.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME11GEM.cc index c4b1f6352a8a2..487c7ea9b7840 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME11GEM.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME11GEM.cc @@ -447,10 +447,10 @@ void CSCMotherboardME11GEM::run(const CSCWireDigiCollection* wiredc, // LUT > createGEMRollEtaLUT(isEven); if (debug_luts){ - std::cout<<"me1b Det "<< me1bId<<" "<< me1bId.rawId() <<" " << (isEven ? "Even":"odd") <<" chamebr "<< me1bId.chamber()< Date: Wed, 4 Jun 2014 11:40:51 -0500 Subject: [PATCH 05/11] fix LUT(roll,eta) --- .../src/CSCMotherboardME11GEM.cc | 119 +++++++++++++++--- 1 file changed, 99 insertions(+), 20 deletions(-) diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME11GEM.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME11GEM.cc index 9d07c9b5c080a..bb0d017aa30da 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME11GEM.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME11GEM.cc @@ -385,20 +385,20 @@ void CSCMotherboardME11GEM::run(const CSCWireDigiCollection* wiredc, clctV1b = clct->run(compdc); // run cathodeLCT in ME1/b clctV1a = clct1a->run(compdc); // run cathodeLCT in ME1/a - const bool debugStubs(false); - if (debugStubs){ - for (auto& p : alctV){ - std::cout << "ALCT: " << p << std::endl; - } +// const bool debugStubs(false); +// if (debugStubs){ +// for (auto& p : alctV){ +// std::cout << "ALCT: " << p << std::endl; +// } - for (auto& p : clctV1b){ - std::cout << "CLCT in ME1b: " << p << std::endl; - } +// for (auto& p : clctV1b){ +// std::cout << "CLCT in ME1b: " << p << std::endl; +// } - for (auto& p : clctV1a){ - std::cout << "CLCT in ME1a: " << p << std::endl; - } - } +// for (auto& p : clctV1a){ +// std::cout << "CLCT in ME1a: " << p << std::endl; +// } +// } bool gemGeometryAvailable(false); if (gem_g != nullptr) { @@ -450,7 +450,7 @@ void CSCMotherboardME11GEM::run(const CSCWireDigiCollection* wiredc, std::cout<<"me1b Det "<< me1bId<<" "<< me1bId.rawId() <<" " << (isEven ? "Even":"odd") <<" chamebr "<< me1bId.chamber()< pCoPads(new GEMCSCPadDigiCollection()); buildCoincidencePads(gemPads, *pCoPads); @@ -541,12 +541,91 @@ void CSCMotherboardME11GEM::run(const CSCWireDigiCollection* wiredc, coPads_.clear(); retrieveGEMPads(gemPads, gem_id); retrieveGEMPads(pCoPads.get(), gem_id, true); + + const bool debugStubs(false); + if (debugStubs){ + for (auto& p : alctV){ + std::cout << "ALCT: " << p << std::endl; + } + + for (auto& p : clctV1b){ + std::cout << "CLCT in ME1b: " << p << std::endl; + } + + for (auto& p : clctV1a){ + std::cout << "CLCT in ME1a: " << p << std::endl; + } + + auto superChamber(gem_g->superChamber(gem_id)); + for (auto ch : superChamber->chambers()) { + for (auto roll : ch->etaPartitions()) { + GEMDetId roll_id(roll->id()); + auto pads_in_det = gemPads->get(roll_id); + for (auto pad = pads_in_det.first; pad != pads_in_det.second; ++pad) { + // auto id_pad = std::make_pair(roll_id(), &(*pad)); + if (abs((*pad).bx())<=1) + std::cout << "GEM: " << roll_id << " " << *pad << std::endl; + } + } + } + } } - + const bool hasPads(pads_.size()!=0); const bool hasCoPads(hasPads and coPads_.size()!=0); bool hasLCTs(false); + + // bool first = true; + if (false) for (int bx = 5; bx <= 7; bx++){ + const bool hasALCT1(alct->bestALCT[bx].isValid()); + const bool hasALCT2(alct->secondALCT[bx].isValid()); + const bool hasCLCT1(clct->bestCLCT[bx].isValid()); + const bool hasCLCT2(clct->secondCLCT[bx].isValid()); + const bool hasCLCT1a(clct1a->bestCLCT[bx].isValid()); + const bool hasCLCT2a(clct1a->secondCLCT[bx].isValid()); + const bool hasGEM1(pads_[bx].size()!=0); + const bool hasGEM2(coPads_[bx].size()!=0); + +// const bool ALCTandGEM1(hasALCT1 and hasGEM1); +// const bool ALCTandGEM2(hasALCT1 and hasGEM2); +// const bool CLCTandGEM1(hasCLCT1 and hasGEM1); +// const bool CLCTandGEM2(hasCLCT1 and hasGEM2); +// const bool ALCTandCLCT(hasALCT1 and hasCLCT1); + // const bool twoStubs(ALCTandGEM2 or CLCTandGEM2 or ALCTandCLCT or (ALCTandGEM1 and CLCTandGEM1)); + + const std::string ALCT1(hasALCT1? "X" : " "); + const std::string ALCT2(hasALCT2? "X" : " "); + const std::string CLCT1(hasCLCT1? "X" : " "); + const std::string CLCT2(hasCLCT2? "X" : " "); + const std::string CLCT1a(hasCLCT1a? "X" : " "); + const std::string CLCT2a(hasCLCT2a? "X" : " "); + const std::string GEM1(hasGEM1? "X" : " "); + const std::string GEM2(hasGEM2? "X" : " "); + + if (hasALCT1 or hasCLCT1 or hasCLCT1a or hasGEM1 or hasGEM2){ + // reference BX + if (bx==5) std::cout << "BX ALCT1 ALCT2 CLCTa1 CLCTa2 CLCTb1 CLCTb2 GEM1 GEM2"<begin(); pad_range_it != gemPads->end(); ++pad_range_it){ + // auto id = (*pad_range_it).first; + // auto pads_range = (*pad_range_it).second; +// for (auto p = pads_range.first; p != pads_range.second; ++p) +// std::cout << "GEM: " << GEMDetId(id) << " " << *p << std::endl; +// + + return; + // ALCT-centric matching for (int bx_alct = 0; bx_alct < CSCAnodeLCTProcessor::MAX_ALCT_BINS; bx_alct++) { @@ -1820,16 +1899,16 @@ void CSCMotherboardME11GEM::createGEMRollEtaLUT(bool isEven) auto chamber(gem_g->chamber(GEMDetId(1,1,1,1,ch,0))); if (chamber==nullptr) return; - for(int i = 1; i<= chamber->nEtaPartitions(); ++i){ - auto roll(chamber->etaPartition(i)); - if (roll==nullptr) continue; - + int n = 1; + if (isEven) n = 2; // this only works for the 9-10 partition geometry!!! FIXME + for(auto roll : chamber->etaPartitions()) { const float half_striplength(roll->specs()->specificTopology().stripLength()/2.); const LocalPoint lp_top(0., half_striplength, 0.); const LocalPoint lp_bottom(0., -half_striplength, 0.); const GlobalPoint gp_top(roll->toGlobal(lp_top)); const GlobalPoint gp_bottom(roll->toGlobal(lp_bottom)); - gemRollToEtaLimits_[i] = std::make_pair(gp_top.eta(), gp_bottom.eta()); + gemRollToEtaLimits_[n] = std::make_pair(gp_top.eta(), gp_bottom.eta()); + ++n; } } From 759f6e4511ebd59f0425d9b76243b50374af0d40 Mon Sep 17 00:00:00 2001 From: Sven Dildick Date: Wed, 4 Jun 2014 11:51:20 -0500 Subject: [PATCH 06/11] fiduciality GE21 --- .../python/cscTriggerPrimitiveDigisPostLS3_cfi.py | 1 + L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME21GEM.cc | 1 + L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME21GEM.h | 1 + 3 files changed, 3 insertions(+) diff --git a/L1Trigger/CSCTriggerPrimitives/python/cscTriggerPrimitiveDigisPostLS3_cfi.py b/L1Trigger/CSCTriggerPrimitives/python/cscTriggerPrimitiveDigisPostLS3_cfi.py index da107a213ecd0..82105aaa39e45 100644 --- a/L1Trigger/CSCTriggerPrimitives/python/cscTriggerPrimitiveDigisPostLS3_cfi.py +++ b/L1Trigger/CSCTriggerPrimitives/python/cscTriggerPrimitiveDigisPostLS3_cfi.py @@ -461,6 +461,7 @@ gemMatchDeltaPhiOdd = cms.double(1), gemMatchDeltaPhiEven = cms.double(1), gemMatchMinEta = cms.double(1.5), + gemMatchMaxEta = cms.double(2.45), gemClearNomatchLCTs = cms.bool(False), firstTwoLCTsInChamber = cms.bool(True), diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME21GEM.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME21GEM.cc index 41648432dea98..5d78c992846c4 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME21GEM.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME21GEM.cc @@ -108,6 +108,7 @@ CSCMotherboardME21GEM::CSCMotherboardME21GEM(unsigned endcap, unsigned station, /// min eta of LCT for which we require GEM match (we don't throw out LCTs below this min eta) gem_match_min_eta = me21tmbParams.getParameter("gemMatchMinEta"); + gem_match_max_eta = me21tmbParams.getParameter("gemMatchMaxEta"); /// whether to throw out GEM-fiducial LCTs that have no gem match gem_clear_nomatch_lcts = me21tmbParams.getParameter("gemClearNomatchLCTs"); diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME21GEM.h b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME21GEM.h index ddfa62f3bca86..4652afe810311 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME21GEM.h +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME21GEM.h @@ -155,6 +155,7 @@ class CSCMotherboardME21GEM : public CSCMotherboard /// min eta of LCT for which we require GEM match (we don't throw out LCTs below this min eta) double gem_match_min_eta; + double gem_match_max_eta; /// whether to throw out GEM-fiducial LCTs that have no gem match bool gem_clear_nomatch_lcts; From 36e7e97d7c0de84ef9b518da183460e8d7820257 Mon Sep 17 00:00:00 2001 From: Sven Dildick Date: Wed, 4 Jun 2014 11:57:37 -0500 Subject: [PATCH 07/11] clean-up --- .../src/CSCMotherboardME11GEM.cc | 41 +++---------------- 1 file changed, 6 insertions(+), 35 deletions(-) diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME11GEM.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME11GEM.cc index 19c7d5990e66e..a79d9641fbb7f 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME11GEM.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME11GEM.cc @@ -385,21 +385,6 @@ void CSCMotherboardME11GEM::run(const CSCWireDigiCollection* wiredc, clctV1b = clct->run(compdc); // run cathodeLCT in ME1/b clctV1a = clct1a->run(compdc); // run cathodeLCT in ME1/a -// const bool debugStubs(false); -// if (debugStubs){ -// for (auto& p : alctV){ -// std::cout << "ALCT: " << p << std::endl; -// } - -// for (auto& p : clctV1b){ -// std::cout << "CLCT in ME1b: " << p << std::endl; -// } - -// for (auto& p : clctV1a){ -// std::cout << "CLCT in ME1a: " << p << std::endl; -// } -// } - bool gemGeometryAvailable(false); if (gem_g != nullptr) { if (infoV >= 0) edm::LogInfo("L1CSCTPEmulatorSetupInfo") @@ -575,7 +560,6 @@ void CSCMotherboardME11GEM::run(const CSCWireDigiCollection* wiredc, const bool hasCoPads(hasPads and coPads_.size()!=0); bool hasLCTs(false); - // bool first = true; if (false) for (int bx = 5; bx <= 7; bx++){ const bool hasALCT1(alct->bestALCT[bx].isValid()); @@ -587,12 +571,12 @@ void CSCMotherboardME11GEM::run(const CSCWireDigiCollection* wiredc, const bool hasGEM1(pads_[bx].size()!=0); const bool hasGEM2(coPads_[bx].size()!=0); -// const bool ALCTandGEM1(hasALCT1 and hasGEM1); -// const bool ALCTandGEM2(hasALCT1 and hasGEM2); -// const bool CLCTandGEM1(hasCLCT1 and hasGEM1); -// const bool CLCTandGEM2(hasCLCT1 and hasGEM2); -// const bool ALCTandCLCT(hasALCT1 and hasCLCT1); - // const bool twoStubs(ALCTandGEM2 or CLCTandGEM2 or ALCTandCLCT or (ALCTandGEM1 and CLCTandGEM1)); + // const bool ALCTandGEM1(hasALCT1 and hasGEM1); + // const bool ALCTandGEM2(hasALCT1 and hasGEM2); + // const bool CLCTandGEM1(hasCLCT1 and hasGEM1); + // const bool CLCTandGEM2(hasCLCT1 and hasGEM2); + // const bool ALCTandCLCT(hasALCT1 and hasCLCT1); + // const bool twoStubs(ALCTandGEM2 or CLCTandGEM2 or ALCTandCLCT or (ALCTandGEM1 and CLCTandGEM1)); const std::string ALCT1(hasALCT1? "X" : " "); const std::string ALCT2(hasALCT2? "X" : " "); @@ -612,19 +596,6 @@ void CSCMotherboardME11GEM::run(const CSCWireDigiCollection* wiredc, <<" "<begin(); pad_range_it != gemPads->end(); ++pad_range_it){ - // auto id = (*pad_range_it).first; - // auto pads_range = (*pad_range_it).second; -// for (auto p = pads_range.first; p != pads_range.second; ++p) -// std::cout << "GEM: " << GEMDetId(id) << " " << *p << std::endl; -// - - return; // ALCT-centric matching for (int bx_alct = 0; bx_alct < CSCAnodeLCTProcessor::MAX_ALCT_BINS; bx_alct++) From 96156914f44aa7dc5797ae83c9ae66b17f4b3465 Mon Sep 17 00:00:00 2001 From: Sven Dildick Date: Wed, 4 Jun 2014 11:59:15 -0500 Subject: [PATCH 08/11] clean-up --- L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME11GEM.cc | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME11GEM.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME11GEM.cc index a79d9641fbb7f..b914f4dbea813 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME11GEM.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME11GEM.cc @@ -516,7 +516,6 @@ void CSCMotherboardME11GEM::run(const CSCWireDigiCollection* wiredc, } } - // build coincidence pads std::auto_ptr pCoPads(new GEMCSCPadDigiCollection()); buildCoincidencePads(gemPads, *pCoPads); @@ -555,7 +554,7 @@ void CSCMotherboardME11GEM::run(const CSCWireDigiCollection* wiredc, } } } - + const bool hasPads(pads_.size()!=0); const bool hasCoPads(hasPads and coPads_.size()!=0); bool hasLCTs(false); From e56db95cc0d4238b3b25d18b59b6d476d2449e36 Mon Sep 17 00:00:00 2001 From: Sven Dildick Date: Wed, 4 Jun 2014 16:12:51 -0500 Subject: [PATCH 09/11] fix the LUT -99s --- .../src/#CSCMotherboardME21GEM.cc# | 1337 ----------------- .../src/CSCMotherboardME21GEM.cc | 2 +- .../src/CSCMotherboardME3141RPC.cc | 2 +- 3 files changed, 2 insertions(+), 1339 deletions(-) delete mode 100644 L1Trigger/CSCTriggerPrimitives/src/#CSCMotherboardME21GEM.cc# diff --git a/L1Trigger/CSCTriggerPrimitives/src/#CSCMotherboardME21GEM.cc# b/L1Trigger/CSCTriggerPrimitives/src/#CSCMotherboardME21GEM.cc# deleted file mode 100644 index 580659e4f082d..0000000000000 --- a/L1Trigger/CSCTriggerPrimitives/src/#CSCMotherboardME21GEM.cc# +++ /dev/null @@ -1,1337 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include -#include -#include "boost/container/flat_set.hpp" - -const double CSCMotherboardME21GEM::lut_wg_eta_odd[112][2] = { -{ 0,2.441},{ 1,2.435},{ 2,2.425},{ 3,2.414},{ 4,2.404},{ 5,2.394},{ 6,2.384},{ 7,2.374}, -{ 8,2.365},{ 9,2.355},{10,2.346},{11,2.336},{12,2.327},{13,2.317},{14,2.308},{15,2.299}, -{16,2.290},{17,2.281},{18,2.273},{19,2.264},{20,2.255},{21,2.247},{22,2.238},{23,2.230}, -{24,2.221},{25,2.213},{26,2.205},{27,2.197},{28,2.189},{29,2.181},{30,2.173},{31,2.165}, -{32,2.157},{33,2.149},{34,2.142},{35,2.134},{36,2.127},{37,2.119},{38,2.112},{39,2.104}, -{40,2.097},{41,2.090},{42,2.083},{43,2.075},{44,2.070},{45,2.059},{46,2.054},{47,2.047}, -{48,2.041},{49,2.034},{50,2.027},{51,2.020},{52,2.014},{53,2.007},{54,2.000},{55,1.994}, -{56,1.988},{57,1.981},{58,1.975},{59,1.968},{60,1.962},{61,1.956},{62,1.950},{63,1.944}, -{64,1.937},{65,1.931},{66,1.924},{67,1.916},{68,1.909},{69,1.902},{70,1.895},{71,1.888}, -{72,1.881},{73,1.875},{74,1.868},{75,1.861},{76,1.854},{77,1.848},{78,1.841},{79,1.835}, -{80,1.830},{81,1.820},{82,1.815},{83,1.809},{84,1.803},{85,1.796},{86,1.790},{87,1.784}, -{88,1.778},{89,1.772},{90,1.766},{91,1.760},{92,1.754},{93,1.748},{94,1.742},{95,1.736}, -{96,1.731},{97,1.725},{98,1.719},{99,1.714},{100,1.708},{101,1.702},{102,1.697},{103,1.691}, -{104,1.686},{105,1.680},{106,1.675},{107,1.670},{108,1.664},{109,1.659},{110,1.654},{111,1.648}, -}; - -const double CSCMotherboardME21GEM::lut_wg_eta_even[112][2] = { -{ 0,2.412},{ 1,2.405},{ 2,2.395},{ 3,2.385},{ 4,2.375},{ 5,2.365},{ 6,2.355},{ 7,2.345}, -{ 8,2.335},{ 9,2.325},{10,2.316},{11,2.306},{12,2.297},{13,2.288},{14,2.279},{15,2.270}, -{16,2.261},{17,2.252},{18,2.243},{19,2.234},{20,2.226},{21,2.217},{22,2.209},{23,2.200}, -{24,2.192},{25,2.184},{26,2.175},{27,2.167},{28,2.159},{29,2.151},{30,2.143},{31,2.135}, -{32,2.128},{33,2.120},{34,2.112},{35,2.105},{36,2.097},{37,2.090},{38,2.082},{39,2.075}, -{40,2.068},{41,2.060},{42,2.053},{43,2.046},{44,2.041},{45,2.030},{46,2.025},{47,2.018}, -{48,2.011},{49,2.005},{50,1.998},{51,1.991},{52,1.985},{53,1.978},{54,1.971},{55,1.965}, -{56,1.958},{57,1.952},{58,1.946},{59,1.939},{60,1.933},{61,1.927},{62,1.921},{63,1.915}, -{64,1.909},{65,1.902},{66,1.895},{67,1.887},{68,1.880},{69,1.873},{70,1.866},{71,1.859}, -{72,1.853},{73,1.846},{74,1.839},{75,1.832},{76,1.826},{77,1.819},{78,1.812},{79,1.806}, -{80,1.801},{81,1.792},{82,1.787},{83,1.780},{84,1.774},{85,1.768},{86,1.762},{87,1.756}, -{88,1.750},{89,1.744},{90,1.738},{91,1.732},{92,1.726},{93,1.720},{94,1.714},{95,1.708}, -{96,1.702},{97,1.697},{98,1.691},{99,1.685},{100,1.680},{101,1.674},{102,1.669},{103,1.663}, -{104,1.658},{105,1.652},{106,1.647},{107,1.642},{108,1.636},{109,1.631},{110,1.626},{111,1.621}, -}; - -// LUT with bending angles of the GEM-CSC high efficiency patterns (98%) -// 1st index: pt value = {5,10,15,20,30,40} -// 2nd index: bending angle for odd numbered chambers -// 3rd index: bending angle for even numbered chambers -const double CSCMotherboardME21GEM::lut_pt_vs_dphi_gemcsc[7][3] = { - - 3, 0.01832829, : 0.01003643 }, - 5, 0.01095490, : 0.00631625 }, - 7, 0.00786026, : 0.00501017 }, - 10, 0.00596349, : 0.00414560 }, - 15, 0.00462411, : 0.00365550 }, - 20, 0.00435298, : 0.00361550 }, - 30, 0.00465160, : 0.00335700 }, - 40, 0.00372145, : 0.00366262 } } - -CSCMotherboardME21GEM::CSCMotherboardME21GEM(unsigned endcap, unsigned station, - unsigned sector, unsigned subsector, - unsigned chamber, - const edm::ParameterSet& conf) : - CSCMotherboard(endcap, station, sector, subsector, chamber, conf) -{ - const edm::ParameterSet commonParams(conf.getParameter("commonParam")); - runME21ILT_ = commonParams.getParameter("runME21ILT"); - - if (!isSLHC) edm::LogError("L1CSCTPEmulatorConfigError") - << "+++ Upgrade CSCMotherboardME21GEM constructed while isSLHC is not set! +++\n"; - - const edm::ParameterSet me21tmbParams(conf.getParameter("me21tmbSLHCGEM")); - - // whether to not reuse CLCTs that were used by previous matching ALCTs - // in ALCT-to-CLCT algorithm - drop_used_clcts = me21tmbParams.getParameter("tmbDropUsedClcts"); - - match_earliest_clct_me21_only = me21tmbParams.getParameter("matchEarliestClctME21Only"); - - tmb_cross_bx_algo = me21tmbParams.getParameter("tmbCrossBxAlgorithm"); - - // maximum lcts per BX in ME2 - max_me21_lcts = me21tmbParams.getParameter("maxME21LCTs"); - - pref[0] = match_trig_window_size/2; - for (unsigned int m=2; m("doGemMatching"); - - /// GEM matching dphi and deta - gem_match_delta_phi_odd = me21tmbParams.getParameter("gemMatchDeltaPhiOdd"); - gem_match_delta_phi_even = me21tmbParams.getParameter("gemMatchDeltaPhiEven"); - gem_match_delta_eta = me21tmbParams.getParameter("gemMatchDeltaEta"); - - /// delta BX for GEM pads matching - gem_match_delta_bx = me21tmbParams.getParameter("gemMatchDeltaBX"); - - /// min eta of LCT for which we require GEM match (we don't throw out LCTs below this min eta) - gem_match_min_eta = me21tmbParams.getParameter("gemMatchMinEta"); - - /// whether to throw out GEM-fiducial LCTs that have no gem match - gem_clear_nomatch_lcts = me21tmbParams.getParameter("gemClearNomatchLCTs"); - - // debug gem matching - debug_gem_matching = me21tmbParams.getParameter("debugMatching"); - debug_luts = me21tmbParams.getParameter("debugLUTs"); - debug_gem_dphi = me21tmbParams.getParameter("debugGEMDphi"); - - // deltas used to construct GEM coincidence pads - maxDeltaBXInCoPad_ = me21tmbParams.getParameter("maxDeltaBXInCoPad"); - maxDeltaPadInCoPad_ = me21tmbParams.getParameter("maxDeltaPadInCoPad"); - - // deltas used to match to GEM pads - maxDeltaBXPad_ = me21tmbParams.getParameter("maxDeltaBXPad"); - maxDeltaPadPad_ = me21tmbParams.getParameter("maxDeltaPadPad"); - - // deltas used to match to GEM coincidence pads - maxDeltaBXCoPad_ = me21tmbParams.getParameter("maxDeltaBXCoPad"); - maxDeltaPadCoPad_ = me21tmbParams.getParameter("maxDeltaPadCoPad"); - - // drop low quality stubs if they don't have GEMs - dropLowQualityCLCTsNoGEMs_ = me21tmbParams.getParameter("dropLowQualityCLCTsNoGEMs"); - dropLowQualityALCTsNoGEMs_ = me21tmbParams.getParameter("dropLowQualityALCTsNoGEMs"); - - // correct LCT timing with GEMs - correctLCTtimingWithGEM_ = me21tmbParams.getParameter("correctLCTtimingWithGEM"); - - // build LCT from ALCT and GEM - buildLCTfromALCTandGEM_ = me21tmbParams.getParameter("buildLCTfromALCTandGEM"); - buildLCTfromCLCTandGEM_ = me21tmbParams.getParameter("buildLCTfromCLCTandGEM"); - - // LCT ghostbusting - doLCTGhostBustingWithGEMs_ = me21tmbParams.getParameter("doLCTGhostBustingWithGEMs"); - - // use "old" or "new" dataformat for integrated LCTs? - useOldLCTDataFormatALCTGEM_ = me21tmbParams.getParameter("useOldLCTDataFormatALCTGEM"); - useOldLCTDataFormatCLCTGEM_ = me21tmbParams.getParameter("useOldLCTDataFormatCLCTGEM"); - - // promote ALCT-GEM pattern - promoteALCTGEMpattern_ = me21tmbParams.getParameter("promoteALCTGEMpattern"); - - // promote ALCT-GEM quality - promoteALCTGEMquality_ = me21tmbParams.getParameter("promoteALCTGEMquality"); - promoteCLCTGEMquality_ = me21tmbParams.getParameter("promoteCLCTGEMquality"); -} - -CSCMotherboardME21GEM::~CSCMotherboardME21GEM() -{ -} - -void CSCMotherboardME21GEM::clear() -{ - CSCMotherboard::clear(); - - for (int bx = 0; bx < MAX_LCT_BINS; bx++) - for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) - for (int i=0;i<2;i++) - allLCTs[bx][mbx][i].clear(); - - gemRollToEtaLimitsShort_.clear(); - gemRollToEtaLimitsLong_.clear(); - cscWgToGemRollShort_.clear(); - cscWgToGemRollLong_.clear(); - gemPadToCscHs_.clear(); - cscHsToGemPad_.clear(); - padsShort_.clear(); - padsLong_.clear(); - coPadsShort_.clear(); - coPadsLong_.clear(); -} - -void -CSCMotherboardME21GEM::run(const CSCWireDigiCollection* wiredc, - const CSCComparatorDigiCollection* compdc, - const GEMCSCPadDigiCollection* gemPads) -{ - clear(); - - if (!( alct and clct and runME21ILT_)) - { - if (infoV >= 0) edm::LogError("L1CSCTPEmulatorSetupError") - << "+++ run() called for non-existing ALCT/CLCT processor! +++ \n"; - return; - } - - alct->run(wiredc); // run anodeLCT - clct->run(compdc); // run cathodeLCT - - bool gemGeometryAvailable(false); - if (gem_g != nullptr) { - if (infoV >= 0) edm::LogInfo("L1CSCTPEmulatorSetupInfo") - << "+++ run() called for GEM-CSC integrated trigger! +++ \n"; - gemGeometryAvailable = true; - } - - // retrieve CSCChamber geometry - CSCTriggerGeomManager* geo_manager(CSCTriggerGeometry::get()); - const CSCChamber* cscChamber(geo_manager->chamber(theEndcap, theStation, theSector, theSubsector, theTrigChamber)); - const CSCDetId csc_id(cscChamber->id()); - - if (runME21ILT_){ - - // check for GE2/1 geometry - if ((not gemGeometryAvailable) or (gemGeometryAvailable and (gem_g->stations()).size()==2)) { - if (infoV >= 0) edm::LogError("L1CSCTPEmulatorSetupError") - << "+++ run() called for GEM-CSC integrated trigger without valid GE21 geometry! +++ \n"; - return; - } - - // trigger geometry - const CSCLayer* keyLayer(cscChamber->layer(3)); - const CSCLayerGeometry* keyLayerGeometry(keyLayer->geometry()); - - // const bool isEven(csc_id%2==0); - const int region((theEndcap == 1) ? 1: -1); - const bool isEven(csc_id%2==0); - const GEMDetId gem_id_short(region, 1, 2, 1, csc_id.chamber(), 0); - const GEMDetId gem_id_long(region, 1, 3, 1, csc_id.chamber(), 0); - // const GEMChamber* gemChamberShort(gem_g->chamber(gem_id_short)); - const GEMChamber* gemChamberLong(gem_g->chamber(gem_id_long)); - - // LUT > - gemRollToEtaLimitsShort_ = createGEMRollEtaLUT(false); - gemRollToEtaLimitsLong_ = createGEMRollEtaLUT(true); - - if (debug_luts){ - if (gemRollToEtaLimitsShort_.size()) - for(auto p : gemRollToEtaLimitsShort_) { - std::cout << "pad "<< p.first << " min eta " << (p.second).first << " max eta " << (p.second).second << std::endl; - } - if (gemRollToEtaLimitsLong_.size()) - for(auto p : gemRollToEtaLimitsLong_) { - std::cout << "pad "<< p.first << " min eta " << (p.second).first << " max eta " << (p.second).second << std::endl; - } - } - - // loop on all wiregroups to create a LUT - const int numberOfWG(keyLayerGeometry->numberOfWireGroups()); - for (int i = 0; i< numberOfWG; ++i){ - auto eta(isEven ? lut_wg_eta_even[i][1] : lut_wg_eta_odd[i][1]); - cscWgToGemRollLong_[i] = assignGEMRoll(eta); - } - if (debug_luts){ - for(auto p : cscWgToGemRollLong_) { - std::cout << "WG "<< p.first << " GEM roll " << p.second << std::endl; - } - } - - auto randRoll(gemChamberLong->etaPartition(2)); - auto nStrips(keyLayerGeometry->numberOfStrips()); - for (float i = 0; i< nStrips; i = i+0.5){ - const LocalPoint lpCSC(keyLayerGeometry->topology()->localPosition(i)); - const GlobalPoint gp(keyLayer->toGlobal(lpCSC)); - const LocalPoint lpGEM(randRoll->toLocal(gp)); - const int HS(i/0.5); - const bool edge(HS < 5 or HS > 155); - const float pad(edge ? -99 : randRoll->pad(lpGEM)); - // HS are wrapped-around - cscHsToGemPad_[HS] = std::make_pair(std::floor(pad),std::ceil(pad)); - } - if (debug_luts){ - std::cout << "detId " << csc_id << std::endl; - for(auto p : cscHsToGemPad_) { - std::cout << "CSC HS "<< p.first << " GEM Pad low " << (p.second).first << " GEM Pad high " << (p.second).second << std::endl; - } - } - - // pick any roll (from short or long superchamber) - const int nGEMPads(randRoll->npads()); - for (int i = 0; i< nGEMPads; ++i){ - const LocalPoint lpGEM(randRoll->centreOfPad(i)); - const GlobalPoint gp(randRoll->toGlobal(lpGEM)); - const LocalPoint lpCSC(keyLayer->toLocal(gp)); - const float strip(keyLayerGeometry->strip(lpCSC)); - // HS are wrapped-around - gemPadToCscHs_[i] = (int) (strip - 0.25)/0.5; - } - if (debug_luts){ - std::cout << "detId " << csc_id << std::endl; - for(auto p : gemPadToCscHs_) { - std::cout << "GEM Pad "<< p.first << " CSC HS : " << p.second << std::endl; - } - } - - // build coincidence pads - std::auto_ptr pCoPads(new GEMCSCPadDigiCollection()); - buildCoincidencePads(gemPads, *pCoPads); - - // retrieve pads and copads in a certain BX window for this CSC - padsShort_ = retrieveGEMPads(gemPads, gem_id_short); - padsLong_ = retrieveGEMPads(gemPads, gem_id_long); - coPadsShort_ = retrieveGEMPads(pCoPads.get(), gem_id_short, true); - coPadsLong_ = retrieveGEMPads(pCoPads.get(), gem_id_long, true); - } - - const bool hasPads(padsLong_.size()!=0); - const bool hasCoPads(hasPads and coPadsLong_.size()!=0); - - int used_clct_mask[20]; - for (int c=0;c<20;++c) used_clct_mask[c]=0; - - // ALCT centric matching - for (int bx_alct = 0; bx_alct < CSCAnodeLCTProcessor::MAX_ALCT_BINS; bx_alct++) - { - if (alct->bestALCT[bx_alct].isValid()) - { - const int bx_clct_start(bx_alct - match_trig_window_size/2); - const int bx_clct_stop(bx_alct + match_trig_window_size/2); - const int bx_copad_start(bx_alct - maxDeltaBXCoPad_); - const int bx_copad_stop(bx_alct + maxDeltaBXCoPad_); - - if (debug_gem_matching){ - std::cout << "========================================================================" << std::endl; - std::cout << "ALCT-CLCT matching in ME2/1 chamber: " << cscChamber->id() << std::endl; - std::cout << "------------------------------------------------------------------------" << std::endl; - std::cout << "+++ Best ALCT Details: "; - alct->bestALCT[bx_alct].print(); - std::cout << "+++ Second ALCT Details: "; - alct->secondALCT[bx_alct].print(); - - //printGEMTriggerPads(bx_clct_start, bx_clct_stop, true); - //printGEMTriggerPads(bx_clct_start, bx_clct_stop, true, true); - printGEMTriggerPads(bx_clct_start, bx_clct_stop, false); - printGEMTriggerPads(bx_clct_start, bx_clct_stop, false, true); - - std::cout << "------------------------------------------------------------------------" << std::endl; - std::cout << "Attempt ALCT-CLCT matching in ME2/1 in bx range: [" << bx_clct_start << "," << bx_clct_stop << "]" << std::endl; - } - - // ALCT-to-CLCT - int nSuccesFulMatches = 0; - for (int bx_clct = bx_clct_start; bx_clct <= bx_clct_stop; bx_clct++) - { - if (bx_clct < 0 or bx_clct >= CSCCathodeLCTProcessor::MAX_CLCT_BINS) continue; - if (drop_used_clcts and used_clct_mask[bx_clct]) continue; - if (clct->bestCLCT[bx_clct].isValid()) - { - // clct quality - const int quality(clct->bestCLCT[bx_clct].getQuality()); - // low quality ALCT - const bool lowQualityALCT(alct->bestALCT[bx_alct].getQuality() == 0); - // low quality ALCT or CLCT - const bool lowQuality(quality<4 or lowQualityALCT); - if (debug_gem_matching) std::cout << "++Valid ME21 CLCT: " << clct->bestCLCT[bx_clct] << std::endl; - - // pick the pad that corresponds - auto matchingPads(matchingGEMPads(clct->bestCLCT[bx_clct], alct->bestALCT[bx_alct], padsLong_[bx_clct], false)); - auto matchingCoPads(matchingGEMPads(clct->bestCLCT[bx_clct], alct->bestALCT[bx_alct], coPadsLong_[bx_clct], true)); - if (runME21ILT_ and dropLowQualityCLCTsNoGEMs_ and lowQuality and hasPads){ - int nFound(matchingPads.size()); - const bool clctInEdge(clct->bestCLCT[bx_clct].getKeyStrip() < 5 or clct->bestCLCT[bx_clct].getKeyStrip() > 155); - if (clctInEdge){ - if (debug_gem_matching) std::cout << "\tInfo: low quality CLCT in CSC chamber edge, don't care about GEM pads" << std::endl; - } - else { - if (nFound != 0){ - if (debug_gem_matching) std::cout << "\tInfo: low quality CLCT with " << nFound << " matching GEM trigger pads" << std::endl; - } - else { - if (debug_gem_matching) std::cout << "\tWarning: low quality CLCT without matching GEM trigger pad" << std::endl; - continue; - } - } - } - - // check timing - if (runME21ILT_ and correctLCTtimingWithGEM_){ - int nFound(matchingCoPads.size()); - if (nFound != 0 and bx_alct == 6 and bx_clct != 6){ - if (debug_gem_matching) std::cout << "\tInfo: CLCT with incorrect timing" << std::endl; - continue; - } - } - - ++nSuccesFulMatches; - - int mbx = bx_clct-bx_clct_start; - - correlateLCTsGEM(alct->bestALCT[bx_alct], alct->secondALCT[bx_alct], - clct->bestCLCT[bx_clct], clct->secondCLCT[bx_clct], - allLCTs[bx_alct][mbx][0], allLCTs[bx_alct][mbx][1], matchingPads, matchingCoPads); - if (debug_gem_matching) { - // if (infoV > 1) LogTrace("CSCMotherboard") - std::cout << "Successful ALCT-CLCT match in ME21: bx_alct = " << bx_alct - << "; match window: [" << bx_clct_start << "; " << bx_clct_stop - << "]; bx_clct = " << bx_clct << std::endl; - std::cout << "+++ Best CLCT Details: "; - clct->bestCLCT[bx_clct].print(); - std::cout << "+++ Second CLCT Details: "; - clct->secondCLCT[bx_clct].print(); - } - if (allLCTs[bx_alct][mbx][0].isValid()) { - used_clct_mask[bx_clct] += 1; - if (match_earliest_clct_me21_only) break; - } - } - } - - // ALCT-to-GEM matching - int nSuccesFulGEMMatches = 0; - if (runME21ILT_ and nSuccesFulMatches==0 and buildLCTfromALCTandGEM_){ - if (debug_gem_matching) std::cout << "++No valid ALCT-CLCT matches in ME21" << std::endl; - for (int bx_gem = bx_copad_start; bx_gem <= bx_copad_stop; bx_gem++) { - if (not hasCoPads) { - continue; - } - - // find the best matching copad - first one - auto copads(matchingGEMPads(alct->bestALCT[bx_alct], coPadsLong_[bx_gem], true)); - if (debug_gem_matching) std::cout << "\t++Number of matching GEM CoPads in BX " << bx_alct << " : "<< copads.size() << std::endl; - if (copads.size()==0) { - continue; - } - - correlateLCTsGEM(alct->bestALCT[bx_alct], alct->secondALCT[bx_alct], - *(copads.at(0)).second, allLCTs[bx_alct][0][0], allLCTs[bx_alct][0][1]); - if (allLCTs[bx_alct][0][0].isValid()) { - ++nSuccesFulGEMMatches; - if (match_earliest_clct_me21_only) break; - } - if (debug_gem_matching) { - std::cout << "Successful ALCT-GEM CoPad match in ME21: bx_alct = " << bx_alct << std::endl << std::endl; - std::cout << "------------------------------------------------------------------------" << std::endl << std::endl; - } - } - } - - if (debug_gem_matching) { - std::cout << "========================================================================" << std::endl; - std::cout << "Summary: " << std::endl; - if (nSuccesFulMatches>1) - std::cout << "Too many successful ALCT-CLCT matches in ME21: " << nSuccesFulMatches - << ", CSCDetId " << cscChamber->id() - << ", bx_alct = " << bx_alct - << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl; - else if (nSuccesFulMatches==1) - std::cout << "1 successful ALCT-CLCT match in ME21: " - << " CSCDetId " << cscChamber->id() - << ", bx_alct = " << bx_alct - << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl; - else if (nSuccesFulGEMMatches==1) - std::cout << "1 successful ALCT-GEM match in ME21: " - << " CSCDetId " << cscChamber->id() - << ", bx_alct = " << bx_alct - << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl; - else - std::cout << "Unsuccessful ALCT-CLCT match in ME21: " - << "CSCDetId " << cscChamber->id() - << ", bx_alct = " << bx_alct - << "; match window: [" << bx_clct_start << "; " << bx_clct_stop << "]" << std::endl; - } - } - // at this point we have invalid ALCTs --> try GEM pad matching - else{ - auto coPads(coPadsLong_[bx_alct]); - if (runME21ILT_ and coPads.size() and buildLCTfromCLCTandGEM_) { - const int bx_clct_start(bx_alct - match_trig_window_size/2); - const int bx_clct_stop(bx_alct + match_trig_window_size/2); - - if (debug_gem_matching){ - std::cout << "========================================================================" << std::endl; - std::cout << "GEM-CLCT matching in ME2/1 chamber: " << cscChamber->id() << " in bx range: [" << bx_clct_start << "," << bx_clct_stop << "]" << std::endl; - std::cout << "------------------------------------------------------------------------" << std::endl; - } - // GEM-to-CLCT - int nSuccesFulMatches = 0; - for (int bx_clct = bx_clct_start; bx_clct <= bx_clct_stop; bx_clct++) - { - if (bx_clct < 0 or bx_clct >= CSCCathodeLCTProcessor::MAX_CLCT_BINS) continue; - if (drop_used_clcts and used_clct_mask[bx_clct]) continue; - if (clct->bestCLCT[bx_clct].isValid()) - { - const int quality(clct->bestCLCT[bx_clct].getQuality()); - // only use high-Q stubs for the time being - if (quality < 4) continue; - - ++nSuccesFulMatches; - - int mbx = bx_clct-bx_clct_start; - correlateLCTsGEM(clct->bestCLCT[bx_clct], clct->secondCLCT[bx_clct], *(coPads[0].second), GEMDetId(coPads[0].first).roll(), - allLCTs[bx_alct][mbx][0], allLCTs[bx_alct][mbx][1]); - if (debug_gem_matching) { - // if (infoV > 1) LogTrace("CSCMotherboard") - std::cout << "Successful GEM-CLCT match in ME21: bx_alct = " << bx_alct - << "; match window: [" << bx_clct_start << "; " << bx_clct_stop - << "]; bx_clct = " << bx_clct << std::endl; - std::cout << "+++ Best CLCT Details: "; - clct->bestCLCT[bx_clct].print(); - std::cout << "+++ Second CLCT Details: "; - clct->secondCLCT[bx_clct].print(); - } - if (allLCTs[bx_alct][mbx][0].isValid()) { - used_clct_mask[bx_clct] += 1; - if (match_earliest_clct_me21_only) break; - } - } - } - } - } - } - - // Possibly use some discrimination from GEMs - if (gemGeometryAvailable and runME21ILT_ and do_gem_matching) matchGEMPads(); - - // reduction of nLCTs per each BX - for (int bx = 0; bx < MAX_LCT_BINS; bx++) - { - // counting - unsigned int n=0; - for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) - for (int i=0;i<2;i++) - { - int cbx = bx + mbx - match_trig_window_size/2; - if (allLCTs[bx][mbx][i].isValid()) - { - ++n; - if (infoV > 0) LogDebug("CSCMotherboard") - << "LCT"<2)) - { - n=0; - for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) - for (int i=0;i<2;i++) - { - if (allLCTs[bx][pref[mbx]][i].isValid()) - { - n++; - if (n>2) allLCTs[bx][pref[mbx]][i].clear(); - } - } - - n=0; - for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) - for (int i=0;i<2;i++) - { - int cbx = bx + mbx - match_trig_window_size/2; - if (allLCTs[bx][mbx][i].isValid()) - { - n++; - if (infoV > 0) LogDebug("CSCMotherboard") - << "LCT"< 0 and n>0) LogDebug("CSCMotherboard") - <<"bx "< CSCMotherboardME21GEM::readoutLCTs() -{ - return getLCTs(); -} - -//getLCTs when we use different sort algorithm -std::vector CSCMotherboardME21GEM::getLCTs() -{ - std::vector result; - for (int bx = 0; bx < MAX_LCT_BINS; bx++) { - std::vector tmpV; - if (tmb_cross_bx_algo == 2) { - tmpV = sortLCTsByQuality(bx); - result.insert(result.end(), tmpV.begin(), tmpV.end()); - } - else { - for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) { - for (int i=0;i<2;i++) { - if (allLCTs[bx][mbx][i].isValid()) { - result.push_back(allLCTs[bx][mbx][i]); - } - } - } - } - } - return result; -} - -//sort LCTs by Quality in each BX -std::vector CSCMotherboardME21GEM::sortLCTsByQuality(int bx) -{ - std::vector LCTs; - LCTs.clear(); - for (unsigned int mbx = 0; mbx < match_trig_window_size; mbx++) - for (int i=0;i<2;i++) - if (allLCTs[bx][mbx][i].isValid()) - LCTs.push_back(allLCTs[bx][mbx][i]); - - // return sorted vector with 2 highest quality LCTs - std::sort(LCTs.begin(), LCTs.end(), CSCMotherboard::sortByQuality); - if (LCTs.size()> max_me21_lcts) LCTs.erase(LCTs.begin()+max_me21_lcts, LCTs.end()); - return LCTs; -} - -void CSCMotherboardME21GEM::correlateLCTsGEM(CSCALCTDigi bestALCT, - CSCALCTDigi secondALCT, - CSCCLCTDigi bestCLCT, - CSCCLCTDigi secondCLCT, - CSCCorrelatedLCTDigi& lct1, - CSCCorrelatedLCTDigi& lct2, - const GEMPadsBX& pads, - const GEMPadsBX& copads) -{ - // check for pads - const int nPads(pads.size()); - const int nCoPads(copads.size()); - const bool hasPads(nPads!=0); - const bool hasCoPads(nCoPads!=0); - - bool anodeBestValid = bestALCT.isValid(); - bool anodeSecondValid = secondALCT.isValid(); - bool cathodeBestValid = bestCLCT.isValid(); - bool cathodeSecondValid = secondCLCT.isValid(); - - if (anodeBestValid and !anodeSecondValid) secondALCT = bestALCT; - if (!anodeBestValid and anodeSecondValid) bestALCT = secondALCT; - if (cathodeBestValid and !cathodeSecondValid) secondCLCT = bestCLCT; - if (!cathodeBestValid and cathodeSecondValid) bestCLCT = secondCLCT; - - // ALCT-CLCT matching conditions are defined by "trig_enable" configuration - // parameters. - if ((alct_trig_enable and bestALCT.isValid()) or - (clct_trig_enable and bestCLCT.isValid()) or - (match_trig_enable and bestALCT.isValid() and bestCLCT.isValid())) - { - lct1 = constructLCTsGEM(bestALCT, bestCLCT, hasPads, hasCoPads); - lct1.setTrknmb(1); - } - - if (((secondALCT != bestALCT) or (secondCLCT != bestCLCT)) and - ((alct_trig_enable and secondALCT.isValid()) or - (clct_trig_enable and secondCLCT.isValid()) or - (match_trig_enable and secondALCT.isValid() and secondCLCT.isValid()))) - { - lct2 = constructLCTsGEM(secondALCT, secondCLCT, hasPads, hasCoPads); - lct2.setTrknmb(2); - } -} - - -void CSCMotherboardME21GEM::correlateLCTsGEM(CSCALCTDigi bestALCT, - CSCALCTDigi secondALCT, - GEMCSCPadDigi gemPad, - CSCCorrelatedLCTDigi& lct1, - CSCCorrelatedLCTDigi& lct2) -{ - bool anodeBestValid = bestALCT.isValid(); - bool anodeSecondValid = secondALCT.isValid(); - - if (anodeBestValid and !anodeSecondValid) secondALCT = bestALCT; - if (!anodeBestValid and anodeSecondValid) bestALCT = secondALCT; - - if ((alct_trig_enable and bestALCT.isValid()) or - (match_trig_enable and bestALCT.isValid())) - { - lct1 = constructLCTsGEM(bestALCT, gemPad, useOldLCTDataFormatALCTGEM_); - lct1.setTrknmb(1); - lct1.setGEMDPhi(0.0); - } - - if ((alct_trig_enable and secondALCT.isValid()) or - (match_trig_enable and secondALCT.isValid() and secondALCT != bestALCT)) - { - lct2 = constructLCTsGEM(secondALCT, gemPad, useOldLCTDataFormatALCTGEM_); - lct2.setTrknmb(2); - lct2.setGEMDPhi(0.0); - } -} - - -void CSCMotherboardME21GEM::correlateLCTsGEM(CSCCLCTDigi bestCLCT, - CSCCLCTDigi secondCLCT, - GEMCSCPadDigi gemPad, int roll, - CSCCorrelatedLCTDigi& lct1, - CSCCorrelatedLCTDigi& lct2) -{ - bool cathodeBestValid = bestCLCT.isValid(); - bool cathodeSecondValid = secondCLCT.isValid(); - - if (cathodeBestValid and !cathodeSecondValid) secondCLCT = bestCLCT; - if (!cathodeBestValid and cathodeSecondValid) bestCLCT = secondCLCT; - - if ((clct_trig_enable and bestCLCT.isValid()) or - (match_trig_enable and bestCLCT.isValid())) - { - lct1 = constructLCTsGEM(bestCLCT, gemPad, roll, useOldLCTDataFormatCLCTGEM_); - lct1.setTrknmb(1); - } - - if ((clct_trig_enable and secondCLCT.isValid()) or - (match_trig_enable and secondCLCT.isValid() and secondCLCT != bestCLCT)) - { - lct2 = constructLCTsGEM(secondCLCT, gemPad, roll, useOldLCTDataFormatCLCTGEM_); - lct2.setTrknmb(2); - } -} - - -CSCCorrelatedLCTDigi CSCMotherboardME21GEM::constructLCTsGEM(const CSCALCTDigi& alct, - const GEMCSCPadDigi& gem, - bool oldDataFormat) -{ - if (oldDataFormat){ - // CLCT pattern number - set it to a highest value - // hack to get LCTs in the CSCTF - unsigned int pattern = promoteALCTGEMpattern_ ? 10 : 0; - - // LCT quality number - set it to a very high value - // hack to get LCTs in the CSCTF - unsigned int quality = promoteALCTGEMquality_ ? 14 : 11; - - // Bunch crossing - int bx = alct.getBX(); - - // get keyStrip from LUT - int keyStrip = gemPadToCscHs_[gem.pad()]; - - // get wiregroup from ALCT - int wg = alct.getKeyWG(); - - // construct correlated LCT; temporarily assign track number of 0. - return CSCCorrelatedLCTDigi(0, 1, quality, wg, keyStrip, pattern, 0, bx, 0, 0, 0, theTrigChamber); - } - else { - // CLCT pattern number - no pattern - unsigned int pattern = 0; - - // LCT quality number - unsigned int quality = 1; - - // Bunch crossing - int bx = gem.bx() + lct_central_bx; - - // get keyStrip from LUT - int keyStrip = gemPadToCscHs_[gem.pad()]; - // get wiregroup from ALCT - int wg = alct.getKeyWG(); - - // construct correlated LCT; temporarily assign track number of 0. - return CSCCorrelatedLCTDigi(0, 1, quality, wg, keyStrip, pattern, 0, bx, 0, 0, 0, theTrigChamber); - } -} - -CSCCorrelatedLCTDigi CSCMotherboardME21GEM::constructLCTsGEM(const CSCCLCTDigi& clct, - const GEMCSCPadDigi& gem, int roll, - bool oldDataFormat) -{ - if (oldDataFormat){ - // CLCT pattern number - for the time being, do not include GEMs in the pattern - unsigned int pattern = encodePattern(clct.getPattern(), clct.getStripType()); - - // LCT quality number - dummy quality - unsigned int quality = promoteCLCTGEMquality_ ? 14 : 11; - - // Bunch crossing: pick GEM bx - int bx = gem.bx() + lct_central_bx; - - // pick a random WG in the roll range - int wg(getRandomWGForGEMRoll(roll)); - - // construct correlated LCT; temporarily assign track number of 0. - return CSCCorrelatedLCTDigi(0, 1, quality, wg, clct.getKeyStrip(), pattern, clct.getBend(), bx, 0, 0, 0, theTrigChamber); - } - else { - // CLCT pattern number - no pattern - unsigned int pattern = 0;//encodePatternGEM(clct.getPattern(), clct.getStripType()); - - // LCT quality number - dummy quality - unsigned int quality = 5;//findQualityGEM(alct, gem); - - // Bunch crossing: get it from cathode LCT if anode LCT is not there. - int bx = gem.bx() + lct_central_bx;; - - // ALCT WG - int wg(0); - - // construct correlated LCT; temporarily assign track number of 0. - return CSCCorrelatedLCTDigi(0, 1, quality, wg, 0, pattern, 0, bx, 0, 0, 0, theTrigChamber); - } -} - - -CSCCorrelatedLCTDigi CSCMotherboardME21GEM::constructLCTsGEM(const CSCALCTDigi& aLCT, const CSCCLCTDigi& cLCT, - bool hasPad, bool hasCoPad) -{ - // CLCT pattern number - unsigned int pattern = encodePattern(cLCT.getPattern(), cLCT.getStripType()); - - // LCT quality number - unsigned int quality = findQualityGEM(aLCT, cLCT, hasPad, hasCoPad); - - // Bunch crossing: get it from cathode LCT if anode LCT is not there. - int bx = aLCT.isValid() ? aLCT.getBX() : cLCT.getBX(); - - // construct correlated LCT; temporarily assign track number of 0. - int trknmb = 0; - CSCCorrelatedLCTDigi thisLCT(trknmb, 1, quality, aLCT.getKeyWG(), - cLCT.getKeyStrip(), pattern, cLCT.getBend(), - bx, 0, 0, 0, theTrigChamber); - return thisLCT; -} - - -unsigned int CSCMotherboardME21GEM::findQualityGEM(const CSCALCTDigi& aLCT, const CSCCLCTDigi& cLCT, - bool hasPad, bool hasCoPad) -{ - - /* - Same LCT quality definition as standard LCTs - c4 takes GEMs into account!!! - */ - - unsigned int quality = 0; - - if (!isTMB07) { - bool isDistrip = (cLCT.getStripType() == 0); - - if (aLCT.isValid() && !(cLCT.isValid())) { // no CLCT - if (aLCT.getAccelerator()) {quality = 1;} - else {quality = 3;} - } - else if (!(aLCT.isValid()) && cLCT.isValid()) { // no ALCT - if (isDistrip) {quality = 4;} - else {quality = 5;} - } - else if (aLCT.isValid() && cLCT.isValid()) { // both ALCT and CLCT - if (aLCT.getAccelerator()) {quality = 2;} // accelerator muon - else { // collision muon - // CLCT quality is, in fact, the number of layers hit, so subtract 3 - // to get quality analogous to ALCT one. - int sumQual = aLCT.getQuality() + (cLCT.getQuality()-3); - if (sumQual < 1 || sumQual > 6) { - if (infoV >= 0) edm::LogWarning("L1CSCTPEmulatorWrongValues") - << "+++ findQuality: sumQual = " << sumQual << "+++ \n"; - } - if (isDistrip) { // distrip pattern - if (sumQual == 2) {quality = 6;} - else if (sumQual == 3) {quality = 7;} - else if (sumQual == 4) {quality = 8;} - else if (sumQual == 5) {quality = 9;} - else if (sumQual == 6) {quality = 10;} - } - else { // halfstrip pattern - if (sumQual == 2) {quality = 11;} - else if (sumQual == 3) {quality = 12;} - else if (sumQual == 4) {quality = 13;} - else if (sumQual == 5) {quality = 14;} - else if (sumQual == 6) {quality = 15;} - } - } - } - } -#ifdef OLD - else { - // Temporary definition, used until July 2008. - // First if statement is fictitious, just to help the CSC TF emulator - // handle such cases (one needs to make sure they will be accounted for - // in the new quality definition. - if (!(aLCT.isValid()) || !(cLCT.isValid())) { - if (aLCT.isValid() && !(cLCT.isValid())) quality = 1; // no CLCT - else if (!(aLCT.isValid()) && cLCT.isValid()) quality = 2; // no ALCT - else quality = 0; // both absent; should never happen. - } - else { - // Sum of ALCT and CLCT quality bits. CLCT quality is, in fact, the - // number of layers hit, so subtract 3 to put it to the same footing as - // the ALCT quality. - int sumQual = aLCT.getQuality() + (cLCT.getQuality()-3); - if (sumQual < 1 || sumQual > 6) { - if (infoV >= 0) edm::LogWarning("L1CSCTPEmulatorWrongValues") - << "+++ findQuality: Unexpected sumQual = " << sumQual << "+++\n"; - } - - // LCT quality is basically the sum of ALCT and CLCT qualities, but split - // in two groups depending on the CLCT pattern id (higher quality for - // straighter patterns). - int offset = 0; - if (cLCT.getPattern() <= 7) offset = 4; - else offset = 9; - quality = offset + sumQual; - } - } -#endif - else { - // 2008 definition. - if (!(aLCT.isValid()) || !(cLCT.isValid())) { - if (aLCT.isValid() && !(cLCT.isValid())) quality = 1; // no CLCT - else if (!(aLCT.isValid()) && cLCT.isValid()) quality = 2; // no ALCT - else quality = 0; // both absent; should never happen. - } - else { - const int pattern(cLCT.getPattern()); - if (pattern == 1) quality = 3; // layer-trigger in CLCT - else { - // ALCT quality is the number of layers hit minus 3. - // CLCT quality is the number of layers hit. - int n_gem = 0; - if (hasPad) n_gem = 1; - if (hasCoPad) n_gem = 2; - const bool a4((aLCT.getQuality() >= 1) or (aLCT.getQuality() >= 0 and n_gem >=1)); - const bool c4((cLCT.getQuality() >= 4) or (cLCT.getQuality() >= 3 and n_gem>=1)); - // quality = 4; "reserved for low-quality muons in future" - if (!a4 && !c4) quality = 5; // marginal anode and cathode - else if ( a4 && !c4) quality = 6; // HQ anode, but marginal cathode - else if (!a4 && c4) quality = 7; // HQ cathode, but marginal anode - else if ( a4 && c4) { - if (aLCT.getAccelerator()) quality = 8; // HQ muon, but accel ALCT - else { - // quality = 9; "reserved for HQ muons with future patterns - // quality = 10; "reserved for HQ muons with future patterns - if (pattern == 2 || pattern == 3) quality = 11; - else if (pattern == 4 || pattern == 5) quality = 12; - else if (pattern == 6 || pattern == 7) quality = 13; - else if (pattern == 8 || pattern == 9) quality = 14; - else if (pattern == 10) quality = 15; - else { - if (infoV >= 0) edm::LogWarning("L1CSCTPEmulatorWrongValues") - << "+++ findQuality: Unexpected CLCT pattern id = " - << pattern << "+++\n"; - } - } - } - } - } - } - return quality; -} - - -void CSCMotherboardME21GEM::buildCoincidencePads(const GEMCSCPadDigiCollection* out_pads, GEMCSCPadDigiCollection& out_co_pads) -{ - gemCoPadV.clear(); - - // build coincidences - for (auto det_range = out_pads->begin(); det_range != out_pads->end(); ++det_range) { - const GEMDetId& id = (*det_range).first; - - // build coincidences only in station 2 - if (id.station() != 2 and id.station() != 3) continue; - - // all coincidences detIDs will have layer=1 - if (id.layer() != 1) continue; - - // find the corresponding id with layer=2 - GEMDetId co_id(id.region(), id.ring(), id.station(), 2, id.chamber(), id.roll()); - - auto co_pads_range = out_pads->get(co_id); - // empty range = no possible coincidence pads - if (co_pads_range.first == co_pads_range.second) continue; - - // now let's correlate the pads in two layers of this partition - const auto& pads_range = (*det_range).second; - for (auto p = pads_range.first; p != pads_range.second; ++p) { - for (auto co_p = co_pads_range.first; co_p != co_pads_range.second; ++co_p) { - // check the match in pad - if (std::abs(p->pad() - co_p->pad()) > maxDeltaPadInCoPad_) continue; - // check the match in BX - if (std::abs(p->bx() - co_p->bx()) > maxDeltaBXInCoPad_ ) continue; - - // make a new coincidence pad digi - gemCoPadV.push_back(GEMCSCCoPadDigi(*p,*co_p)); - - // always use layer1 pad's BX as a copad's BX - GEMCSCPadDigi co_pad_digi(p->pad(), p->bx()); - out_co_pads.insertDigi(id, co_pad_digi); - } - } - } -} - - -std::map > -CSCMotherboardME21GEM::createGEMRollEtaLUT(bool isLong) -{ - std::map > result; - - const int st(isLong ? 3 : 2); - // no distinction between even and odd in GE2/1 - auto chamber(gem_g->chamber(GEMDetId(1,1,st,1,1,0))); - if (chamber==nullptr) return result; - - for(int i = 1; i<= chamber->nEtaPartitions(); ++i){ - auto roll(chamber->etaPartition(i)); - if (roll==nullptr) continue; - const float half_striplength(roll->specs()->specificTopology().stripLength()/2.); - const LocalPoint lp_top(0., half_striplength, 0.); - const LocalPoint lp_bottom(0., -half_striplength, 0.); - const GlobalPoint gp_top(roll->toGlobal(lp_top)); - const GlobalPoint gp_bottom(roll->toGlobal(lp_bottom)); - result[i] = std::make_pair(gp_top.eta(), gp_bottom.eta()); - } - return result; -} - -std::map > > -CSCMotherboardME21GEM::retrieveGEMPads(const GEMCSCPadDigiCollection* gemPads, unsigned id, bool iscopad) -{ - int deltaBX(iscopad ? maxDeltaBXCoPad_ : maxDeltaBXPad_); - GEMPads result; - - auto superChamber(gem_g->superChamber(id)); - for (auto ch : superChamber->chambers()) { - for (auto roll : ch->etaPartitions()) { - GEMDetId roll_id(roll->id()); - auto pads_in_det = gemPads->get(roll_id); - for (auto pad = pads_in_det.first; pad != pads_in_det.second; ++pad) { - auto id_pad = std::make_pair(roll_id(), &(*pad)); - const int bx_shifted(lct_central_bx + pad->bx()); - for (int bx = bx_shifted - deltaBX;bx <= bx_shifted + deltaBX; ++bx) { - if (iscopad){ - if(bx != lct_central_bx) continue; - result[bx].push_back(id_pad); - }else{ - result[bx].push_back(id_pad); - } - } - } - } - } - return result; -} - - -void CSCMotherboardME21GEM::printGEMTriggerPads(int bx_start, int bx_stop, bool isShort, bool iscopad) -{ - // pads or copads? - auto thePads(!iscopad ? (isShort ? padsShort_ : padsLong_) : (isShort ? coPadsShort_ : coPadsLong_)); - const bool hasPads(thePads.size()!=0); - - std::cout << "------------------------------------------------------------------------" << std::endl; - bool first = true; - for (int bx = bx_start; bx <= bx_stop; bx++) { - // print only the pads for the central BX - if (bx!=lct_central_bx and iscopad) continue; - std::vector > in_pads = thePads[bx]; - if (first) { - if (!iscopad) std::cout << "* GEM trigger pads: " << std::endl; - else std::cout << "* GEM trigger coincidence pads: " << std::endl; - } - first = false; - if (!iscopad) std::cout << "N(pads) BX " << bx << " : " << in_pads.size() << std::endl; - else std::cout << "N(copads) BX " << bx << " : " << in_pads.size() << std::endl; - if (hasPads){ - for (auto pad : in_pads){ - auto roll_id(GEMDetId(pad.first)); - std::cout << "\tdetId " << pad.first << " " << roll_id << ", pad = " << pad.second->pad() << ", BX = " << pad.second->bx() + 6 << std::endl; - } - } - else - break; - } -} - - -CSCMotherboardME21GEM::GEMPadsBX -CSCMotherboardME21GEM::matchingGEMPads(const CSCCLCTDigi& clct, const GEMPadsBX& pads, bool isCoPad, bool first) -{ - CSCMotherboardME21GEM::GEMPadsBX result; - - // fetch the low and high pad edges for the long superchambers - int deltaPad(isCoPad ? maxDeltaPadCoPad_ : maxDeltaPadPad_); - const int lowPad(cscHsToGemPad_[clct.getKeyStrip()].first); - const int highPad(cscHsToGemPad_[clct.getKeyStrip()].second); - const bool debug(false); - if (debug) std::cout << "lowpad " << lowPad << " highpad " << highPad << " delta pad " << deltaPad <pad()); - if (debug) std::cout << "padRoll " << padRoll << std::endl; - if (std::abs(lowPad - padRoll) <= deltaPad or std::abs(padRoll - highPad) <= deltaPad){ - if (debug) std::cout << "++Matches! " << std::endl; - result.push_back(p); - if (first) return result; - } - } - return result; -} - - -CSCMotherboardME21GEM::GEMPadsBX -CSCMotherboardME21GEM::matchingGEMPads(const CSCALCTDigi& alct, const GEMPadsBX& pads, bool isCoPad, bool first) -{ - CSCMotherboardME21GEM::GEMPadsBX result; - - auto alctRoll(cscWgToGemRollLong_[alct.getKeyWG()]); - const bool debug(false); - if (debug) std::cout << "ALCT keyWG " << alct.getKeyWG() << ", roll " << alctRoll << std::endl; - for (auto p: pads){ - auto padRoll(GEMDetId(p.first).roll()); - if (debug) std::cout << "Candidate ALCT: " << padRoll << std::endl; - if (alctRoll != padRoll) continue; - if (debug) std::cout << "++Matches! " << std::endl; - result.push_back(p); - if (first) return result; - } - return result; -} - - -CSCMotherboardME21GEM::GEMPadsBX -CSCMotherboardME21GEM::matchingGEMPads(const CSCCLCTDigi& clct, const CSCALCTDigi& alct, const GEMPadsBX& pads, - bool isCoPad, bool first) -{ - CSCMotherboardME21GEM::GEMPadsBX result; - - // Fetch all (!) pads matching to ALCTs and CLCTs - auto padsClct(matchingGEMPads(clct, pads, isCoPad, false)); - auto padsAlct(matchingGEMPads(alct, pads, isCoPad, false)); - - const bool debug(false); - if (debug) std::cout << "-----------------------------------------------------------------------"<chamber(theEndcap, theStation, theSector, theSubsector, theTrigChamber); - const CSCDetId csc_id(cscChamber->id()); - const int chamber(csc_id.chamber()); - const bool is_odd(chamber%2==1); - - - if (debug_gem_dphi) std::cout<<"++++++++ matchGEMPads "<< csc_id <<" +++++++++ "<layer(CSCConstants::KEY_CLCT_LAYER)->geometry(); - // LCT::getKeyWG() also starts from 0 - float wire = layer_geo->middleWireOfGroup(lct.getKeyWG() + 1); - - LocalPoint csc_intersect = layer_geo->intersectionOfStripAndWire(fractional_strip, wire); - GlobalPoint csc_gp = csc_g->idToDet(csc_id)->surface().toGlobal(csc_intersect); - - // is LCT located in the high efficiency GEM eta range? - bool gem_fid = ( std::abs(csc_gp.eta()) >= gem_match_min_eta ); - - if (debug_gem_dphi) std::cout<<" lct eta "< zap it - { - if (gem_clear_nomatch_lcts) lct.clear(); - if (debug_gem_dphi) std::cout<<" -- no gem"<second) - { - GEMDetId gem_id(id_pad.first); - LocalPoint gem_lp = gem_g->etaPartition(gem_id)->centreOfPad(id_pad.second->pad()); - GlobalPoint gem_gp = gem_g->idToDet(gem_id)->surface().toGlobal(gem_lp); - float dphi = deltaPhi(csc_gp.phi(), gem_gp.phi()); - float deta = csc_gp.eta() - gem_gp.eta(); - if (debug_gem_dphi) std::cout<<" gem with dphi "<< std::abs(dphi) <<" deta "<< std::abs(deta) <bx(); - } - } - if (gem_matched) - { - if (debug_gem_dphi) std::cout<<" GOT MATCHED GEM!"< lut_pt_vs_dphi_gemcsc[i+1][oddEven]) - iFound = i+1; - } - } - lct.setGEMDPhiBits(iFound); - if (debug_gem_dphi) std::cout<<"found bend angle "< CSCMotherboardME21GEM::readoutCoPads() -{ - return gemCoPadV; -} - - -int CSCMotherboardME21GEM::getRandomWGForGEMRoll(int roll) -{ - boost::container::flat_set wgs; - for (auto p: cscWgToGemRollLong_) - if (p.first == roll) - wgs.insert(p.first); - // return a random one - return *(wgs.begin() + rand() % wgs.size()); -} diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME21GEM.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME21GEM.cc index 5d78c992846c4..7e603c09661bf 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME21GEM.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME21GEM.cc @@ -1020,7 +1020,7 @@ CSCMotherboardME21GEM::createGEMRollEtaLUT(bool isLong) const LocalPoint lp_bottom(0., -half_striplength, 0.); const GlobalPoint gp_top(roll->toGlobal(lp_top)); const GlobalPoint gp_bottom(roll->toGlobal(lp_bottom)); - result[i] = std::make_pair(gp_top.eta(), gp_bottom.eta()); + result[i] = std::make_pair(floorf(gp_top.eta() * 100) / 100, ceilf(gp_bottom.eta() * 100) / 100); } return result; } diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME3141RPC.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME3141RPC.cc index e4aef9aea058f..5effa97c7bb0c 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME3141RPC.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME3141RPC.cc @@ -584,7 +584,7 @@ std::map > CSCMotherboardME3141RPC::createRPCRollLU const LocalPoint lp_bottom(0., -half_striplength, 0.); const GlobalPoint gp_top(roll->toGlobal(lp_top)); const GlobalPoint gp_bottom(roll->toGlobal(lp_bottom)); - result[i] = std::make_pair(std::abs(gp_top.eta()), std::abs(gp_bottom.eta())); + result[i] = std::make_pair(floorf(gp_top.eta() * 100) / 100, ceilf(gp_bottom.eta() * 100) / 100); } return result; } From 90f0011e53dde91868fe5d3b7d092b932ff3d256 Mon Sep 17 00:00:00 2001 From: tahuang1991 Date: Wed, 4 Jun 2014 17:29:08 -0500 Subject: [PATCH 10/11] loosen the matching window when we match ALCT to Pad. updated matching function will also check the corresponding rolls of neighboring wg --- GEMCode | 1 + .../cscTriggerPrimitiveDigisPostLS3_cfi.py | 2 ++ .../src/CSCMotherboardME21GEM.cc | 17 ++++++++++++++--- .../src/CSCMotherboardME21GEM.h | 1 + .../src/CSCMotherboardME3141RPC.cc | 16 ++++++++++++++-- .../src/CSCMotherboardME3141RPC.h | 1 + L1TriggerDPGUpgrade | 1 + 7 files changed, 34 insertions(+), 5 deletions(-) create mode 160000 GEMCode create mode 160000 L1TriggerDPGUpgrade diff --git a/GEMCode b/GEMCode new file mode 160000 index 0000000000000..2c4b4629afaa6 --- /dev/null +++ b/GEMCode @@ -0,0 +1 @@ +Subproject commit 2c4b4629afaa6d0f5e25c16fe17b8a356263fd3d diff --git a/L1Trigger/CSCTriggerPrimitives/python/cscTriggerPrimitiveDigisPostLS3_cfi.py b/L1Trigger/CSCTriggerPrimitives/python/cscTriggerPrimitiveDigisPostLS3_cfi.py index 82105aaa39e45..6c2c67b83415a 100644 --- a/L1Trigger/CSCTriggerPrimitives/python/cscTriggerPrimitiveDigisPostLS3_cfi.py +++ b/L1Trigger/CSCTriggerPrimitives/python/cscTriggerPrimitiveDigisPostLS3_cfi.py @@ -438,6 +438,7 @@ ## matching to pads in case LowQ CLCT maxDeltaBXPad = cms.int32(1), maxDeltaPadPad = cms.int32(2), + maxDeltaWg = cms.int32(1), ## matching to pads in case absent CLCT maxDeltaBXCoPad = cms.int32(0), @@ -496,6 +497,7 @@ ## matching to digis in case LowQ CLCT maxDeltaBXRPC = cms.int32(0), maxDeltaStripRPC = cms.int32(3), + maxDeltaWg = cms.int32(1), ## efficiency recovery switches dropLowQualityCLCTsNoRPCs = cms.bool(True), diff --git a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME21GEM.cc b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME21GEM.cc index 5d78c992846c4..a6792f61ca455 100644 --- a/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME21GEM.cc +++ b/L1Trigger/CSCTriggerPrimitives/src/CSCMotherboardME21GEM.cc @@ -125,6 +125,7 @@ CSCMotherboardME21GEM::CSCMotherboardME21GEM(unsigned endcap, unsigned station, // deltas used to match to GEM pads maxDeltaBXPad_ = me21tmbParams.getParameter("maxDeltaBXPad"); maxDeltaPadPad_ = me21tmbParams.getParameter("maxDeltaPadPad"); + maxDeltaWg_ = me21tmbParams.getParameter("maxDeltaWg"); // deltas used to match to GEM coincidence pads maxDeltaBXCoPad_ = me21tmbParams.getParameter("maxDeltaBXCoPad"); @@ -1113,10 +1114,19 @@ CSCMotherboardME21GEM::GEMPadsBX CSCMotherboardME21GEM::matchingGEMPads(const CSCALCTDigi& alct, const GEMPadsBX& pads, bool isCoPad, bool first) { CSCMotherboardME21GEM::GEMPadsBX result; - - auto alctRoll(cscWgToGemRollLong_[alct.getKeyWG()]); + int Wg = alct.getKeyWG(); + std::vector Rolls; + Rolls.push_back(cscWgToGemRollLong_[Wg]); + if (Wg>=maxDeltaWg_ && cscWgToGemRollLong_[Wg] != cscWgToGemRollLong_[Wg-maxDeltaWg_]) + Rolls.push_back(cscWgToGemRollLong_[Wg-maxDeltaWg_]); + if ((unsigned int)(Wg+maxDeltaWg_)("maxDeltaBXRPC"); maxDeltaStripRPC_ = me3141tmbParams.getParameter("maxDeltaStripRPC"); + maxDeltaWg_ = me3141tmbParams.getParameter("maxDeltaWg"); // use "old" or "new" dataformat for integrated LCTs? useOldLCTDataFormatALCTRPC_ = me3141tmbParams.getParameter("useOldLCTDataFormatALCTRPC"); @@ -672,9 +673,19 @@ CSCMotherboardME3141RPC::matchingRPCDigis(const CSCALCTDigi& alct, const RPCDigi { CSCMotherboardME3141RPC::RPCDigisBX result; - auto alctRoll(cscWgToRpcRoll_[alct.getKeyWG()]); + int Wg = alct.getKeyWG(); + std::vector Rolls; + Rolls.push_back(cscWgToRpcRoll_[Wg]); + if (Wg>=maxDeltaWg_ && cscWgToRpcRoll_[Wg] != cscWgToRpcRoll_[Wg-maxDeltaWg_]) + Rolls.push_back(cscWgToRpcRoll_[Wg-maxDeltaWg_]); + if ((unsigned int)(Wg+maxDeltaWg_) Date: Wed, 4 Jun 2014 18:34:11 -0500 Subject: [PATCH 11/11] delete obsolete files --- GEMCode | 1 - L1TriggerDPGUpgrade | 1 - 2 files changed, 2 deletions(-) delete mode 160000 GEMCode delete mode 160000 L1TriggerDPGUpgrade diff --git a/GEMCode b/GEMCode deleted file mode 160000 index 2c4b4629afaa6..0000000000000 --- a/GEMCode +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 2c4b4629afaa6d0f5e25c16fe17b8a356263fd3d diff --git a/L1TriggerDPGUpgrade b/L1TriggerDPGUpgrade deleted file mode 160000 index 588d7127d8579..0000000000000 --- a/L1TriggerDPGUpgrade +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 588d7127d857928f97fc2a678f7e85dc1b0465a9