From 69296bc73eefaf256288180ac0b3004727edd8cf Mon Sep 17 00:00:00 2001 From: Igor Date: Mon, 10 Nov 2014 23:28:25 +0100 Subject: [PATCH 01/28] initial implementation of QIE8 preamp simulation --- .../HcalAlgos/interface/AbsElectronicODERHS.h | 144 +++++++ .../HcalAlgos/interface/AbsODERHS.h | 18 + .../interface/ConstantStepOdeSolver.h | 184 ++++++++ .../HcalAlgos/interface/DoublePadeDelay.h | 168 ++++++++ .../HcalAlgos/interface/LowPassFilterTiming.h | 13 + .../HcalAlgos/interface/PadeTableODE.h | 31 ++ .../HcalAlgos/interface/QIE8Simulator.h | 181 ++++++++ .../HcalAlgos/interface/ThirdOrderDelayODE.h | 32 ++ .../HcalAlgos/interface/equalADCSignalTime.h | 16 + .../HcalAlgos/src/ConstantStepOdeSolver.cc | 396 ++++++++++++++++++ .../HcalAlgos/src/LowPassFilterTiming.cc | 88 ++++ .../HcalAlgos/src/PadeTableODE.cc | 149 +++++++ .../HcalAlgos/src/QIE8Simulator.cc | 217 ++++++++++ .../HcalAlgos/src/ThirdOrderDelayODE.cc | 35 ++ CondCore/HcalPlugins/src/plugin.cc | 4 + .../interface/HcalInterpolatedPulseCollRcd.h | 26 ++ .../src/HcalInterpolatedPulseCollRcd.cc | 15 + .../HcalObjects/interface/AllObjects.h | 4 + .../HcalObjects/interface/HBHEChannelGroups.h | 94 +++++ .../HcalObjects/interface/HBHELinearMap.h | 91 ++++ .../interface/HcalInterpolatedPulse.h | 11 + .../interface/HcalInterpolatedPulseColl.h | 50 +++ .../HcalObjects/interface/InterpolatedPulse.h | 351 ++++++++++++++++ CondFormats/HcalObjects/src/HBHELinearMap.cc | 150 +++++++ .../src/HcalInterpolatedPulseColl.cc | 25 ++ .../T_EventSetup_HcalInterpolatedPulseColl.cc | 4 + CondFormats/HcalObjects/src/classes.h | 6 + CondFormats/HcalObjects/src/classes_def.xml | 12 + .../plugins/HcalInterpolatedPulseDBModules.cc | 14 + .../test/HcalInterpolatedPulseDBReader_cfg.py | 28 ++ .../test/HcalInterpolatedPulseDBWriter_cfg.py | 50 +++ 31 files changed, 2607 insertions(+) create mode 100644 CalibCalorimetry/HcalAlgos/interface/AbsElectronicODERHS.h create mode 100644 CalibCalorimetry/HcalAlgos/interface/AbsODERHS.h create mode 100644 CalibCalorimetry/HcalAlgos/interface/ConstantStepOdeSolver.h create mode 100644 CalibCalorimetry/HcalAlgos/interface/DoublePadeDelay.h create mode 100644 CalibCalorimetry/HcalAlgos/interface/LowPassFilterTiming.h create mode 100644 CalibCalorimetry/HcalAlgos/interface/PadeTableODE.h create mode 100644 CalibCalorimetry/HcalAlgos/interface/QIE8Simulator.h create mode 100644 CalibCalorimetry/HcalAlgos/interface/ThirdOrderDelayODE.h create mode 100644 CalibCalorimetry/HcalAlgos/interface/equalADCSignalTime.h create mode 100644 CalibCalorimetry/HcalAlgos/src/ConstantStepOdeSolver.cc create mode 100644 CalibCalorimetry/HcalAlgos/src/LowPassFilterTiming.cc create mode 100644 CalibCalorimetry/HcalAlgos/src/PadeTableODE.cc create mode 100644 CalibCalorimetry/HcalAlgos/src/QIE8Simulator.cc create mode 100644 CalibCalorimetry/HcalAlgos/src/ThirdOrderDelayODE.cc create mode 100644 CondFormats/DataRecord/interface/HcalInterpolatedPulseCollRcd.h create mode 100644 CondFormats/DataRecord/src/HcalInterpolatedPulseCollRcd.cc create mode 100644 CondFormats/HcalObjects/interface/HBHEChannelGroups.h create mode 100644 CondFormats/HcalObjects/interface/HBHELinearMap.h create mode 100644 CondFormats/HcalObjects/interface/HcalInterpolatedPulse.h create mode 100644 CondFormats/HcalObjects/interface/HcalInterpolatedPulseColl.h create mode 100644 CondFormats/HcalObjects/interface/InterpolatedPulse.h create mode 100644 CondFormats/HcalObjects/src/HBHELinearMap.cc create mode 100644 CondFormats/HcalObjects/src/HcalInterpolatedPulseColl.cc create mode 100644 CondFormats/HcalObjects/src/T_EventSetup_HcalInterpolatedPulseColl.cc create mode 100644 CondTools/Hcal/plugins/HcalInterpolatedPulseDBModules.cc create mode 100644 CondTools/Hcal/test/HcalInterpolatedPulseDBReader_cfg.py create mode 100644 CondTools/Hcal/test/HcalInterpolatedPulseDBWriter_cfg.py diff --git a/CalibCalorimetry/HcalAlgos/interface/AbsElectronicODERHS.h b/CalibCalorimetry/HcalAlgos/interface/AbsElectronicODERHS.h new file mode 100644 index 0000000000000..1668cde504785 --- /dev/null +++ b/CalibCalorimetry/HcalAlgos/interface/AbsElectronicODERHS.h @@ -0,0 +1,144 @@ +#ifndef CalibCalorimetry_HcalAlgos_AbsElectronicODERHS_h_ +#define CalibCalorimetry_HcalAlgos_AbsElectronicODERHS_h_ + +#include +#include +#include + +#include "CalibCalorimetry/HcalAlgos/interface/AbsODERHS.h" +#include "CondFormats/HcalObjects/interface/HcalInterpolatedPulse.h" + +// +// Modeling of electronic circuits always involves an input pulse that +// determines the circuit output. This class adds an input pulse to +// AbsODERHS and establishes a uniform interface to circuit parameters. +// +class AbsElectronicODERHS : public AbsODERHS +{ +public: + static const unsigned invalidNode = UINT_MAX - 1U; + + inline AbsElectronicODERHS() : initialized_(false), allSet_(false) {} + + inline explicit AbsElectronicODERHS(const HcalInterpolatedPulse& pulse) + : inputPulse_(pulse) {} + + inline virtual ~AbsElectronicODERHS() {} + + inline const HcalInterpolatedPulse& inputPulse() const {return inputPulse_;} + + inline HcalInterpolatedPulse& inputPulse() {return inputPulse_;} + + template + inline void setInputPulse(const Pulse& pulse) {inputPulse_ = pulse;} + + // The following methods must be overriden by derived classes. + // Total number of nodes included in the simulation: + virtual unsigned numberOfNodes() const = 0; + + // The node which counts as "output" (preamp output in case + // of QIE8, which is not necessarily the node which accumulates + // the charge): + virtual unsigned outputNode() const = 0; + + // The node which counts as "control". If this method returns + // "invalidNode" then there is no such node in the circuit. + virtual unsigned controlNode() const {return invalidNode;} + + // The number of simulation parameters: + virtual unsigned nParameters() const = 0; + + // Check if all parameters have been set + inline bool allParametersSet() const + { + // Raise "allSet_" flag if all parameters have been set + if (!allSet_) + { + const unsigned nExpected = this->nParameters(); + if (nExpected) + { + if (paramMask_.size() != nExpected) + return false; + unsigned count = 0; + const unsigned char* mask = ¶mMask_[0]; + for (unsigned i=0; i& getAllParameters() const + { + if (!allParametersSet()) throw cms::Exception( + "In AbsElectronicODERHS::getAllParameters: " + "some parameter values were not established yet"); + return params_; + } + + inline void setLeadingParameters(const double* values, const unsigned len) + { + if (len) + { + assert(values); + if (!initialized_) + initialize(); + const unsigned sz = params_.size(); + const unsigned imax = std::min(sz, len); + for (unsigned i=0; i& values) + { + if (!values.empty()) + setLeadingParameters(&values[0], values.size()); + } + +protected: + HcalInterpolatedPulse inputPulse_; + std::vector params_; + +private: + std::vector paramMask_; + bool initialized_; + mutable bool allSet_; + + inline void initialize() + { + const unsigned nExpected = this->nParameters(); + if (nExpected) + { + params_.resize(nExpected); + paramMask_.resize(nExpected); + for (unsigned i=0; i +#include +#include "FWCore/Utilities/interface/Exception.h" + +#include "CalibCalorimetry/HcalAlgos/interface/AbsODERHS.h" + +// +// ODE solver with a constant time step. The derived classes are supposed +// to implement concrete ODE solving algorithms (Runge-Kutta, etc). +// +class ConstantStepOdeSolver +{ +public: + inline ConstantStepOdeSolver() + : rhs_(0), dt_(0.0), dim_(0), runLen_(0), lastIntegrated_(0) {} + + inline ConstantStepOdeSolver(const AbsODERHS& rhs) : + rhs_(0), dt_(0.0), dim_(0), runLen_(0), lastIntegrated_(0) + { + rhs_ = rhs.clone(); + } + + // The copy constructor and the assignment operator are explicitly provided + ConstantStepOdeSolver(const ConstantStepOdeSolver& r); + ConstantStepOdeSolver& operator=(const ConstantStepOdeSolver& r); + + inline virtual ~ConstantStepOdeSolver() {delete rhs_;} + + // Access the equation right hand side + inline void setRHS(const AbsODERHS& rhs) + { + delete rhs_; + rhs_ = rhs.clone(); + } + inline const AbsODERHS* getRHS() const {return rhs_;} + inline AbsODERHS* getRHS() {return rhs_;} + + // Inspectors (will be valid after at least one "run" call) + inline unsigned lastDim() const {return dim_;} + inline unsigned lastRunLength() const {return runLen_;} + inline double lastDeltaT() const {return dt_;} + inline double lastMaxT() const {return runLen_ ? dt_*(runLen_-1U) : 0.0;} + + inline double getTime(const unsigned idx) const + { + if (idx >= runLen_) throw cms::Exception( + "In ConstantStepOdeSolver::getTime: index out of range"); + return idx*dt_; + } + + inline double getCoordinate(const unsigned which, const unsigned idx) const + { + if (which >= dim_ || idx >= runLen_) throw cms::Exception( + "In ConstantStepOdeSolver::getCoordinate: index out of range"); + return historyBuffer_[dim_*idx + which]; + } + + // Integrate the node with the given number and get + // the value of the integral at the given history point + double getIntegrated(unsigned which, unsigned idx) const; + + // Truncate some coordinate + void truncateCoordinate(unsigned which, double minValue, double maxValue); + + // Linear interpolation methods will be used in case the "cubic" + // argument is false, and cubic in case it is true + double interpolateCoordinate(unsigned which, double t, + bool cubic = false) const; + + // Interpolate the integrated node + double interpolateIntegrated(unsigned which, double t, + bool cubic = false) const; + + // Get the time of the peak position + double getPeakTime(unsigned which) const; + + // Solve the ODE and remember the history + void run(const double* initialConditions, unsigned lenConditions, + double dt, unsigned nSteps); + + // Set the history from some external source. The size + // of the data array should be at least dim*runLen. + void setHistory(double dt, const double* data, + unsigned dim, unsigned runLen); + + // Write out the history + void writeHistory(std::ostream& os, double dt, bool cubic = false) const; + + // Write out the integrated node + void writeIntegrated(std::ostream& os, unsigned which, + double dt, bool cubic = false) const; + + // The following method must be overriden by derived classes + virtual const char* methodName() const = 0; + +protected: + AbsODERHS* rhs_; + +private: + // The following method must be overriden by derived classes + virtual void step(double t, double dt, + const double* x, unsigned lenX, + double* coordIncrement) const = 0; + + // The following integration corresponds to the cubic + // interpolation of the coordinate + void integrateCoordinate(const unsigned which); + + double dt_; + unsigned dim_; + unsigned runLen_; + unsigned lastIntegrated_; + + std::vector historyBuffer_; + std::vector chargeBuffer_; +}; + + +// Dump the coordinate history as it was collected +inline std::ostream& operator<<(std::ostream& os, + const ConstantStepOdeSolver& s) +{ + s.writeHistory(os, s.lastDeltaT()); + return os; +} + + +// A few concrete ODE solvers +class EulerOdeSolver : public ConstantStepOdeSolver +{ +public: + inline EulerOdeSolver() : ConstantStepOdeSolver() {} + + inline explicit EulerOdeSolver(const AbsODERHS& rhs) + : ConstantStepOdeSolver(rhs) {} + + inline const char* methodName() const {return "Euler";} + +private: + void step(double t, double dt, + const double* x, unsigned lenX, + double* coordIncrement) const; +}; + + +class RK2 : public ConstantStepOdeSolver +{ +public: + inline RK2() : ConstantStepOdeSolver() {} + + inline explicit RK2(const AbsODERHS& rhs) : ConstantStepOdeSolver(rhs) {} + + inline const char* methodName() const {return "2nd order Runge-Kutta";} + +private: + void step(double t, double dt, + const double* x, unsigned lenX, + double* coordIncrement) const; + + mutable std::vector buf_; +}; + + +class RK4 : public ConstantStepOdeSolver +{ +public: + inline RK4() : ConstantStepOdeSolver() {} + + inline explicit RK4(const AbsODERHS& rhs) : ConstantStepOdeSolver(rhs) {} + + inline const char* methodName() const {return "4th order Runge-Kutta";} + +private: + void step(double t, double dt, + const double* x, unsigned lenX, + double* coordIncrement) const; + + mutable std::vector buf_; +}; + +#endif // CalibCalorimetry_HcalAlgos_ConstantStepOdeSolver_h_ diff --git a/CalibCalorimetry/HcalAlgos/interface/DoublePadeDelay.h b/CalibCalorimetry/HcalAlgos/interface/DoublePadeDelay.h new file mode 100644 index 0000000000000..eb02251ae4466 --- /dev/null +++ b/CalibCalorimetry/HcalAlgos/interface/DoublePadeDelay.h @@ -0,0 +1,168 @@ +#ifndef CalibCalorimetry_HcalAlgos_DoublePadeDelay_h_ +#define CalibCalorimetry_HcalAlgos_DoublePadeDelay_h_ + +#include +#include + +#include "CalibCalorimetry/HcalAlgos/interface/AbsElectronicODERHS.h" + +// +// Two differential equations using the Pade delay scheme. The control +// equation and the output equation are coupled only via the timing +// parameter of the output equation (this timing is determined by the +// control output). In this particular model, there is no feedback from +// the output into the control. +// +template +class DoublePadeDelay : public AbsElectronicODERHS +{ +public: + inline DoublePadeDelay(const unsigned padeRow1, const unsigned padeColumn1, + const unsigned padeRow2, const unsigned padeColumn2) + : ode1_(padeRow1, padeColumn1), ode2_(padeRow2, padeColumn2) + { + validate(); + } + + inline DoublePadeDelay(const unsigned padeRow1, const unsigned padeColumn1, + const unsigned padeRow2, const unsigned padeColumn2, + const HcalInterpolatedPulse& pulse) + : AbsElectronicODERHS(pulse), + ode1_(padeRow1, padeColumn1), + ode2_(padeRow2, padeColumn2) + { + validate(); + } + + inline virtual DoublePadeDelay* clone() const + {return new DoublePadeDelay(*this);} + + inline virtual void calc(const double t, + const double* x, const unsigned lenX, + double* derivative) + { + if (!allParametersSet()) throw cms::Exception( + "In DoublePadeDelay::calc: timing and/or ODE parameters not set"); + + // The input signal + const double currentIn = inputPulse_(t); + + // The output signal + const double currentOut = x[outputNode()]; + + // Numbers of parameters used by the member objects + const unsigned npTau1 = tau1_.nParameters(); + const unsigned npOde1 = ode1_.nParameters(); + const unsigned npTau2 = tau2_.nParameters(); + const unsigned npOde2 = ode2_.nParameters(); + + // Parameters for this code. + // Order of parameters in the overall parameter set is: + // parameters for tau1, then for ode1, then tau2, then ode2, + // then parameters of this code. + const double* pstart = ¶ms_[npTau1 + npOde1 + npTau2 + npOde2]; + const double* pars = pstart; + const double ctlGainOut = *pars++; + const double inGainOut = *pars++; + const double outGainOut = *pars++; + assert(thisCodeNumPars == static_cast(pars - pstart)); + + // Save a little bit of time by not calculating the input + // signal derivatives in case they will not be needed + const unsigned row = std::max(ode1_.getPadeRow(), ode2_.getPadeRow()); + const double dIdt = row ? inputPulse_.derivative(t) : 0.0; + const double d2Id2t = row > 1U ? inputPulse_.secondDerivative(t) : 0.0; + + // Set the timing parameters of the control circuit + unsigned firstPar = npTau1 + npOde1; + const double tau2 = tau2_(currentIn, ¶ms_[firstPar], npTau2); + + // Set the ODE parameters for the control circuit + firstPar += npTau2; + if (npOde2) + ode2_.setParameters(¶ms_[firstPar], npOde2); + + // Run the control circuit + const unsigned ctrlNode = controlNode(); + double control; + if (ctrlNode < AbsElectronicODERHS::invalidNode) + { + // The control circuit solves an ODE + control = x[ctrlNode]; + ode2_.calculate(tau2, currentIn, dIdt, d2Id2t, + x, lenX, ctrlNode, derivative); + } + else + { + // The control circuit does not solve an ODE. + // Instead, it drives its output directly. + ode2_.calculate(tau2, currentIn, dIdt, d2Id2t, + 0, 0U, 0U, &control); + } + + // Timing parameter for the output circuit (the preamp) + const double vtau = ctlGainOut*control + + inGainOut*currentIn + + outGainOut*currentOut; + const double tau = tau1_(vtau, ¶ms_[0], npTau1); + + // ODE parameters for the output circuit + if (npOde1) + ode1_.setParameters(¶ms_[npTau1], npOde1); + + // Run the output circuit + ode1_.calculate(tau, currentIn, dIdt, d2Id2t, x, lenX, 0U, derivative); + } + + inline unsigned numberOfNodes() const + {return ode1_.getPadeColumn() + ode2_.getPadeColumn();} + + inline unsigned nParameters() const + { + const unsigned npTau1 = tau1_.nParameters(); + const unsigned npOde1 = ode1_.nParameters(); + const unsigned npTau2 = tau2_.nParameters(); + const unsigned npOde2 = ode2_.nParameters(); + return npTau1 + npOde1 + npTau2 + npOde2 + thisCodeNumPars; + } + + inline unsigned outputNode() const {return 0U;} + + // The second ODE is the one for control. It's output node + // is the control node. + inline unsigned controlNode() const + { + if (ode2_.getPadeColumn()) + // ode2 has a real output node + return ode1_.getPadeColumn(); + else + // ode2 does not have a real output node + return AbsElectronicODERHS::invalidNode; + } + +private: + static const unsigned thisCodeNumPars = 3U; + + inline void validate() const + { + // Basically, we need to avoid the situation in which + // we need to solve the differential equation for the control + // circuit but do not need to solve the differential equation + // for the preamp. It this case we will not have a good way + // to pass the preamp output to the simulator. The simplest + // way to ensure correctness of the whole procedure is to require + // that the preamp must always be modeled by an ODE. Indeed, + // one will almost surely need to represent it by at least + // a low-pass filter. + if (!ode1_.getPadeColumn()) throw cms::Exception( + "In DoublePadeDelay::validate: the output " + "circuit must be modeled by an ODE"); + } + + ODE1 ode1_; + ODE2 ode2_; + DelayTimeModel1 tau1_; + DelayTimeModel2 tau2_; +}; + +#endif // CalibCalorimetry_HcalAlgos_DoublePadeDelay_h_ diff --git a/CalibCalorimetry/HcalAlgos/interface/LowPassFilterTiming.h b/CalibCalorimetry/HcalAlgos/interface/LowPassFilterTiming.h new file mode 100644 index 0000000000000..7fab52e7e8b4d --- /dev/null +++ b/CalibCalorimetry/HcalAlgos/interface/LowPassFilterTiming.h @@ -0,0 +1,13 @@ +#ifndef CalibCalorimetry_HcalAlgos_LowPassFilterTiming_h_ +#define CalibCalorimetry_HcalAlgos_LowPassFilterTiming_h_ + +class LowPassFilterTiming +{ +public: + unsigned nParameters() const; + + double operator()(double currentIn, + const double* params, unsigned nParams) const; +}; + +#endif // CalibCalorimetry_HcalAlgos_LowPassFilterTiming_h_ diff --git a/CalibCalorimetry/HcalAlgos/interface/PadeTableODE.h b/CalibCalorimetry/HcalAlgos/interface/PadeTableODE.h new file mode 100644 index 0000000000000..533c656afadf8 --- /dev/null +++ b/CalibCalorimetry/HcalAlgos/interface/PadeTableODE.h @@ -0,0 +1,31 @@ +#ifndef CalibCalorimetry_HcalAlgos_PadeTableODE_h_ +#define CalibCalorimetry_HcalAlgos_PadeTableODE_h_ + +// +// Differential equations are built using the delay formula +// I_out(s) = I_in(s) exp(-tau s), where I_out(s), etc. are the Laplace +// transforms. exp(-tau s) is then represented by fractions according +// to the Pade table. See http://en.wikipedia.org/wiki/Pade_table and +// replace z by (-tau s). +// +class PadeTableODE +{ +public: + PadeTableODE(unsigned padeRow, unsigned padeColumn); + + void calculate(double tau, double inputCurrent, + double dIdt, double d2Id2t, + const double* x, unsigned lenX, + unsigned firstNode, double* derivative) const; + + inline unsigned getPadeRow() const {return row_;} + inline unsigned getPadeColumn() const {return col_;} + inline unsigned nParameters() const {return 0U;} + void setParameters(const double* pars, unsigned nPars); + +private: + unsigned row_; + unsigned col_; +}; + +#endif // CalibCalorimetry_HcalAlgos_PadeTableODE_h_ diff --git a/CalibCalorimetry/HcalAlgos/interface/QIE8Simulator.h b/CalibCalorimetry/HcalAlgos/interface/QIE8Simulator.h new file mode 100644 index 0000000000000..a7eb9089094c3 --- /dev/null +++ b/CalibCalorimetry/HcalAlgos/interface/QIE8Simulator.h @@ -0,0 +1,181 @@ +#ifndef CalibCalorimetry_HcalAlgos_QIE8Simulator_h_ +#define CalibCalorimetry_HcalAlgos_QIE8Simulator_h_ + +#include "CalibCalorimetry/HcalAlgos/interface/ConstantStepOdeSolver.h" +#include "CalibCalorimetry/HcalAlgos/interface/AbsElectronicODERHS.h" + +// +// This class is needed mostly in order to represent the charge +// to ADC conversion inside the QIE8 chip +// +class QIE8Simulator +{ +public: + static const unsigned maxlen = HcalInterpolatedPulse::maxlen; + + // In case the default constructor is used, "setRHS" method must be + // called before running the simulation + QIE8Simulator(); + + // Constructor which includes a proper model + QIE8Simulator(const AbsElectronicODERHS& model, + unsigned chargeNode, + bool interpolateCubic = false, + double preampOutputCut = -1.0e100, + double inputGain = 1.0, + double outputGain = 1.0); + + void setRHS(const AbsElectronicODERHS& rhs, unsigned chargeNode, + bool interpolateCubic=false); + + inline const AbsElectronicODERHS& getRHS() const + { + const AbsODERHS* ptr = solver_.getRHS(); + if (!ptr) throw cms::Exception( + "In QIE8Simulator::getRHS: RHS is not set"); + return *(static_cast(ptr)); + } + + // Simple inspectors + inline double getInputGain() const {return inputGain_;} + inline double getOutputGain() const {return outputGain_;} + inline unsigned long getRunCount() const {return runCount_;} + inline double getPreampOutputCut() const {return preampOutputCut_;} + + // Examine preamp model parameters + inline unsigned nParameters() const + {return getRHS().nParameters();} + inline double getParameter(const unsigned which) const + {return getRHS().getParameter(which);} + + // Set gains + inline void setInputGain(const double g) {inputGain_ = g; validateGain();} + inline void setOutputGain(const double g) {outputGain_ = g; validateGain();} + + // Set preamp initial conditions + void setInitialConditions(const double* values, const unsigned len); + void zeroInitialConditions(); + + // Set preamp model parameters + inline void setParameter(const unsigned which, const double p) + {modifiableRHS().setParameter(which, p);} + inline void setLeadingParameters(const double* values, const unsigned len) + {modifiableRHS().setLeadingParameters(values, len);} + + // Set the minimum value for the preamp output + inline void setPreampOutputCut(const double p) + {preampOutputCut_ = p;} + + // Set the input pulse + template + inline void setInputSignal(const Signal& inputSignal) + { + modifiableRHS().setInputPulse(inputSignal); + modifiableRHS().inputPulse() *= inputGain_; + } + + // Get the input pulse + inline const HcalInterpolatedPulse& getInputSignal() const + {return getRHS().inputPulse();} + + // Set the input pulse data. This will not modify + // signal begin and end times. + template + inline void setInputShape(const Real* values, const unsigned len) + { + modifiableRHS().inputPulse().setShape(values, len); + modifiableRHS().inputPulse() *= inputGain_; + } + + // Scale the input pulse by some constant factor + inline void scaleInputSignal(const double s) + {modifiableRHS().inputPulse() *= s;} + + // Manipulate input pulse amplidude + inline double getInputAmplitude() const + {return getRHS().inputPulse().getPeakValue()/inputGain_;} + + inline void setInputAmplitude(const double a) + {modifiableRHS().inputPulse().setPeakValue(a*inputGain_);} + + // Manipulate input pulse total charge + inline double getInputIntegral() const + {return getRHS().inputPulse().getIntegral()/inputGain_;} + + inline void setInputIntegral(const double d) + {modifiableRHS().inputPulse().setIntegral(d*inputGain_);} + + // Manipulate input pulse timing + inline double getInputStartTime() const + {return getRHS().inputPulse().getStartTime();} + + inline void setInputStartTime(const double newStartTime) + {modifiableRHS().inputPulse().setStartTime(newStartTime);} + + // Run the simulation. Parameters are as follows: + // + // dt -- Simulation time step. + // + // tstop -- At what time to stop the simulation. The actual + // stopping time will be the smaller of this parameter and + // dt*(maxlen - 1). The simulation always starts at t = 0. + // + // tDigitize -- When to start producing ADC counts. This argument + // must be non-negative. + // + // TS, lenTS -- Array (and its length) where ADC counts will be + // placed on exit. + // + // This method returns the number of "good" ADC time slices -- the + // ones that completely covered by the simulation interval. + // + unsigned run(double dt, double tstop, + double tDigitize, double* TS, unsigned lenTS); + + // Inspect simulation results + double lastStopTime() const; + double totalIntegratedCharge(double t) const; + double preampPeakTime() const; + + // The following methods with simply return 0.0 in case + // there are no corresponding nodes in the circuit + double preampOutput(double t) const; + double controlOutput(double t) const; + + // Time slice width in nanoseconds + static inline double adcTSWidth() {return 25.0;} + +private: + inline AbsElectronicODERHS& modifiableRHS() + { + AbsODERHS* ptr = solver_.getRHS(); + if (!ptr) throw cms::Exception( + "In QIE8Simulator::modifiableRHS: no RHS"); + return *(static_cast(ptr)); + } + + inline double getCharge(const double t) const + { + double q; + if (integrateToGetCharge_) + q = solver_.interpolateIntegrated(chargeNode_, t, useCubic_); + else + q = solver_.interpolateCoordinate(chargeNode_, t, useCubic_); + return q; + } + + void validateGain() const; + + RK4 solver_; + std::vector initialConditions_; + std::vector historyBuffer_; + double preampOutputCut_; + double inputGain_; + double outputGain_; + unsigned long runCount_; + unsigned chargeNode_; + bool integrateToGetCharge_; + bool useCubic_; +}; + +#endif // CalibCalorimetry_HcalAlgos_QIE8Simulator_h_ diff --git a/CalibCalorimetry/HcalAlgos/interface/ThirdOrderDelayODE.h b/CalibCalorimetry/HcalAlgos/interface/ThirdOrderDelayODE.h new file mode 100644 index 0000000000000..5d8096fa84d89 --- /dev/null +++ b/CalibCalorimetry/HcalAlgos/interface/ThirdOrderDelayODE.h @@ -0,0 +1,32 @@ +#ifndef CalibCalorimetry_HcalAlgos_ThirdOrderDelayODE_h_ +#define CalibCalorimetry_HcalAlgos_ThirdOrderDelayODE_h_ + +// +// Equation a/6*tau^3*V_out''' + b/2*tau^2*V_out'' + c*tau*V_out' + V_out = V_in, +// with parameters "a", "b", and "c". a = 1, b = 1, c = 1 corresponds to the +// Pade table delay equation with row = 0 and column = 3. +// +class ThirdOrderDelayODE +{ +public: + inline ThirdOrderDelayODE(unsigned /* r */, unsigned /* c */) : a_(1.0) {} + + void calculate(double tau, double inputCurrent, + double dIdt, double d2Id2t, + const double* x, unsigned lenX, + unsigned firstNode, double* derivative) const; + + inline unsigned getPadeRow() const {return 0U;} + inline unsigned getPadeColumn() const {return 3U;} + inline unsigned nParameters() const {return 3U;} + + // The parameters should be set to the logs of their actual values + void setParameters(const double* pars, unsigned nPars); + +private: + double a_; + double b_; + double c_; +}; + +#endif // CalibCalorimetry_HcalAlgos_ThirdOrderDelayODE_h_ diff --git a/CalibCalorimetry/HcalAlgos/interface/equalADCSignalTime.h b/CalibCalorimetry/HcalAlgos/interface/equalADCSignalTime.h new file mode 100644 index 0000000000000..baa88e325b8ee --- /dev/null +++ b/CalibCalorimetry/HcalAlgos/interface/equalADCSignalTime.h @@ -0,0 +1,16 @@ +#ifndef CalibCalorimetry_HcalAlgos_equalADCSignalTime_h_ +#define CalibCalorimetry_HcalAlgos_equalADCSignalTime_h_ + +class QIE8Simulator; + +// +// Determine the start time of the simulator input signal which +// produces equal ADC counts in time slices N and N+1. If the start +// time is set to "ttry" then ADC[N] should be larger than ADC[N+1]. +// If the start time is set to "ttry"+25 then ADC[N] should be smaller +// than ADC[N+1]. Note that N should be positive. +// +double equalADCSignalTime(QIE8Simulator& sim, double dt, + double tDigitize, unsigned N, double ttry); + +#endif // CalibCalorimetry_HcalAlgos_equalADCSignalTime_h_ diff --git a/CalibCalorimetry/HcalAlgos/src/ConstantStepOdeSolver.cc b/CalibCalorimetry/HcalAlgos/src/ConstantStepOdeSolver.cc new file mode 100644 index 0000000000000..820953232d8b9 --- /dev/null +++ b/CalibCalorimetry/HcalAlgos/src/ConstantStepOdeSolver.cc @@ -0,0 +1,396 @@ +#include + +#include "CalibCalorimetry/HcalAlgos/interface/ConstantStepOdeSolver.h" + +inline static double interpolateLinear(const double x, const double f0, + const double f1) +{ + return f0*(1.0 - x) + f1*x; +} + +double ConstantStepOdeSolver::getPeakTime(const unsigned which) const +{ + if (which >= dim_) throw cms::Exception( + "In ConstantStepOdeSolver::getPeakTime: index out of range"); + if (runLen_ < 3) throw cms::Exception( + "In ConstantStepOdeSolver::getPeakTime: not enough data"); + + const double* hbuf = &historyBuffer_[which]; + double maxval = hbuf[0]; + unsigned maxind = 0; + for (unsigned i=1; i maxval) + { + maxval = hbuf[dim_*i]; + maxind = i; + } + if (maxind == 0U) + return 0.0; + if (maxind == runLen_-1U) + return dt_*maxind; + const double l = hbuf[dim_*(maxind - 1U)]; + const double r = hbuf[dim_*(maxind + 1U)]; + if (l < maxval || r < maxval) + return dt_*(maxind + (l - r)/2.0/(l + r - 2.0*maxval)); + else + return dt_*maxind; +} + +double ConstantStepOdeSolver::getIntegrated( + const unsigned which, const unsigned idx) const +{ + if (which >= dim_ || idx >= runLen_) throw cms::Exception( + "In ConstantStepOdeSolver::getIntegrated: index out of range"); + if (lastIntegrated_ != which) + (const_cast(this))->integrateCoordinate(which); + return chargeBuffer_[idx]; +} + +void ConstantStepOdeSolver::integrateCoordinate(const unsigned which) +{ + if (runLen_ < 4) throw cms::Exception( + "In ConstantStepOdeSolver::integrateCoordinate: not enough data"); + if (chargeBuffer_.size() < runLen_) + chargeBuffer_.resize(runLen_); + double* integ = &chargeBuffer_[0]; + const double* coord = &historyBuffer_[which]; + + integ[0] = 0.0; + integ[1] = coord[dim_*0]*(3.0/8.0) + + coord[dim_*1]*(19.0/24.0) + + coord[dim_*2]*(-5.0/24.0) + + coord[dim_*3]*(1.0/24.0); + long double sum = integ[1]; + const unsigned rlenm1 = runLen_ - 1U; + for (unsigned i=2; imethodName() << '\n'; + if (dim_ && runLen_) + { + if (dt == dt_) + { + for (unsigned ipt=0; ipt tmax) + break; + os << t; + for (unsigned which=0; whichmethodName() << '\n'; + if (dim_ && runLen_) + { + if (dt == dt_) + { + for (unsigned ipt=0; ipt tmax) + break; + os << t << ' ' << interpolateIntegrated(which, t, cubic) << '\n'; + } + } + } +} + +ConstantStepOdeSolver::ConstantStepOdeSolver(const ConstantStepOdeSolver& r) + : rhs_(0), + dt_(r.dt_), + dim_(r.dim_), + runLen_(r.runLen_), + lastIntegrated_(r.lastIntegrated_), + historyBuffer_(r.historyBuffer_), + chargeBuffer_(r.chargeBuffer_) +{ + if (r.rhs_) + rhs_ = r.rhs_->clone(); +} + +ConstantStepOdeSolver& ConstantStepOdeSolver::operator=( + const ConstantStepOdeSolver& r) +{ + if (this != &r) + { + delete rhs_; rhs_ = 0; + dt_ = r.dt_; + dim_ = r.dim_; + runLen_ = r.runLen_; + lastIntegrated_ = r.lastIntegrated_; + historyBuffer_ = r.historyBuffer_; + chargeBuffer_ = r.chargeBuffer_; + if (r.rhs_) + rhs_ = r.rhs_->clone(); + } + return *this; +} + +void ConstantStepOdeSolver::truncateCoordinate(const unsigned which, + const double minValue, + const double maxValue) +{ + if (which >= dim_) throw cms::Exception( + "In ConstantStepOdeSolver::truncateCoordinate: index out of range"); + if (minValue > maxValue) throw cms::Exception( + "In ConstantStepOdeSolver::truncateCoordinate: invalid truncation range"); + + double* buf = &historyBuffer_[which]; + for (unsigned i=0; i maxValue) + buf[dim_*i] = maxValue; + } +} + +double ConstantStepOdeSolver::interpolateCoordinate( + const unsigned which, const double t, const bool cubic) const +{ + if (which >= dim_) throw cms::Exception( + "In ConstantStepOdeSolver::interpolateCoordinate: index out of range"); + if (runLen_ < 2U || (cubic && runLen_ < 4U)) throw cms::Exception( + "In ConstantStepOdeSolver::interpolateCoordinate: not enough data"); + const double maxt = runLen_ ? dt_*(runLen_-1U) : 0.0; + if (t < 0.0 || t > maxt) throw cms::Exception( + "In ConstantStepOdeSolver::interpolateCoordinate: time out of range"); + + const double* arr = &historyBuffer_[0]; + if (t == 0.0) + return arr[which]; + else if (t == maxt) + return arr[which + dim_*(runLen_-1U)]; + + // Translate time into timestep units + const double tSteps = t/dt_; + unsigned nLow = tSteps; + if (nLow >= runLen_ - 1) + nLow = runLen_ - 2; + double x = tSteps - nLow; + + if (cubic) + { + unsigned i0 = 0; + if (nLow == runLen_ - 2) + { + i0 = nLow - 2U; + x += 2.0; + } + else if (nLow) + { + i0 = nLow - 1U; + x += 1.0; + } + const double* base = arr + (which + dim_*i0); + return interpolateLinear(x*(3.0 - x)/2.0, + interpolateLinear(x/3.0, base[0], base[dim_*3]), + interpolateLinear(x-1.0, base[dim_], base[dim_*2])); + } + else + return interpolateLinear(x, arr[which+dim_*nLow], arr[which+dim_*(nLow+1U)]); +} + +double ConstantStepOdeSolver::interpolateIntegrated( + const unsigned which, const double t, const bool cubic) const +{ + if (which >= dim_) throw cms::Exception( + "In ConstantStepOdeSolver::interpolateIntegrated: index out of range"); + if (runLen_ < 2U || (cubic && runLen_ < 4U)) throw cms::Exception( + "In ConstantStepOdeSolver::interpolateIntegrated: not enough data"); + const double maxt = runLen_ ? dt_*(runLen_-1U) : 0.0; + if (t < 0.0 || t > maxt) throw cms::Exception( + "In ConstantStepOdeSolver::interpolateIntegrated: time out of range"); + if (lastIntegrated_ != which) + (const_cast(this))->integrateCoordinate(which); + + const double* buf = &chargeBuffer_[0]; + if (t == 0.0) + return buf[0]; + else if (t == maxt) + return buf[runLen_-1U]; + + // Translate time into timestep units + const double tSteps = t/dt_; + unsigned nLow = tSteps; + if (nLow >= runLen_ - 1) + nLow = runLen_ - 2; + double x = tSteps - nLow; + + if (cubic) + { + unsigned i0 = 0; + if (nLow == runLen_ - 2) + { + i0 = nLow - 2U; + x += 2.0; + } + else if (nLow) + { + i0 = nLow - 1U; + x += 1.0; + } + const double* base = buf + i0; + return interpolateLinear(x*(3.0 - x)/2.0, + interpolateLinear(x/3.0, base[0], base[3]), + interpolateLinear(x-1.0, base[1], base[2])); + } + else + return interpolateLinear(x, buf[nLow], buf[nLow+1U]); +} + +void ConstantStepOdeSolver::setHistory(const double dt, const double* data, + const unsigned dim, const unsigned runLen) +{ + const unsigned len = dim*runLen; + if (!len) + return; + if (dt <= 0.0) throw cms::Exception( + "In ConstantStepOdeSolver::setHistory: can not run backwards in time"); + assert(data); + const unsigned sz = dim*(runLen + 1U); + if (historyBuffer_.size() < sz) + historyBuffer_.resize(sz); + dt_ = dt; + dim_ = dim; + runLen_ = runLen; + lastIntegrated_ = dim_; + double* arr = &historyBuffer_[0]; + for (unsigned i=0; istep(t, dt, arr, lenInitialConditions, stepBuffer); + double* next = arr + lenInitialConditions; + for (unsigned i=0; icalc(t, x, lenX, coordIncrement); + for (unsigned i=0; icalc(t, x, lenX, midpoint); + for (unsigned i=0; icalc(t + halfstep, midpoint, lenX, coordIncrement); + for (unsigned i=0; icalc(t, x, lenX, k1x); + for (unsigned i=0; icalc(t + halfstep, coordIncrement, lenX, k2x); + for (unsigned i=0; icalc(t + halfstep, coordIncrement, lenX, k3x); + for (unsigned i=0; icalc(t + dt, coordIncrement, lenX, k4x); + for (unsigned i=0; i +#include +#include "FWCore/Utilities/interface/Exception.h" + +#include "CalibCalorimetry/HcalAlgos/interface/LowPassFilterTiming.h" + +#define NPARAMETERS 6U + +// +// The formula below join_location - h is aleft*(x_in - join_location) + bleft. +// The formula above join_location + h is aright*(x_in - join_location) + bright. +// Smooth cubic interpolation is performed within +-h of join_location. +// +static double two_joined_lines(const double x_in, const double aleft, + const double bleft, const double aright, + const double bright, const double join_location, + const double h) +{ + assert(h >= 0.0); + const double x = x_in - join_location; + if (x <= -h) + return aleft*x + bleft; + else if (x >= h) + return aright*x + bright; + else + { + const double vleft = -h*aleft + bleft; + const double vright = aright*h + bright; + const double b = (aright - aleft)/4.0/h; + const double d = (vright + vleft - 2*b*h*h)/2.0; + const double a = (d + aright*h - b*h*h - vright)/(2.0*h*h*h); + const double c = -(3*d + aright*h + b*h*h - 3*vright)/(2.0*h); + return ((a*x + b)*x + c)*x + d; + } +} + +unsigned LowPassFilterTiming::nParameters() const +{ + return NPARAMETERS; +} + +// +// The time constant decreases linearly in the space of log(V + Vbias), +// from tauMin+tauDelta when V = 0 to tauMin when V = V1. +// Around log(V1 + Vbias), the curve is joined by a third order polynomial. +// The width of the join is dLogV on both sides of log(V1 + Vbias). +// +// Value "tauDelta" = 0 can be used to create a constant time filter. +// +double LowPassFilterTiming::operator()(const double v, + const double* pars, + const unsigned nParams) const +{ + assert(nParams == NPARAMETERS); + assert(pars); + unsigned ipar = 0; + const double logVbias = pars[ipar++]; + const double logTauMin = pars[ipar++]; + + // The middle of the join region. Not a log actually, + // it is simple in the log space. + const double logV0 = pars[ipar++]; + + // Log of the width of the join region + const double logDelta = pars[ipar++]; + + // Log of the minus negative slope + const double slopeLog = pars[ipar++]; + + // Log of the maximum delay time (cutoff) + const double tauMax = pars[ipar++]; + assert(ipar == NPARAMETERS); + + // What happens for large (in magnitude) negative voltage inputs? + const double Vbias = exp(logVbias); + const double shiftedV = v + Vbias; + if (shiftedV <= 0.0) + return tauMax; + + const double lg = log(shiftedV); + const double delta = exp(logDelta); + const double tauMin = exp(logTauMin); + double result = two_joined_lines(lg, -exp(slopeLog), tauMin, + 0.0, tauMin, logV0, delta); + if (result > tauMax) + result = tauMax; + return result; +} diff --git a/CalibCalorimetry/HcalAlgos/src/PadeTableODE.cc b/CalibCalorimetry/HcalAlgos/src/PadeTableODE.cc new file mode 100644 index 0000000000000..ae52a887c3db1 --- /dev/null +++ b/CalibCalorimetry/HcalAlgos/src/PadeTableODE.cc @@ -0,0 +1,149 @@ +#include +#include "FWCore/Utilities/interface/Exception.h" + +#include "CalibCalorimetry/HcalAlgos/interface/PadeTableODE.h" + +PadeTableODE::PadeTableODE(const unsigned padeRow, const unsigned padeColumn) + : row_(padeRow), + col_(padeColumn) +{ + if (row_ > 2U) throw cms::Exception( + "In PadeTableODE constructor: Pade table row number out of range"); + if (col_ > 3U) throw cms::Exception( + "In PadeTableODE constructor: Pade table column number out of range"); +} + +void PadeTableODE::calculate(const double tau, const double currentIn, + const double dIdt, const double d2Id2t, + const double* x, const unsigned lenX, + const unsigned firstNode, double* derivative) const +{ + // Check input sanity + if (lenX < firstNode + col_) throw cms::Exception( + "In PadeTableODE::calculate: insufficient number of variables"); + if (tau <= 0.0) throw cms::Exception( + "In PadeTableODE::calculate: delay time is not positive"); + if (col_) assert(x); + assert(derivative); + + switch (col_) + { + case 0U: + // Special case: no ODE to solve + derivative[firstNode] = 0.0; + switch (row_) + { + case 2U: + derivative[firstNode] += 0.5*tau*tau*d2Id2t; + case 1U: + derivative[firstNode] -= tau*dIdt; + case 0U: + derivative[firstNode] += currentIn; + break; + + default: + assert(0); + } + break; + + case 1U: + // First order ODE to solve + switch (row_) + { + case 0U: + derivative[firstNode] = (currentIn - x[firstNode])/tau; + break; + + case 1U: + derivative[firstNode] = 2.0*(currentIn - x[firstNode])/tau - dIdt; + break; + + case 2U: + derivative[firstNode] = 3.0*(currentIn - x[firstNode])/tau - + 2.0*dIdt + 0.5*tau*d2Id2t; + break; + + default: + assert(0); + } + break; + + case 2U: + // Second order ODE to solve + derivative[firstNode] = x[firstNode+1]; + switch (row_) + { + case 0U: + derivative[firstNode+1] = + 2.0*(currentIn-x[firstNode]-tau*x[firstNode+1])/tau/tau; + break; + + case 1U: + derivative[firstNode+1] = (6.0*(currentIn - x[firstNode]) - + 2.0*tau*dIdt - + 4.0*tau*x[firstNode+1])/tau/tau; + break; + + case 2U: + derivative[firstNode+1] = + 12.0*(currentIn - x[firstNode])/tau/tau - + 6.0*(x[firstNode+1] + dIdt)/tau + d2Id2t; + break; + + default: + assert(0); + } + break; + + case 3U: + // Third order ODE to solve + derivative[firstNode] = x[firstNode+1]; + derivative[firstNode+1] = x[firstNode+2]; + switch (row_) + { + case 0U: + derivative[firstNode+2] = + 6.0*(currentIn - x[firstNode] - tau*x[firstNode+1] - + 0.5*tau*tau*x[firstNode+2])/tau/tau/tau; + break; + + case 1U: + derivative[firstNode+2] = 24.0/tau/tau/tau*( + currentIn - x[firstNode] - 0.25*tau*dIdt - + 0.75*tau*x[firstNode+1] - 0.25*tau*tau*x[firstNode+2]); + break; + + case 2U: + derivative[firstNode+2] = 60.0/tau/tau/tau*( + currentIn - x[firstNode] - 0.4*tau*dIdt + + 0.05*tau*tau*d2Id2t - 0.6*tau*x[firstNode+1] - + 0.15*tau*tau*x[firstNode+2]); + break; + + default: + assert(0); + } + break; + + default: + // + // In principle, it is possible to proceed a bit further, but + // we will soon encounter difficulties. For example, row 0 and + // column 4 is going to generate a 4th order differential + // equation for which all roots of the characteristic equation + // still have negative real parts. The most "inconvenient" pair + // of roots there is (-0.270556 +- 2.50478 I) which leads + // to oscillations with damping. The characteristic equation + // of 5th and higher order ODEs are going to have roots with + // positive real parts. Unless additional damping is + // purposefully introduced into the system, numerical + // solutions of such equations will just blow up. + // + assert(0); + } +} + +void PadeTableODE::setParameters(const double* /* pars */, const unsigned nPars) +{ + assert(nPars == 0U); +} diff --git a/CalibCalorimetry/HcalAlgos/src/QIE8Simulator.cc b/CalibCalorimetry/HcalAlgos/src/QIE8Simulator.cc new file mode 100644 index 0000000000000..4b1f7f1e1465b --- /dev/null +++ b/CalibCalorimetry/HcalAlgos/src/QIE8Simulator.cc @@ -0,0 +1,217 @@ +#include +#include + +#include "CalibCalorimetry/HcalAlgos/interface/QIE8Simulator.h" + +QIE8Simulator::QIE8Simulator() + : preampOutputCut_(-1.0e100), inputGain_(1.0), + outputGain_(1.0), runCount_(0), + chargeNode_(AbsElectronicODERHS::invalidNode), + integrateToGetCharge_(false), + useCubic_(false) +{ +} + +QIE8Simulator::QIE8Simulator(const AbsElectronicODERHS& model, + const unsigned chargeNode, + const bool interpolateCubic, + const double preampOutputCut, + const double inputGain, + const double outputGain) + : solver_(model), + preampOutputCut_(preampOutputCut), + inputGain_(inputGain), + outputGain_(outputGain), + runCount_(0), + chargeNode_(chargeNode), + useCubic_(interpolateCubic) +{ + if (chargeNode >= AbsElectronicODERHS::invalidNode) + throw cms::Exception( + "In QIE8Simulator constructor: invalid charge collection node"); + integrateToGetCharge_ = chargeNode == model.outputNode(); + validateGain(); + zeroInitialConditions(); +} + +unsigned QIE8Simulator::run(const double dt, const double tstop, + const double tDigitize, + double* TS, const unsigned lenTS) +{ + if (chargeNode_ >= AbsElectronicODERHS::invalidNode) + throw cms::Exception( + "In QIE8Simulator::run: preamp model is not set"); + + // Check arguments for validity + if (dt <= 0.0) throw cms::Exception( + "In QIE8Simulator::run: invalid time step"); + + if (tstop < dt) throw cms::Exception( + "In QIE8Simulator::run: invalid stopping time"); + + if (lenTS && tDigitize < 0.0) throw cms::Exception( + "In QIE8Simulator::run: can't digitize at t < 0"); + + // Determine the number of time steps + const double dsteps = tstop/dt; + unsigned n = dsteps; + if (dsteps != static_cast(n)) + ++n; + if (n >= maxlen) + n = maxlen - 1; + + // Run the simulation + AbsElectronicODERHS& rhs = modifiableRHS(); + const unsigned numNodes = rhs.numberOfNodes(); + if (numNodes) + { + assert(initialConditions_.size() == numNodes); + solver_.run(&initialConditions_[0], numNodes, dt, n); + } + else + { + // Special situation: the simulation does not + // need to solve any ODE. Instead, it will fill + // out the output directly. + if (!(integrateToGetCharge_ && chargeNode_ == 0U)) + throw cms::Exception("In QIE8Simulator::run: " + "invalid mode of operation"); + const unsigned runLen = n + 1U; + if (historyBuffer_.size() < runLen) + historyBuffer_.resize(runLen); + double* hbuf = &historyBuffer_[0]; + for (unsigned istep=0; istep -0.9e100) + solver_.truncateCoordinate(chargeNode_, preampOutputCut_, DBL_MAX); + + // Digitize the accumulated charge + unsigned filled = 0; + if (lenTS) + { + assert(TS); + const double lastTStop = solver_.lastMaxT(); + const double tsWidth = this->adcTSWidth(); + double oldCharge = getCharge(tDigitize); + for (unsigned its=0; its lastTStop) + t1 = lastTStop; + else + ++filled; + const double q = getCharge(t1); + TS[its] = (q - oldCharge)*outputGain_; + oldCharge = q; + } + else + TS[its] = 0.0; + } + } + ++runCount_; + return filled; +} + +double QIE8Simulator::preampOutput(const double t) const +{ + if (!runCount_) throw cms::Exception( + "In QIE8Simulator::preampOutput: please run the simulation first"); + const unsigned preampNode = getRHS().outputNode(); + if (preampNode >= AbsElectronicODERHS::invalidNode) + return 0.0; + else + return outputGain_*solver_.interpolateCoordinate( + preampNode, t, useCubic_); +} + +double QIE8Simulator::controlOutput(const double t) const +{ + if (!runCount_) throw cms::Exception( + "In QIE8Simulator::controlOutput: please run the simulation first"); + const unsigned controlNode = getRHS().controlNode(); + if (controlNode >= AbsElectronicODERHS::invalidNode) + return 0.0; + else + return solver_.interpolateCoordinate(controlNode, t, useCubic_); +} + +double QIE8Simulator::preampPeakTime() const +{ + if (!runCount_) throw cms::Exception( + "In QIE8Simulator::preampPeakTime: please run the simulation first"); + const unsigned preampNode = getRHS().outputNode(); + if (preampNode >= AbsElectronicODERHS::invalidNode) throw cms::Exception( + "In QIE8Simulator::preampPeakTime: no preamp node in the circuit"); + return solver_.getPeakTime(preampNode); +} + +void QIE8Simulator::setInitialConditions( + const double* values, const unsigned sz) +{ + const unsigned nExpected = getRHS().numberOfNodes(); + if (sz != nExpected) throw cms::Exception( + "In QIE8Simulator::setInitialConditions: unexpected number " + "of initial conditions"); + assert(sz == initialConditions_.size()); + if (sz) + { + double* c = &initialConditions_[0]; + for (unsigned i=0; i= AbsElectronicODERHS::invalidNode) + throw cms::Exception( + "In QIE8Simulator::setRHS invalid charge collection node"); + solver_.setRHS(rhs); + chargeNode_ = chargeNode; + integrateToGetCharge_ = chargeNode == rhs.outputNode(); + useCubic_ = useCubicInterpolation; + zeroInitialConditions(); +} + +void QIE8Simulator::zeroInitialConditions() +{ + const unsigned sz = getRHS().numberOfNodes(); + if (initialConditions_.size() != sz) + initialConditions_.resize(sz); + if (sz) + { + double* c = &initialConditions_[0]; + for (unsigned i=0; i +#include +#include "FWCore/Utilities/interface/Exception.h" + +#include "CalibCalorimetry/HcalAlgos/interface/ThirdOrderDelayODE.h" + +void ThirdOrderDelayODE::calculate(const double tau, const double currentIn, + double /* dIdt */, double /* d2Id2t */, + const double* x, const unsigned lenX, + const unsigned firstNode, + double* derivative) const +{ + // Check input sanity + if (lenX < firstNode + 3U) throw cms::Exception( + "In ThirdOrderDelayODE::calculate: insufficient number of variables"); + if (tau <= 0.0) throw cms::Exception( + "In ThirdOrderDelayODE::calculate: delay time is not positive"); + assert(x); + assert(derivative); + + derivative[firstNode] = x[firstNode+1]; + derivative[firstNode+1] = x[firstNode+2]; + derivative[firstNode+2] = 6.0/a_*(currentIn - x[firstNode] - + c_*tau*x[firstNode+1] - + b_/2.0*tau*tau*x[firstNode+2])/tau/tau/tau; +} + +void ThirdOrderDelayODE::setParameters(const double* pars, const unsigned nPars) +{ + assert(nPars == 3U); + assert(pars); + a_ = exp(pars[0]); + b_ = exp(pars[1]); + c_ = exp(pars[2]); +} diff --git a/CondCore/HcalPlugins/src/plugin.cc b/CondCore/HcalPlugins/src/plugin.cc index cf5f545405715..e4c3c0cda922e 100644 --- a/CondCore/HcalPlugins/src/plugin.cc +++ b/CondCore/HcalPlugins/src/plugin.cc @@ -19,6 +19,9 @@ #include "CondFormats/DataRecord/interface/HcalOOTPileupCorrectionMapCollRcd.h" #include "CondFormats/HcalObjects/interface/OOTPileupCorrectionMapColl.h" +#include "CondFormats/DataRecord/interface/HcalInterpolatedPulseCollRcd.h" +#include "CondFormats/HcalObjects/interface/HcalInterpolatedPulseColl.h" + // #include "CondCore/CondDB/interface/Serialization.h" @@ -61,3 +64,4 @@ REGISTER_PLUGIN(HcalTimingParamsRcd,HcalTimingParams); REGISTER_PLUGIN(HcalOOTPileupCorrectionRcd,OOTPileupCorrectionColl); REGISTER_PLUGIN(HcalOOTPileupCompatibilityRcd,OOTPileupCorrectionBuffer); REGISTER_PLUGIN(HcalOOTPileupCorrectionMapCollRcd,OOTPileupCorrectionMapColl); +REGISTER_PLUGIN(HcalInterpolatedPulseCollRcd,HcalInterpolatedPulseColl); diff --git a/CondFormats/DataRecord/interface/HcalInterpolatedPulseCollRcd.h b/CondFormats/DataRecord/interface/HcalInterpolatedPulseCollRcd.h new file mode 100644 index 0000000000000..0a4fdecf5396e --- /dev/null +++ b/CondFormats/DataRecord/interface/HcalInterpolatedPulseCollRcd.h @@ -0,0 +1,26 @@ +#ifndef CondFormats_HcalInterpolatedPulseCollRcd_h +#define CondFormats_HcalInterpolatedPulseCollRcd_h +// -*- C++ -*- +// +// Package: CondFormats/DataRecord +// Class : HcalInterpolatedPulseCollRcd +// +/**\class HcalInterpolatedPulseCollRcd HcalInterpolatedPulseCollRcd.h CondFormats/DataRecord/interface/HcalInterpolatedPulseCollRcd.h + + Description: record for storing HCAL analog pulse shapes + + Usage: + + +*/ +// +// Author: Igor Volobouev +// Created: Mon Nov 10 13:10:28 CST 2014 +// + +#include "FWCore/Framework/interface/EventSetupRecordImplementation.h" + +class HcalInterpolatedPulseCollRcd : public edm::eventsetup::EventSetupRecordImplementation {}; + +#endif // CondFormats_HcalInterpolatedPulseCollRcd_h + diff --git a/CondFormats/DataRecord/src/HcalInterpolatedPulseCollRcd.cc b/CondFormats/DataRecord/src/HcalInterpolatedPulseCollRcd.cc new file mode 100644 index 0000000000000..adc4b577e7306 --- /dev/null +++ b/CondFormats/DataRecord/src/HcalInterpolatedPulseCollRcd.cc @@ -0,0 +1,15 @@ +// -*- C++ -*- +// +// Package: CondFormats/DataRecord +// Class : HcalInterpolatedPulseCollRcd +// +// Implementation: +// [Notes on implementation] +// +// Author: Igor Volobouev +// Created: Mon Nov 10 13:10:28 CST 2014 + +#include "CondFormats/DataRecord/interface/HcalInterpolatedPulseCollRcd.h" +#include "FWCore/Framework/interface/eventsetuprecord_registration_macro.h" + +EVENTSETUP_RECORD_REG(HcalInterpolatedPulseCollRcd); diff --git a/CondFormats/HcalObjects/interface/AllObjects.h b/CondFormats/HcalObjects/interface/AllObjects.h index cc9e5e6a9bcd6..995954fcfacab 100644 --- a/CondFormats/HcalObjects/interface/AllObjects.h +++ b/CondFormats/HcalObjects/interface/AllObjects.h @@ -31,4 +31,8 @@ #include "CondFormats/HcalObjects/interface/HcalFlagHFDigiTimeParams.h" #include "CondFormats/HcalObjects/interface/HcalTimingParams.h" #include "CondFormats/HcalObjects/interface/OOTPileupCorrectionBuffer.h" +#include "CondFormats/HcalObjects/interface/HcalInterpolatedPulse.h" +#include "CondFormats/HcalObjects/interface/HBHEChannelGroups.h" +#include "CondFormats/HcalObjects/interface/HcalInterpolatedPulseColl.h" + #endif diff --git a/CondFormats/HcalObjects/interface/HBHEChannelGroups.h b/CondFormats/HcalObjects/interface/HBHEChannelGroups.h new file mode 100644 index 0000000000000..20db7f0407ed1 --- /dev/null +++ b/CondFormats/HcalObjects/interface/HBHEChannelGroups.h @@ -0,0 +1,94 @@ +#ifndef CondFormats_HcalObjects_HBHEChannelGroups_h_ +#define CondFormats_HcalObjects_HBHEChannelGroups_h_ + +#include "FWCore/Utilities/interface/Exception.h" + +#include "boost/cstdint.hpp" +#include "boost/serialization/access.hpp" +#include "boost/serialization/vector.hpp" + +#include "CondFormats/HcalObjects/interface/HBHELinearMap.h" + +class HBHEChannelGroups +{ +public: + inline HBHEChannelGroups() : group_(HBHELinearMap::ChannelCount, 0U) {} + + // + // Main constructor. It is expected that "len" equals + // HBHELinearMap::ChannelCount and that every element of "data" + // indicates to which group that particular channel should belong. + // + inline HBHEChannelGroups(const unsigned* data, const unsigned len) + : group_(data, data+len) + { + if (!validate()) throw cms::Exception( + "In HBHEChannelGroups constructor: invalid input data"); + } + + // + // Set the group number for the given HBHE linear channel number. + // Linear channel numbers are calculated by HBHELinearMap. + // + inline void setGroup(const unsigned linearChannel, const unsigned groupNum) + {group_.at(linearChannel) = groupNum;} + + // Inspectors + inline unsigned size() const {return group_.size();} + + inline const uint32_t* groupData() const + {return group_.empty() ? 0 : &group_[0];} + + inline unsigned getGroup(const unsigned linearChannel) const + {return group_.at(linearChannel);} + + inline unsigned largestGroupNumber() const + { + unsigned lg = 0; + const unsigned sz = group_.size(); + const uint32_t* dat = sz ? &group_[0] : 0; + for (unsigned i=0; i lg) + lg = dat[i]; + return lg; + } + + // Comparators + inline bool operator==(const HBHEChannelGroups& r) const + {return group_ == r.group_;} + + inline bool operator!=(const HBHEChannelGroups& r) const + {return !(*this == r);} + +private: + std::vector group_; + + inline bool validate() const + { + return group_.size() == HBHELinearMap::ChannelCount; + } + + friend class boost::serialization::access; + + template + inline void save(Archive & ar, const unsigned /* version */) const + { + if (!validate()) throw cms::Exception( + "In HBHEChannelGroups::save: invalid data"); + ar & group_; + } + + template + inline void load(Archive & ar, const unsigned /* version */) + { + ar & group_; + if (!validate()) throw cms::Exception( + "In HBHEChannelGroups::load: invalid data"); + } + + BOOST_SERIALIZATION_SPLIT_MEMBER() +}; + +BOOST_CLASS_VERSION(HBHEChannelGroups, 1) + +#endif // CondFormats_HcalObjects_HBHEChannelGroups_h_ diff --git a/CondFormats/HcalObjects/interface/HBHELinearMap.h b/CondFormats/HcalObjects/interface/HBHELinearMap.h new file mode 100644 index 0000000000000..09dd66d137fcf --- /dev/null +++ b/CondFormats/HcalObjects/interface/HBHELinearMap.h @@ -0,0 +1,91 @@ +#ifndef CondFormats_HcalObjects_HBHELinearMap_h_ +#define CondFormats_HcalObjects_HBHELinearMap_h_ + +// +// Linearize the channel id in the HBHE +// +// I. Volobouev +// September 2014 +// + +#include +#include + +#include "DataFormats/HcalDetId/interface/HcalSubdetector.h" + +class HBHELinearMap +{ +public: + enum {ChannelCount = 5184U}; + + HBHELinearMap(); + + // Mapping from the depth/ieta/iphi triple which uniquely + // identifies an HBHE channel into a linear index, currently + // from 0 to 5183 (inclusive). This linear index should not + // be treated as anything meaningful -- consider it to be + // just a convenient unique key in a database table. + unsigned linearIndex(unsigned depth, int ieta, unsigned iphi) const; + + // Check whether the given triple is a valid depth/ieta/iphi combination + bool isValidTriple(unsigned depth, int ieta, unsigned iphi) const; + + // Inverse mapping, from a linear index into depth/ieta/iphi triple. + // Any of the argument pointers is allowed to be NULL in which case + // the corresponding variable is simply not filled out. + void getChannelTriple(unsigned index, unsigned* depth, + int* ieta, unsigned* iphi) const; + + // The following assumes a valid HBHE depth/ieta combination + static HcalSubdetector getSubdetector(unsigned depth, int ieta); + +private: + class HBHEChannelId + { + public: + inline HBHEChannelId() : depth_(1000U), ieta_(1000), iphi_(1000U) {} + + inline HBHEChannelId(const unsigned i_depth, + const int i_ieta, + const unsigned i_iphi) + : depth_(i_depth), ieta_(i_ieta), iphi_(i_iphi) {} + + // Inspectors + inline unsigned depth() const {return depth_;} + inline int ieta() const {return ieta_;} + inline unsigned iphi() const {return iphi_;} + + inline bool operator<(const HBHEChannelId& r) const + { + if (depth_ < r.depth_) return true; + if (r.depth_ < depth_) return false; + if (ieta_ < r.ieta_) return true; + if (r.ieta_ < ieta_) return false; + return iphi_ < r.iphi_; + } + + inline bool operator==(const HBHEChannelId& r) const + {return depth_ == r.depth_ && ieta_ == r.ieta_ && iphi_ == r.iphi_;} + + inline bool operator!=(const HBHEChannelId& r) const + {return !(*this == r);} + + private: + unsigned depth_; + int ieta_; + unsigned iphi_; + }; + + typedef std::pair MapPair; + typedef std::vector ChannelMap; + + unsigned find(unsigned depth, int ieta, unsigned iphi) const; + + HBHEChannelId lookup_[ChannelCount]; + ChannelMap inverse_; +}; + +// Standard map +const HBHELinearMap& hbheChannelMap(); + +#endif // CondFormats_HcalObjects_HBHELinearMap_h_ diff --git a/CondFormats/HcalObjects/interface/HcalInterpolatedPulse.h b/CondFormats/HcalObjects/interface/HcalInterpolatedPulse.h new file mode 100644 index 0000000000000..d15199fb0b26a --- /dev/null +++ b/CondFormats/HcalObjects/interface/HcalInterpolatedPulse.h @@ -0,0 +1,11 @@ +#ifndef CondFormats_HcalObjects_HcalInterpolatedPulse_h_ +#define CondFormats_HcalObjects_HcalInterpolatedPulse_h_ + +#include "CondFormats/HcalObjects/interface/InterpolatedPulse.h" + +// Use some number which is sufficient to simulate at least 13 +// 25 ns time slices with 0.25 ns step (need to get at least +// 3 ts ahead of the 10 time slices digitized) +typedef InterpolatedPulse<1500U> HcalInterpolatedPulse; + +#endif // CondFormats_HcalObjects_HcalInterpolatedPulse_h_ diff --git a/CondFormats/HcalObjects/interface/HcalInterpolatedPulseColl.h b/CondFormats/HcalObjects/interface/HcalInterpolatedPulseColl.h new file mode 100644 index 0000000000000..ce723652cd53a --- /dev/null +++ b/CondFormats/HcalObjects/interface/HcalInterpolatedPulseColl.h @@ -0,0 +1,50 @@ +#ifndef CondFormats_HcalObjects_HcalInterpolatedPulseColl_h_ +#define CondFormats_HcalObjects_HcalInterpolatedPulseColl_h_ + +#include "CondFormats/HcalObjects/interface/HcalInterpolatedPulse.h" +#include "CondFormats/HcalObjects/interface/HBHEChannelGroups.h" + +class HcalDetId; + +class HcalInterpolatedPulseColl +{ +public: + HcalInterpolatedPulseColl( + const std::vector& pulses, + const HBHEChannelGroups& groups); + + // Get the pulse from channel HcalDetId + const HcalInterpolatedPulse& getChannelPulse(const HcalDetId& id) const; + + // Get the pulse by linearized HCAL channel number + inline const HcalInterpolatedPulse& getChannelPulse(const unsigned i) const + {return pulses_[groups_.getGroup(i)];} + + inline bool operator==(const HcalInterpolatedPulseColl& r) + {return pulses_ == r.pulses_ && groups_ == r.groups_;} + + inline bool operator!=(const HcalInterpolatedPulseColl& r) + {return !(*this == r);} + +private: + std::vector pulses_; + HBHEChannelGroups groups_; + +public: + // Default constructor needed for serialization. + // Do not use in application code. + inline HcalInterpolatedPulseColl() {} + +private: + friend class boost::serialization::access; + + template + inline void serialize(Archive & ar, unsigned /* version */) + { + ar & pulses_ & groups_; + } +}; + +BOOST_CLASS_VERSION(HcalInterpolatedPulseColl, 1) + +#endif // CondFormats_HcalObjects_HcalInterpolatedPulseColl_h_ diff --git a/CondFormats/HcalObjects/interface/InterpolatedPulse.h b/CondFormats/HcalObjects/interface/InterpolatedPulse.h new file mode 100644 index 0000000000000..8461c67189397 --- /dev/null +++ b/CondFormats/HcalObjects/interface/InterpolatedPulse.h @@ -0,0 +1,351 @@ +#ifndef CondFormats_HcalObjects_InterpolatedPulse_h_ +#define CondFormats_HcalObjects_InterpolatedPulse_h_ + +#include +#include "FWCore/Utilities/interface/Exception.h" + +#include "boost/serialization/access.hpp" +#include "boost/serialization/version.hpp" + +template +class InterpolatedPulse +{ + template friend class InterpolatedPulse; + +public: + // Would normally do "static const" but genreflex has problems for it + enum {maxlen = MaxLen}; + + // Default constructor creates a pulse which is zero everywhere + inline InterpolatedPulse() + : tmin_(0.0), width_(1.0), length_(2U) + { + zeroOut(); + } + + // Constructor from a single integer creates a pulse with the given + // number of discrete steps which is zero everywhere + inline explicit InterpolatedPulse(const unsigned len) + : tmin_(0.0), width_(1.0), length_(len) + { + if (length_ < 2 || length_ > MaxLen) throw cms::Exception( + "In InterpolatedPulse constructor: invalid length"); + zeroOut(); + } + + inline InterpolatedPulse(const double tmin, const double tmax, + const unsigned len) + : tmin_(tmin), width_(tmax - tmin), length_(len) + { + if (length_ < 2 || length_ > MaxLen) throw cms::Exception( + "In InterpolatedPulse constructor: invalid length"); + if (width_ <= 0.0) throw cms::Exception( + "In InterpolatedPulse constructor: invalid pulse width"); + zeroOut(); + } + + template + inline InterpolatedPulse(const double tmin, const double tmax, + const Real* values, const unsigned len) + : tmin_(tmin), width_(tmax - tmin) + { + if (width_ <= 0.0) throw cms::Exception( + "In InterpolatedPulse constructor: invalid pulse width"); + setShape(values, len); + } + + // Efficient copy constructor. Do not copy undefined values. + inline InterpolatedPulse(const InterpolatedPulse& r) + : tmin_(r.tmin_), width_(r.width_), length_(r.length_) + { + double* buf = &pulse_[0]; + const double* rbuf = &r.pulse_[0]; + for (unsigned i=0; i + inline InterpolatedPulse(const InterpolatedPulse& r) + : tmin_(r.tmin_), width_(r.width_), length_(r.length_) + { + if (length_ > MaxLen) throw cms::Exception( + "In InterpolatedPulse copy constructor: buffer is not long enough"); + double* buf = &pulse_[0]; + const double* rbuf = &r.pulse_[0]; + for (unsigned i=0; i + inline InterpolatedPulse& operator=(const InterpolatedPulse& r) + { + if (r.length_ > MaxLen) throw cms::Exception( + "In InterpolatedPulse::operator=: buffer is not long enough"); + tmin_ = r.tmin_; + width_ = r.width_; + length_ = r.length_; + double* buf = &pulse_[0]; + const double* rbuf = &r.pulse_[0]; + for (unsigned i=0; i + inline void setShape(const Real* values, const unsigned len) + { + if (len < 2 || len > MaxLen) throw cms::Exception( + "In InterpolatedPulse::setShape: invalid length"); + assert(values); + length_ = len; + double* buf = &pulse_[0]; + for (unsigned i=0; i tmax) + return 0.0; + const unsigned lm1 = length_ - 1U; + const double step = width_/lm1; + const double nSteps = (t - tmin_)/step; + unsigned nbelow = nSteps; + unsigned nabove = nbelow + 1; + if (nabove > lm1) + { + nabove = lm1; + nbelow = nabove - 1U; + } + const double delta = nSteps - nbelow; + return pulse_[nbelow]*(1.0 - delta) + pulse_[nabove]*delta; + } + + inline double derivative(const double t) const + { + const volatile double tmax = tmin_ + width_; + if (t < tmin_ || t > tmax) + return 0.0; + const unsigned lm1 = length_ - 1U; + const double step = width_/lm1; + const double nSteps = (t - tmin_)/step; + unsigned nbelow = nSteps; + unsigned nabove = nbelow + 1; + if (nabove > lm1) + { + nabove = lm1; + nbelow = nabove - 1U; + } + const double delta = nSteps - nbelow; + if ((nbelow == 0U && delta <= 0.5) || (nabove == lm1 && delta >= 0.5)) + return (pulse_[nabove] - pulse_[nbelow])/step; + else if (delta >= 0.5) + { + const double lower = pulse_[nabove] - pulse_[nbelow]; + const double upper = pulse_[nabove+1U] - pulse_[nabove]; + return (upper*(delta - 0.5) + lower*(1.5 - delta))/step; + } + else + { + const double lower = pulse_[nbelow] - pulse_[nbelow-1U]; + const double upper = pulse_[nabove] - pulse_[nbelow]; + return (lower*(0.5 - delta) + upper*(0.5 + delta))/step; + } + } + + inline double secondDerivative(const double t) const + { + const volatile double tmax = tmin_ + width_; + if (t < tmin_ || t > tmax || length_ < 3U) + return 0.0; + const unsigned lm1 = length_ - 1U; + const double step = width_/lm1; + const double stepSq = step*step; + const double nSteps = (t - tmin_)/step; + unsigned nbelow = nSteps; + unsigned nabove = nbelow + 1; + if (nabove > lm1) + { + nabove = lm1; + nbelow = nabove - 1U; + } + + if (nbelow == 0U) + { + // The first interval + return (pulse_[2] - 2.0*pulse_[1] + pulse_[0])/stepSq; + } + else if (nabove == lm1) + { + // The last interval + return (pulse_[lm1] - 2.0*pulse_[lm1-1U] + pulse_[lm1-2U])/stepSq; + } + else + { + // One of the middle intervals + const double lower = pulse_[nbelow-1U] - 2.0*pulse_[nbelow] + pulse_[nabove]; + const double upper = pulse_[nbelow] - 2.0*pulse_[nabove] + pulse_[nabove+1U]; + const double delta = nSteps - nbelow; + return (lower*(1.0 - delta) + upper*delta)/stepSq; + } + } + + inline InterpolatedPulse& operator*=(const double scale) + { + if (scale != 1.0) + { + double* buf = &pulse_[0]; + for (unsigned i=0; i + inline InterpolatedPulse& operator+=(const InterpolatedPulse& r) + { + const double step = width_/(length_ - 1U); + for (unsigned i=0; i + inline bool operator==(const InterpolatedPulse& r) const + { + if (!(tmin_ == r.tmin_ && width_ == r.width_ && length_ == r.length_)) + return false; + const double* buf = &pulse_[0]; + const double* rbuf = &r.pulse_[0]; + for (unsigned i=0; i + inline bool operator!=(const InterpolatedPulse& r) const + {return !(*this == r);} + + // Simple trapezoidal integration + inline double getIntegral() const + { + const double* buf = &pulse_[0]; + long double sum = buf[0]/2.0; + const unsigned nIntervals = length_ - 1U; + for (unsigned i=1U; igetIntegral(); + if (integ == 0.0) throw cms::Exception( + "In InterpolatedPulse::setIntegral division by zero"); + *this *= (newValue/integ); + } + + inline double getPeakValue() const + { + const double* buf = &pulse_[0]; + double peak = buf[0]; + for (unsigned i=1U; i peak) + peak = buf[i]; + return peak; + } + + inline void setPeakValue(const double newValue) + { + const double peak = this->getPeakValue(); + if (peak == 0.0) throw cms::Exception( + "In InterpolatedPulse::setPeakValue: division by zero"); + *this *= (newValue/peak); + } + +private: + double pulse_[MaxLen]; + double tmin_; + double width_; + unsigned length_; + + friend class boost::serialization::access; + + template + inline void serialize(Archive & ar, unsigned /* version */) + { + ar & tmin_ & width_ & length_; + + // In case we are reading, it may be useful to verify + // that the length is reasonable + if (length_ > MaxLen) throw cms::Exception( + "In InterpolatedPulse::serialize: buffer is not long enough"); + + for (unsigned i=0; i + struct version > + { + BOOST_STATIC_CONSTANT(int, value = 1); + }; + } +} + +#endif // CondFormats_HcalObjects_InterpolatedPulse_h_ diff --git a/CondFormats/HcalObjects/src/HBHELinearMap.cc b/CondFormats/HcalObjects/src/HBHELinearMap.cc new file mode 100644 index 0000000000000..8f3ed457c4c06 --- /dev/null +++ b/CondFormats/HcalObjects/src/HBHELinearMap.cc @@ -0,0 +1,150 @@ +#include +#include "FWCore/Utilities/interface/Exception.h" +#include + +#include "CondFormats/HcalObjects/interface/HBHELinearMap.h" + +void HBHELinearMap::getChannelTriple(const unsigned index, unsigned* depth, + int* ieta, unsigned* iphi) const +{ + if (index >= ChannelCount) + throw cms::Exception("In HBHELinearMap::getChannelTriple: " + "input index out of range"); + const HBHEChannelId& id = lookup_[index]; + if (depth) + *depth = id.depth(); + if (ieta) + *ieta = id.ieta(); + if (iphi) + *iphi = id.iphi(); +} + +unsigned HBHELinearMap::find(const unsigned depth, const int ieta, + const unsigned iphi) const +{ + const HBHEChannelId id(depth, ieta, iphi); + const unsigned loc = std::lower_bound( + inverse_.begin(), inverse_.end(), MapPair(id, 0U)) - inverse_.begin(); + if (loc < ChannelCount) + if (inverse_[loc].first == id) + return inverse_[loc].second; + return ChannelCount; +} + +bool HBHELinearMap::isValidTriple(const unsigned depth, const int ieta, + const unsigned iphi) const +{ + const unsigned ind = find(depth, ieta, iphi); + return ind < ChannelCount; +} + +unsigned HBHELinearMap::linearIndex(const unsigned depth, const int ieta, + const unsigned iphi) const +{ + const unsigned ind = find(depth, ieta, iphi); + if (ind >= ChannelCount) + throw cms::Exception("In HBHELinearMap::linearIndex: " + "invalid channel triple"); + return ind; +} + +HBHELinearMap::HBHELinearMap() +{ + unsigned l = 0; + unsigned depth = 1; + + for (int ieta = -29; ieta <= -21; ++ieta) + for (unsigned iphi=1; iphi<72; iphi+=2) + lookup_[l++] = HBHEChannelId(depth, ieta, iphi); + + for (int ieta = -20; ieta <= 20; ++ieta) + if (ieta) + for (unsigned iphi=1; iphi<=72; ++iphi) + lookup_[l++] = HBHEChannelId(depth, ieta, iphi); + + for (int ieta = 21; ieta <= 29; ++ieta) + for (unsigned iphi=1; iphi<72; iphi+=2) + lookup_[l++] = HBHEChannelId(depth, ieta, iphi); + + depth = 2; + + for (int ieta = -29; ieta <= -21; ++ieta) + for (unsigned iphi=1; iphi<72; iphi+=2) + lookup_[l++] = HBHEChannelId(depth, ieta, iphi); + + for (int ieta = -20; ieta <= -18; ++ieta) + for (unsigned iphi=1; iphi<=72; ++iphi) + lookup_[l++] = HBHEChannelId(depth, ieta, iphi); + + for (int ieta = -16; ieta <= -15; ++ieta) + for (unsigned iphi=1; iphi<=72; ++iphi) + lookup_[l++] = HBHEChannelId(depth, ieta, iphi); + + for (int ieta = 15; ieta <= 16; ++ieta) + for (unsigned iphi=1; iphi<=72; ++iphi) + lookup_[l++] = HBHEChannelId(depth, ieta, iphi); + + for (int ieta = 18; ieta <= 20; ++ieta) + for (unsigned iphi=1; iphi<=72; ++iphi) + lookup_[l++] = HBHEChannelId(depth, ieta, iphi); + + for (int ieta = 21; ieta <= 29; ++ieta) + for (unsigned iphi=1; iphi<72; iphi+=2) + lookup_[l++] = HBHEChannelId(depth, ieta, iphi); + + depth = 3; + + for (int ieta = -28; ieta <= -27; ++ieta) + for (unsigned iphi=1; iphi<72; iphi+=2) + lookup_[l++] = HBHEChannelId(depth, ieta, iphi); + + for (int ieta = -16; ieta <= -16; ++ieta) + for (unsigned iphi=1; iphi<=72; ++iphi) + lookup_[l++] = HBHEChannelId(depth, ieta, iphi); + + for (int ieta = 16; ieta <= 16; ++ieta) + for (unsigned iphi=1; iphi<=72; ++iphi) + lookup_[l++] = HBHEChannelId(depth, ieta, iphi); + + for (int ieta = 27; ieta <= 28; ++ieta) + for (unsigned iphi=1; iphi<72; iphi+=2) + lookup_[l++] = HBHEChannelId(depth, ieta, iphi); + + assert(l == ChannelCount); + + inverse_.reserve(ChannelCount); + for (unsigned i=0; i 0U && depth < 4U)) + throw cms::Exception("In HBHELinearMap::getSubdetector: " + "depth argument out of range"); + if (abseta == 29U) + if (!(depth <= 2U)) + throw cms::Exception("In HBHELinearMap::getSubdetector: " + "depth argument out of range " + "for |ieta| = 29"); + if (abseta <= 15U) + return HcalBarrel; + else if (abseta == 16U) + return depth <= 2U ? HcalBarrel : HcalEndcap; + else + return HcalEndcap; +} + +const HBHELinearMap& hbheChannelMap() +{ + static const HBHELinearMap chMap; + return chMap; +} diff --git a/CondFormats/HcalObjects/src/HcalInterpolatedPulseColl.cc b/CondFormats/HcalObjects/src/HcalInterpolatedPulseColl.cc new file mode 100644 index 0000000000000..74b656500679a --- /dev/null +++ b/CondFormats/HcalObjects/src/HcalInterpolatedPulseColl.cc @@ -0,0 +1,25 @@ +#include "CondFormats/HcalObjects/interface/HcalInterpolatedPulseColl.h" +#include "DataFormats/HcalDetId/interface/HcalDetId.h" + +HcalInterpolatedPulseColl::HcalInterpolatedPulseColl( + const std::vector& pulses, + const HBHEChannelGroups& groups) + : pulses_(pulses), + groups_(groups) +{ + if (!(pulses_.size() == groups_.largestGroupNumber() + 1U)) + throw cms::Exception( + "Inconsistent arguments in HcalInterpolatedPulseColl constructor"); +} + +const HcalInterpolatedPulse& HcalInterpolatedPulseColl::getChannelPulse( + const HcalDetId& id) const +{ + // Figure out the group number for this channel + const unsigned lindex = hbheChannelMap().linearIndex( + id.depth(), id.ieta(), id.iphi()); + const unsigned grN = groups_.getGroup(lindex); + + // Return the pulse for this group + return pulses_[grN]; +} diff --git a/CondFormats/HcalObjects/src/T_EventSetup_HcalInterpolatedPulseColl.cc b/CondFormats/HcalObjects/src/T_EventSetup_HcalInterpolatedPulseColl.cc new file mode 100644 index 0000000000000..e5df96140ecb1 --- /dev/null +++ b/CondFormats/HcalObjects/src/T_EventSetup_HcalInterpolatedPulseColl.cc @@ -0,0 +1,4 @@ +#include "CondFormats/HcalObjects/interface/HcalInterpolatedPulseColl.h" +#include "FWCore/Utilities/interface/typelookup.h" + +TYPELOOKUP_DATA_REG(HcalInterpolatedPulseColl); diff --git a/CondFormats/HcalObjects/src/classes.h b/CondFormats/HcalObjects/src/classes.h index 0b9a776e67fef..51a44f59a24d9 100644 --- a/CondFormats/HcalObjects/src/classes.h +++ b/CondFormats/HcalObjects/src/classes.h @@ -93,6 +93,12 @@ namespace CondFormats_HcalObjects { DummyOOTPileupCorrection myDummyOOTPileupCorrection; OOTPileupCorrectionMapColl myOOTPileupCorrectionMapColl; OOTPileupCorrectionBuffer myOOTPileupCorrectionBuffer; + + // HCAL pulse + HBHEChannelGroups myHBHEChannelGroups; + HcalInterpolatedPulse myHcalInterpolatedPulse; + std::vector myVectorOfHcalInterpolatedPulse; + HcalInterpolatedPulseColl myHcalInterpolatedPulseColl; }; } diff --git a/CondFormats/HcalObjects/src/classes_def.xml b/CondFormats/HcalObjects/src/classes_def.xml index e039b505a24d2..f0571194e7bd7 100644 --- a/CondFormats/HcalObjects/src/classes_def.xml +++ b/CondFormats/HcalObjects/src/classes_def.xml @@ -392,4 +392,16 @@ + + + + + + + + + + + + diff --git a/CondTools/Hcal/plugins/HcalInterpolatedPulseDBModules.cc b/CondTools/Hcal/plugins/HcalInterpolatedPulseDBModules.cc new file mode 100644 index 0000000000000..49bb9e4e2a720 --- /dev/null +++ b/CondTools/Hcal/plugins/HcalInterpolatedPulseDBModules.cc @@ -0,0 +1,14 @@ +#include "CondFormats/HcalObjects/interface/HcalInterpolatedPulseColl.h" +#include "CondFormats/DataRecord/interface/HcalInterpolatedPulseCollRcd.h" + +#include "CondTools/Hcal/interface/BoostIODBWriter.h" +#include "CondTools/Hcal/interface/BoostIODBReader.h" + +#include "FWCore/Framework/interface/MakerMacros.h" + +typedef BoostIODBWriter HcalInterpolatedPulseDBWriter; + +typedef BoostIODBReader HcalInterpolatedPulseDBReader; + +DEFINE_FWK_MODULE(HcalInterpolatedPulseDBWriter); +DEFINE_FWK_MODULE(HcalInterpolatedPulseDBReader); diff --git a/CondTools/Hcal/test/HcalInterpolatedPulseDBReader_cfg.py b/CondTools/Hcal/test/HcalInterpolatedPulseDBReader_cfg.py new file mode 100644 index 0000000000000..507fa96674917 --- /dev/null +++ b/CondTools/Hcal/test/HcalInterpolatedPulseDBReader_cfg.py @@ -0,0 +1,28 @@ +database = "sqlite_file:hcalPulse.db" +tag = "test" +outputfile = "hcalPulse_dbread.bbin" + +import FWCore.ParameterSet.Config as cms + +process = cms.Process('HcalInterpolatedPulseDBRead') + +process.source = cms.Source('EmptySource') +process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(1)) + +process.load("CondCore.CondDB.CondDB_cfi") +process.CondDB.connect = database + +process.PoolDBESSource = cms.ESSource("PoolDBESSource", + process.CondDB, + toGet = cms.VPSet(cms.PSet( + record = cms.string("HcalInterpolatedPulseCollRcd"), + tag = cms.string(tag) + )) +) + +process.dumper = cms.EDAnalyzer( + 'HcalInterpolatedPulseDBReader', + outputFile = cms.string(outputfile) +) + +process.p = cms.Path(process.dumper) diff --git a/CondTools/Hcal/test/HcalInterpolatedPulseDBWriter_cfg.py b/CondTools/Hcal/test/HcalInterpolatedPulseDBWriter_cfg.py new file mode 100644 index 0000000000000..6f633714db802 --- /dev/null +++ b/CondTools/Hcal/test/HcalInterpolatedPulseDBWriter_cfg.py @@ -0,0 +1,50 @@ +database = "sqlite_file:hcalPulse.db" +tag = "test" +inputfile = "hcalPulse.bbin" + +import FWCore.ParameterSet.Config as cms + +process = cms.Process('HcalInterpolatedPulseDBWrite') + +process.source = cms.Source('EmptyIOVSource', + lastValue = cms.uint64(1), + timetype = cms.string('runnumber'), + firstValue = cms.uint64(1), + interval = cms.uint64(1) +) +process.maxEvents = cms.untracked.PSet(input = cms.untracked.int32(1)) + +process.load("CondCore.CondDB.CondDB_cfi") +process.CondDB.connect = cms.string(database) + +# Data is tagged in the database by the "tag" parameter specified in the +# PoolDBOutputService configuration. We then check if the tag already exists. +# +# -- If the tag does not exist, a new interval of validity (IOV) for this tag +# is created, valid till "end of time". +# +# -- If the tag already exists: the IOV of the previous data is stopped at +# "current time" and we register new data valid from now on (currentTime +# is the time of the current event!). +# +# The "record" parameter should be the same in the PoolDBOutputService +# configuration and in the module which writes the object. It is basically +# used in order to just associate the record with the tag. +# +process.PoolDBOutputService = cms.Service( + "PoolDBOutputService", + process.CondDB, + timetype = cms.untracked.string('runnumber'), + toPut = cms.VPSet(cms.PSet( + record = cms.string("HcalInterpolatedPulseCollRcd"), + tag = cms.string(tag) + )) +) + +process.filereader = cms.EDAnalyzer( + 'HcalInterpolatedPulseDBWriter', + inputFile = cms.string(inputfile), + record = cms.string("HcalInterpolatedPulseCollRcd") +) + +process.p = cms.Path(process.filereader) From dafdcf72b0a41b840222788d3779b6d1e7bc3401 Mon Sep 17 00:00:00 2001 From: Igor Date: Tue, 11 Nov 2014 09:00:21 +0100 Subject: [PATCH 02/28] fixing genreflex serialization --- .../interface/HcalInterpolatedPulseColl.h | 3 +-- .../HcalObjects/src/HcalInterpolatedPulseColl.cc | 2 +- CondFormats/HcalObjects/src/classes.h | 6 +++--- CondFormats/HcalObjects/src/classes_def.xml | 13 +++---------- CondFormats/HcalObjects/src/headers.h | 3 +++ 5 files changed, 11 insertions(+), 16 deletions(-) diff --git a/CondFormats/HcalObjects/interface/HcalInterpolatedPulseColl.h b/CondFormats/HcalObjects/interface/HcalInterpolatedPulseColl.h index ce723652cd53a..370675649a178 100644 --- a/CondFormats/HcalObjects/interface/HcalInterpolatedPulseColl.h +++ b/CondFormats/HcalObjects/interface/HcalInterpolatedPulseColl.h @@ -1,11 +1,10 @@ #ifndef CondFormats_HcalObjects_HcalInterpolatedPulseColl_h_ #define CondFormats_HcalObjects_HcalInterpolatedPulseColl_h_ +#include "DataFormats/HcalDetId/interface/HcalDetId.h" #include "CondFormats/HcalObjects/interface/HcalInterpolatedPulse.h" #include "CondFormats/HcalObjects/interface/HBHEChannelGroups.h" -class HcalDetId; - class HcalInterpolatedPulseColl { public: diff --git a/CondFormats/HcalObjects/src/HcalInterpolatedPulseColl.cc b/CondFormats/HcalObjects/src/HcalInterpolatedPulseColl.cc index 74b656500679a..9e6007815ea52 100644 --- a/CondFormats/HcalObjects/src/HcalInterpolatedPulseColl.cc +++ b/CondFormats/HcalObjects/src/HcalInterpolatedPulseColl.cc @@ -1,5 +1,5 @@ #include "CondFormats/HcalObjects/interface/HcalInterpolatedPulseColl.h" -#include "DataFormats/HcalDetId/interface/HcalDetId.h" +#include "CondFormats/HcalObjects/interface/HBHELinearMap.h" HcalInterpolatedPulseColl::HcalInterpolatedPulseColl( const std::vector& pulses, diff --git a/CondFormats/HcalObjects/src/classes.h b/CondFormats/HcalObjects/src/classes.h index 51a44f59a24d9..6f8492d060aad 100644 --- a/CondFormats/HcalObjects/src/classes.h +++ b/CondFormats/HcalObjects/src/classes.h @@ -94,10 +94,10 @@ namespace CondFormats_HcalObjects { OOTPileupCorrectionMapColl myOOTPileupCorrectionMapColl; OOTPileupCorrectionBuffer myOOTPileupCorrectionBuffer; - // HCAL pulse - HBHEChannelGroups myHBHEChannelGroups; + // QIE8 input pulse representation objects HcalInterpolatedPulse myHcalInterpolatedPulse; - std::vector myVectorOfHcalInterpolatedPulse; + std::vector myHcalInterpolatedPulseVec; + HBHEChannelGroups myHBHEChannelGroups; HcalInterpolatedPulseColl myHcalInterpolatedPulseColl; }; } diff --git a/CondFormats/HcalObjects/src/classes_def.xml b/CondFormats/HcalObjects/src/classes_def.xml index f0571194e7bd7..b8fedfc18715b 100644 --- a/CondFormats/HcalObjects/src/classes_def.xml +++ b/CondFormats/HcalObjects/src/classes_def.xml @@ -391,17 +391,10 @@ - - - - - + + - - - - - + diff --git a/CondFormats/HcalObjects/src/headers.h b/CondFormats/HcalObjects/src/headers.h index 4b7555649610c..8187025a3bd46 100644 --- a/CondFormats/HcalObjects/src/headers.h +++ b/CondFormats/HcalObjects/src/headers.h @@ -8,3 +8,6 @@ #include "CondFormats/HcalObjects/interface/OOTPileupCorrData.h" #include "CondFormats/HcalObjects/interface/DummyOOTPileupCorrection.h" #include "CondFormats/HcalObjects/interface/OOTPileupCorrectionMapColl.h" +#include "CondFormats/HcalObjects/interface/HcalInterpolatedPulse.h" +#include "CondFormats/HcalObjects/interface/HcalInterpolatedPulseColl.h" +#include "CondFormats/HcalObjects/interface/HBHEChannelGroups.h" From fc2edab02c8b87eeed79cdd2b1c6611f5aeb0970 Mon Sep 17 00:00:00 2001 From: Carlo Battilana Date: Thu, 20 Nov 2014 16:36:20 +0100 Subject: [PATCH 03/28] CondFormat to store a vector of function parameters for the version of the DYT TeV refit code presently under development toghether with the trivial code to populate it from txt. --- .../DataRecord/interface/DYTParamsObjectRcd.h | 8 + .../DataRecord/src/DYTParamsObjectRcd.cc | 7 + .../interface/DYTParamObject.h | 34 ++++ .../interface/DYTParamsObject.h | 35 ++++ .../RecoMuonObjects/src/DYTParamObject.cc | 16 ++ .../src/T_EventSetup_DYTParamsObject.cc | 5 + CondFormats/RecoMuonObjects/src/classes.h | 2 +- .../RecoMuonObjects/src/classes_def.xml | 3 + CondFormats/RecoMuonObjects/src/headers.h | 1 + .../test/testSerializationRecoMuonObjects.cpp | 1 + .../GlobalTrackingTools/test/BuildFile.xml | 3 + .../test/DYTParamsWriter.cc | 187 ++++++++++++++++++ .../test/writeDytParamsFromFile_cfg.py | 33 ++++ 13 files changed, 334 insertions(+), 1 deletion(-) create mode 100644 CondFormats/DataRecord/interface/DYTParamsObjectRcd.h create mode 100644 CondFormats/DataRecord/src/DYTParamsObjectRcd.cc create mode 100644 CondFormats/RecoMuonObjects/interface/DYTParamObject.h create mode 100644 CondFormats/RecoMuonObjects/interface/DYTParamsObject.h create mode 100644 CondFormats/RecoMuonObjects/src/DYTParamObject.cc create mode 100644 CondFormats/RecoMuonObjects/src/T_EventSetup_DYTParamsObject.cc create mode 100644 RecoMuon/GlobalTrackingTools/test/DYTParamsWriter.cc create mode 100644 RecoMuon/GlobalTrackingTools/test/writeDytParamsFromFile_cfg.py diff --git a/CondFormats/DataRecord/interface/DYTParamsObjectRcd.h b/CondFormats/DataRecord/interface/DYTParamsObjectRcd.h new file mode 100644 index 0000000000000..16c9dcf7868ae --- /dev/null +++ b/CondFormats/DataRecord/interface/DYTParamsObjectRcd.h @@ -0,0 +1,8 @@ +#ifndef CondFormats_DYTParamsObjectRcd_h +#define CondFormats_DYTParamsObjectRcd_h + +#include "FWCore/Framework/interface/EventSetupRecordImplementation.h" + +class DYTParamsObjectRcd : public edm::eventsetup::EventSetupRecordImplementation {}; + +#endif diff --git a/CondFormats/DataRecord/src/DYTParamsObjectRcd.cc b/CondFormats/DataRecord/src/DYTParamsObjectRcd.cc new file mode 100644 index 0000000000000..aa5ed4215f3ce --- /dev/null +++ b/CondFormats/DataRecord/src/DYTParamsObjectRcd.cc @@ -0,0 +1,7 @@ +// Package: CondFormats +// Class : DYTParamsObjectRcd + +#include "CondFormats/DataRecord/interface/DYTParamsObjectRcd.h" +#include "FWCore/Framework/interface/eventsetuprecord_registration_macro.h" + +EVENTSETUP_RECORD_REG(DYTParamsObjectRcd); diff --git a/CondFormats/RecoMuonObjects/interface/DYTParamObject.h b/CondFormats/RecoMuonObjects/interface/DYTParamObject.h new file mode 100644 index 0000000000000..70ccde892737e --- /dev/null +++ b/CondFormats/RecoMuonObjects/interface/DYTParamObject.h @@ -0,0 +1,34 @@ +#ifndef DytParamObject_h +#define DytParamObject_h + +#include +#include "DataFormats/DetId/interface/DetId.h" +#include "CondFormats/Serialization/interface/Serializable.h" + +class DYTParamObject { + public: + + DYTParamObject() { }; + DYTParamObject(uint32_t id, std::vector & params) + : m_id(id) , m_params(params) { }; + ~DYTParamObject() { m_params.clear(); }; + + // Return raw id + uint32_t id() const {return m_id;}; + + // Return param i (i from 0 to size-1) + double parameter(unsigned int iParam) const; + + // Return param vector size (i from 0 to size-1) + unsigned int paramSize() const { return m_params.size(); }; + + private: + + uint32_t m_id; + std::vector m_params; + + COND_SERIALIZABLE; + +}; + +#endif diff --git a/CondFormats/RecoMuonObjects/interface/DYTParamsObject.h b/CondFormats/RecoMuonObjects/interface/DYTParamsObject.h new file mode 100644 index 0000000000000..1f63d22e85620 --- /dev/null +++ b/CondFormats/RecoMuonObjects/interface/DYTParamsObject.h @@ -0,0 +1,35 @@ +#ifndef DytParamsObject_h +#define DytParamsObject_h + +#include +#include "CondFormats/RecoMuonObjects/interface/DYTParamObject.h" +#include "CondFormats/Serialization/interface/Serializable.h" + +class DYTParamsObject { + public: + + DYTParamsObject() {}; + ~DYTParamsObject() { m_paramObjs.clear(); }; + + // Add a parameter to the vector of parameters + void addParamObject(const DYTParamObject & obj) { m_paramObjs.push_back(obj); }; + + // Set the parametrized formula + void setFormula(std::string formula) { m_formula = formula; }; + + // Get the list of parameters + const std::vector & getParamObjs() const { return m_paramObjs; }; + + // Get the functional parametrization + const std::string & formula() const { return m_formula; }; + + private: + + std::vector m_paramObjs; + + std::string m_formula; + + COND_SERIALIZABLE; +}; + +#endif diff --git a/CondFormats/RecoMuonObjects/src/DYTParamObject.cc b/CondFormats/RecoMuonObjects/src/DYTParamObject.cc new file mode 100644 index 0000000000000..d17896831ecf5 --- /dev/null +++ b/CondFormats/RecoMuonObjects/src/DYTParamObject.cc @@ -0,0 +1,16 @@ +#include "CondFormats/RecoMuonObjects/interface/DYTParamObject.h" + +double DYTParamObject::parameter(unsigned int iParam) const +{ + + if (iParam >= paramSize()) + { + std::cout << "[DYTParamObject::parameter] " + << "Requested parameter is outside size range (" + << paramSize() << ")." << std::endl; + return 0.; + } + + return m_params.at(iParam); + +} diff --git a/CondFormats/RecoMuonObjects/src/T_EventSetup_DYTParamsObject.cc b/CondFormats/RecoMuonObjects/src/T_EventSetup_DYTParamsObject.cc new file mode 100644 index 0000000000000..4ce3d803bcab0 --- /dev/null +++ b/CondFormats/RecoMuonObjects/src/T_EventSetup_DYTParamsObject.cc @@ -0,0 +1,5 @@ +#include "CondFormats/RecoMuonObjects/interface/DYTParamsObject.h" +#include "FWCore/Utilities/interface/typelookup.h" + +TYPELOOKUP_DATA_REG(DYTParamsObject); + diff --git a/CondFormats/RecoMuonObjects/src/classes.h b/CondFormats/RecoMuonObjects/src/classes.h index 860037cc05401..6c3438f3c2520 100644 --- a/CondFormats/RecoMuonObjects/src/classes.h +++ b/CondFormats/RecoMuonObjects/src/classes.h @@ -1,9 +1,9 @@ #include "CondFormats/RecoMuonObjects/src/headers.h" - namespace CondFormats_RecoMuonObjects { struct dictionary { // std::vector a; MuScleFitDBobject e; + DYTParamsObject g; }; } diff --git a/CondFormats/RecoMuonObjects/src/classes_def.xml b/CondFormats/RecoMuonObjects/src/classes_def.xml index 53bf55a73c763..b51397de4e3b4 100644 --- a/CondFormats/RecoMuonObjects/src/classes_def.xml +++ b/CondFormats/RecoMuonObjects/src/classes_def.xml @@ -3,4 +3,7 @@ + + + diff --git a/CondFormats/RecoMuonObjects/src/headers.h b/CondFormats/RecoMuonObjects/src/headers.h index 64fd9baebe328..2a32729e8ecce 100644 --- a/CondFormats/RecoMuonObjects/src/headers.h +++ b/CondFormats/RecoMuonObjects/src/headers.h @@ -1,5 +1,6 @@ #include "CondFormats/RecoMuonObjects/interface/MuScleFitDBobject.h" #include "CondFormats/RecoMuonObjects/interface/DYTThrObject.h" +#include "CondFormats/RecoMuonObjects/interface/DYTParamsObject.h" #if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__) #include "CondFormats/External/interface/DetID.h" diff --git a/CondFormats/RecoMuonObjects/test/testSerializationRecoMuonObjects.cpp b/CondFormats/RecoMuonObjects/test/testSerializationRecoMuonObjects.cpp index ae0f027174523..9df0c62abdccc 100644 --- a/CondFormats/RecoMuonObjects/test/testSerializationRecoMuonObjects.cpp +++ b/CondFormats/RecoMuonObjects/test/testSerializationRecoMuonObjects.cpp @@ -5,6 +5,7 @@ int main() { testSerialization(); + testSerialization(); testSerialization(); return 0; } diff --git a/RecoMuon/GlobalTrackingTools/test/BuildFile.xml b/RecoMuon/GlobalTrackingTools/test/BuildFile.xml index 6ed089d915d5e..17ffffff5b452 100644 --- a/RecoMuon/GlobalTrackingTools/test/BuildFile.xml +++ b/RecoMuon/GlobalTrackingTools/test/BuildFile.xml @@ -6,3 +6,6 @@ + + + diff --git a/RecoMuon/GlobalTrackingTools/test/DYTParamsWriter.cc b/RecoMuon/GlobalTrackingTools/test/DYTParamsWriter.cc new file mode 100644 index 0000000000000..551a80027bea6 --- /dev/null +++ b/RecoMuon/GlobalTrackingTools/test/DYTParamsWriter.cc @@ -0,0 +1,187 @@ +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "CondFormats/RecoMuonObjects/interface/DYTParamsObject.h" +#include "CondFormats/DataRecord/interface/DYTParamsObjectRcd.h" +#include "CondCore/DBOutputService/interface/PoolDBOutputService.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "FWCore/Framework/interface/ConsumesCollector.h" +#include "DataFormats/DetId/interface/DetId.h" + +#include +#include +#include + +#include +#include +#include + +class DYTParamsWriter : public edm::EDAnalyzer +{ + +public: + + explicit DYTParamsWriter(const edm::ParameterSet&); + ~DYTParamsWriter(); + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + virtual void endRun(edm::Run const&, edm::EventSetup const&) override; + virtual void analyze(edm::Event const&, edm::EventSetup const&) override; + virtual void endJob() override; + +private: + + void parseLine(std::string & line, uint32_t & id, std::vector & pars); + int getNParamsFromFunction(); + + const std::string m_inputFileName; + const std::string m_inputFunction; + + edm::Service m_poolDbService; + + DYTParamsObject * m_params; + +}; + + +DYTParamsWriter::DYTParamsWriter(const edm::ParameterSet& iConfig) : + m_inputFileName(iConfig.getParameter("inputFileName")), + m_inputFunction(iConfig.getParameter("inputFunction")) +{ + + if( !m_poolDbService.isAvailable() ) + throw cms::Exception("NotAvailable") << "[DYTParamsWriter::DYTParamsWriter] " + << "PoolDBOutputService is not available."; + + if (!m_poolDbService->isNewTagRequest("DYTParamsObjectRcd")) + throw cms::Exception("ObjectExists") << "[DYTParamsWriter::DYTParamsWriter] " + << "The output file already contains a valid " + << "\"DYTParamsObjectRcd\" record." << std::endl + << "Please provide a different file name or tag."; + + m_params = new DYTParamsObject; + +} + + +DYTParamsWriter::~DYTParamsWriter() +{ + +} + + +void DYTParamsWriter::analyze(edm::Event const&, edm::EventSetup const&) +{ + +} + + +void DYTParamsWriter::endRun(edm::Run const&, edm::EventSetup const&) +{ + + std::ifstream inputFile(m_inputFileName.c_str()); + + int nLines=0; + uint32_t nParams=getNParamsFromFunction(); + + m_params->setFormula(m_inputFunction); + + std::string line; + + while(std::getline(inputFile, line)) + { + + nLines++; + + uint32_t id; + std::vector params; + + parseLine(line, id, params); + + if ( nParams != params.size() ) + throw cms::Exception("ConfigFileError") << "[DYTParamsWriter::endRun] " + << "# of parameters in line " << nLines + << " differs from the one expected from" + << " the parametrized function (" << nParams << ")."; + + DYTParamObject obj(id, params); + m_params->addParamObject(obj); + + } + + std::cout << "[DYTParamsWriter::endRun] " + << "Processed " << nLines << " lines with " + << nParams << " parameters for each line." << std::endl; + + inputFile.close(); + +} + + +void DYTParamsWriter::endJob() +{ + + // Writing to DB + if( m_poolDbService.isAvailable() ) + m_poolDbService->writeOne(m_params, m_poolDbService->beginOfTime(), "DYTParamsObjectRcd"); + else + throw cms::Exception("NotAvailable") << "[DYTParamsWriter::endJob] " + << "PoolDBOutputService is not available."; +} + + +void DYTParamsWriter::parseLine(std::string & line, uint32_t & id, std::vector & pars) +{ + + std::vector elements; + boost::algorithm::split(elements,line,boost::algorithm::is_any_of(" \t\n")); + if (elements.size() < 2) + { + throw cms::Exception("ConfigFileError") << "[DYTParamsWriter::parseLine] " + << "Wrong number of entries in line : \"" + << line << "\" ." << std::endl; + } + else + { + id = atoi(elements[0].c_str()); + for (uint32_t i=1; i < elements.size(); ++i) + pars.push_back(atof(elements[i].c_str())); + } + +} + + +int DYTParamsWriter::getNParamsFromFunction() +{ + + std::vector parameters; + boost::regex reg("\\[[0-9]+\\]"); + + boost::sregex_token_iterator rIt(m_inputFunction.begin(), m_inputFunction.end(), reg, 0); + boost::sregex_token_iterator rEnd; + + int nParams = 0; + for( ; rIt != rEnd; ++rIt ) + nParams++; + + return nParams; + +} + + +void DYTParamsWriter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) +{ + + //The following says we do not know what parameters are allowed so do no validation + // Please change this to state exactly what you do use, even if it is no parameters + edm::ParameterSetDescription desc; + desc.add("inputFileName", "dyt_params.txt"); + desc.add("inputFunction", "[0]*x + [1]*x^[2]"); + descriptions.add("dytParamsWriter",desc); + +} + +DEFINE_FWK_MODULE(DYTParamsWriter); diff --git a/RecoMuon/GlobalTrackingTools/test/writeDytParamsFromFile_cfg.py b/RecoMuon/GlobalTrackingTools/test/writeDytParamsFromFile_cfg.py new file mode 100644 index 0000000000000..0714a49154ee2 --- /dev/null +++ b/RecoMuon/GlobalTrackingTools/test/writeDytParamsFromFile_cfg.py @@ -0,0 +1,33 @@ +import FWCore.ParameterSet.Config as cms + +process = cms.Process("WriteDYTParamsFromFile") + +process.source = cms.Source("EmptySource", + numberEventsInRun = cms.untracked.uint32(1), + firstRun = cms.untracked.uint32(1) + ) + +process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(1) ) + +process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") + +process.GlobalTag.globaltag = "PRE_LS172_V15::All" + +process.PoolDBOutputService = cms.Service("PoolDBOutputService", + process.CondDBSetup, + timetype = cms.untracked.string('runnumber'), + connect = cms.string('sqlite_file:dytParamsFromFile.db'), + authenticationMethod = cms.untracked.uint32(0), + toPut = cms.VPSet(cms.PSet(record = cms.string('DYTParamsObjectRcd'), + tag = cms.string('test') + ) + ) + ) + +process.dytParamsWriter = cms.EDAnalyzer("DYTParamsWriter", + inputFileName = cms.string("dyt_params_example.txt"), + inputFunction = cms.string("[0]x+[1]") + ) + + +process.clientPath = cms.Path(process.dytParamsWriter) From 61bc648906d56ff2535c055e68a7474a38a7f1f2 Mon Sep 17 00:00:00 2001 From: Carlo Battilana Date: Wed, 3 Dec 2014 13:40:36 +0100 Subject: [PATCH 04/28] From std::cout to edm::MessageLogger --- CondFormats/RecoMuonObjects/src/DYTParamObject.cc | 7 ++++--- RecoMuon/GlobalTrackingTools/test/DYTParamsWriter.cc | 7 ++++--- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/CondFormats/RecoMuonObjects/src/DYTParamObject.cc b/CondFormats/RecoMuonObjects/src/DYTParamObject.cc index d17896831ecf5..840f26598a460 100644 --- a/CondFormats/RecoMuonObjects/src/DYTParamObject.cc +++ b/CondFormats/RecoMuonObjects/src/DYTParamObject.cc @@ -1,13 +1,14 @@ #include "CondFormats/RecoMuonObjects/interface/DYTParamObject.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" double DYTParamObject::parameter(unsigned int iParam) const { if (iParam >= paramSize()) { - std::cout << "[DYTParamObject::parameter] " - << "Requested parameter is outside size range (" - << paramSize() << ")." << std::endl; + edm::LogWarning("DYTParamObject") + << "The requested parameter (" << (iParam + 1) + << ") is outside size range (" << paramSize() << ")."; return 0.; } diff --git a/RecoMuon/GlobalTrackingTools/test/DYTParamsWriter.cc b/RecoMuon/GlobalTrackingTools/test/DYTParamsWriter.cc index 551a80027bea6..b1763c12e44be 100644 --- a/RecoMuon/GlobalTrackingTools/test/DYTParamsWriter.cc +++ b/RecoMuon/GlobalTrackingTools/test/DYTParamsWriter.cc @@ -3,6 +3,7 @@ #include "FWCore/Framework/interface/Event.h" #include "FWCore/Framework/interface/MakerMacros.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" #include "CondFormats/RecoMuonObjects/interface/DYTParamsObject.h" #include "CondFormats/DataRecord/interface/DYTParamsObjectRcd.h" #include "CondCore/DBOutputService/interface/PoolDBOutputService.h" @@ -112,9 +113,9 @@ void DYTParamsWriter::endRun(edm::Run const&, edm::EventSetup const&) } - std::cout << "[DYTParamsWriter::endRun] " - << "Processed " << nLines << " lines with " - << nParams << " parameters for each line." << std::endl; + edm::LogInfo("DYTParamsWriter") + << "Processed " << nLines << " lines with " + << nParams << " parameters for each line."; inputFile.close(); From 02c9e071fa9925d58727736bf603924abfb9c144 Mon Sep 17 00:00:00 2001 From: Carlo Battilana Date: Wed, 3 Dec 2014 13:41:36 +0100 Subject: [PATCH 05/28] moved DYTParamsObject class version to 2 --- CondFormats/RecoMuonObjects/src/classes_def.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CondFormats/RecoMuonObjects/src/classes_def.xml b/CondFormats/RecoMuonObjects/src/classes_def.xml index b51397de4e3b4..c7f12bc68f3e7 100644 --- a/CondFormats/RecoMuonObjects/src/classes_def.xml +++ b/CondFormats/RecoMuonObjects/src/classes_def.xml @@ -3,7 +3,7 @@ - + From 4b0940f67836f0b25e90969de18b77ace68475a5 Mon Sep 17 00:00:00 2001 From: arabella Date: Thu, 4 Dec 2014 09:57:07 +0100 Subject: [PATCH 06/28] extended_DIGI_window --- SimCalorimetry/EcalSimAlgos/src/EcalHitResponse.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse.cc b/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse.cc index edbb661e63f38..5806dffb1735f 100644 --- a/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse.cc +++ b/SimCalorimetry/EcalSimAlgos/src/EcalHitResponse.cc @@ -28,7 +28,7 @@ EcalHitResponse::EcalHitResponse( const CaloVSimParameterMap* parameterMap , m_hitFilter ( 0 ) , m_geometry ( 0 ) , m_lasercals ( 0 ) , - m_minBunch ( -10 ) , + m_minBunch ( -32 ) , m_maxBunch ( 10 ) , m_phaseShift ( 1 ) , m_iTime ( 0 ) , From f59d7eab8fd867845c65b136a19aa513d7628ae9 Mon Sep 17 00:00:00 2001 From: David Date: Fri, 5 Dec 2014 14:28:19 +0100 Subject: [PATCH 07/28] turn on pat in unscheduled, remove miniaod products coming into the aod --- Configuration/PyReleaseValidation/python/relval_steps.py | 5 +++-- .../Configuration/python/RecoEgamma_EventContent_cff.py | 4 ++-- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/Configuration/PyReleaseValidation/python/relval_steps.py b/Configuration/PyReleaseValidation/python/relval_steps.py index e703f994d8e1d..fc14479a8af3c 100644 --- a/Configuration/PyReleaseValidation/python/relval_steps.py +++ b/Configuration/PyReleaseValidation/python/relval_steps.py @@ -935,8 +935,9 @@ def genvalid(fragment,d,suffix='all',fi='',dataSet=''): '--customise' :'SLHCUpgradeSimulations/Configuration/postLS1Customs.customisePostLS1' } -step3Up2015DefaultsUnsch = merge([{'--runUnscheduled':''},step3Up2015Defaults]) -step3DefaultsUnsch = merge([{'--runUnscheduled':''},step3Defaults]) +unSchOverrides={'--runUnscheduled':'','-s':'RAW2DIGI,L1Reco,RECO,EI,PAT,VALIDATION,DQM','--eventcontent':'RECOSIM,MINIAODSIM,DQM','--datatier':'GEN-SIM-RECO,MINIAODSIM,DQMIO'} +step3Up2015DefaultsUnsch = merge([unSchOverrides,step3Up2015Defaults]) +step3DefaultsUnsch = merge([unSchOverrides,step3Defaults]) steps['RECOUP15']=merge([step3Up2015Defaults]) # todo: remove UP from label diff --git a/RecoEgamma/Configuration/python/RecoEgamma_EventContent_cff.py b/RecoEgamma/Configuration/python/RecoEgamma_EventContent_cff.py index 3af249ec5fe70..8da778e4bc161 100644 --- a/RecoEgamma/Configuration/python/RecoEgamma_EventContent_cff.py +++ b/RecoEgamma/Configuration/python/RecoEgamma_EventContent_cff.py @@ -13,7 +13,7 @@ 'keep *_eidLoose_*_*', 'keep *_eidTight_*_*', 'keep *_egmGedGsfElectronPF*Isolation_*_*', - 'keep *_egmGsfElectronIDs_*_*', + 'keep *_egmGsfElectronIDs_*_*', 'keep *_conversions_*_*', 'keep *_mustacheConversions_*_*', 'drop *_conversions_uncleanedConversions_*', @@ -104,7 +104,7 @@ 'keep floatedmValueMap_eidLoose_*_*', 'keep floatedmValueMap_eidTight_*_*', 'keep *_egmGedGsfElectronPFIsolation_*_*', - 'keep *_egmGsfElectronIDs_*_*', +# 'keep *_egmGsfElectronIDs_*_*', #these are in the miniAOD 'keep recoPhotonCores_gedPhotonCore_*_*', 'keep recoPhotons_gedPhotons_*_*', 'keep *_particleBasedIsolation_*_*', From ebc0dbdd33751d5b47da960ba2a5018cbc452f48 Mon Sep 17 00:00:00 2001 From: Carlo Battilana Date: Fri, 5 Dec 2014 15:47:23 +0100 Subject: [PATCH 08/28] Removing DYT parameters writer code --- .../test/DYTParamsWriter.cc | 188 ------------------ .../test/writeDytParamsFromFile_cfg.py | 33 --- 2 files changed, 221 deletions(-) delete mode 100644 RecoMuon/GlobalTrackingTools/test/DYTParamsWriter.cc delete mode 100644 RecoMuon/GlobalTrackingTools/test/writeDytParamsFromFile_cfg.py diff --git a/RecoMuon/GlobalTrackingTools/test/DYTParamsWriter.cc b/RecoMuon/GlobalTrackingTools/test/DYTParamsWriter.cc deleted file mode 100644 index b1763c12e44be..0000000000000 --- a/RecoMuon/GlobalTrackingTools/test/DYTParamsWriter.cc +++ /dev/null @@ -1,188 +0,0 @@ -#include "FWCore/Framework/interface/Frameworkfwd.h" -#include "FWCore/Framework/interface/EDAnalyzer.h" -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/Framework/interface/MakerMacros.h" -#include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "FWCore/MessageLogger/interface/MessageLogger.h" -#include "CondFormats/RecoMuonObjects/interface/DYTParamsObject.h" -#include "CondFormats/DataRecord/interface/DYTParamsObjectRcd.h" -#include "CondCore/DBOutputService/interface/PoolDBOutputService.h" -#include "FWCore/ServiceRegistry/interface/Service.h" -#include "FWCore/Framework/interface/ConsumesCollector.h" -#include "DataFormats/DetId/interface/DetId.h" - -#include -#include -#include - -#include -#include -#include - -class DYTParamsWriter : public edm::EDAnalyzer -{ - -public: - - explicit DYTParamsWriter(const edm::ParameterSet&); - ~DYTParamsWriter(); - - static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); - - virtual void endRun(edm::Run const&, edm::EventSetup const&) override; - virtual void analyze(edm::Event const&, edm::EventSetup const&) override; - virtual void endJob() override; - -private: - - void parseLine(std::string & line, uint32_t & id, std::vector & pars); - int getNParamsFromFunction(); - - const std::string m_inputFileName; - const std::string m_inputFunction; - - edm::Service m_poolDbService; - - DYTParamsObject * m_params; - -}; - - -DYTParamsWriter::DYTParamsWriter(const edm::ParameterSet& iConfig) : - m_inputFileName(iConfig.getParameter("inputFileName")), - m_inputFunction(iConfig.getParameter("inputFunction")) -{ - - if( !m_poolDbService.isAvailable() ) - throw cms::Exception("NotAvailable") << "[DYTParamsWriter::DYTParamsWriter] " - << "PoolDBOutputService is not available."; - - if (!m_poolDbService->isNewTagRequest("DYTParamsObjectRcd")) - throw cms::Exception("ObjectExists") << "[DYTParamsWriter::DYTParamsWriter] " - << "The output file already contains a valid " - << "\"DYTParamsObjectRcd\" record." << std::endl - << "Please provide a different file name or tag."; - - m_params = new DYTParamsObject; - -} - - -DYTParamsWriter::~DYTParamsWriter() -{ - -} - - -void DYTParamsWriter::analyze(edm::Event const&, edm::EventSetup const&) -{ - -} - - -void DYTParamsWriter::endRun(edm::Run const&, edm::EventSetup const&) -{ - - std::ifstream inputFile(m_inputFileName.c_str()); - - int nLines=0; - uint32_t nParams=getNParamsFromFunction(); - - m_params->setFormula(m_inputFunction); - - std::string line; - - while(std::getline(inputFile, line)) - { - - nLines++; - - uint32_t id; - std::vector params; - - parseLine(line, id, params); - - if ( nParams != params.size() ) - throw cms::Exception("ConfigFileError") << "[DYTParamsWriter::endRun] " - << "# of parameters in line " << nLines - << " differs from the one expected from" - << " the parametrized function (" << nParams << ")."; - - DYTParamObject obj(id, params); - m_params->addParamObject(obj); - - } - - edm::LogInfo("DYTParamsWriter") - << "Processed " << nLines << " lines with " - << nParams << " parameters for each line."; - - inputFile.close(); - -} - - -void DYTParamsWriter::endJob() -{ - - // Writing to DB - if( m_poolDbService.isAvailable() ) - m_poolDbService->writeOne(m_params, m_poolDbService->beginOfTime(), "DYTParamsObjectRcd"); - else - throw cms::Exception("NotAvailable") << "[DYTParamsWriter::endJob] " - << "PoolDBOutputService is not available."; -} - - -void DYTParamsWriter::parseLine(std::string & line, uint32_t & id, std::vector & pars) -{ - - std::vector elements; - boost::algorithm::split(elements,line,boost::algorithm::is_any_of(" \t\n")); - if (elements.size() < 2) - { - throw cms::Exception("ConfigFileError") << "[DYTParamsWriter::parseLine] " - << "Wrong number of entries in line : \"" - << line << "\" ." << std::endl; - } - else - { - id = atoi(elements[0].c_str()); - for (uint32_t i=1; i < elements.size(); ++i) - pars.push_back(atof(elements[i].c_str())); - } - -} - - -int DYTParamsWriter::getNParamsFromFunction() -{ - - std::vector parameters; - boost::regex reg("\\[[0-9]+\\]"); - - boost::sregex_token_iterator rIt(m_inputFunction.begin(), m_inputFunction.end(), reg, 0); - boost::sregex_token_iterator rEnd; - - int nParams = 0; - for( ; rIt != rEnd; ++rIt ) - nParams++; - - return nParams; - -} - - -void DYTParamsWriter::fillDescriptions(edm::ConfigurationDescriptions& descriptions) -{ - - //The following says we do not know what parameters are allowed so do no validation - // Please change this to state exactly what you do use, even if it is no parameters - edm::ParameterSetDescription desc; - desc.add("inputFileName", "dyt_params.txt"); - desc.add("inputFunction", "[0]*x + [1]*x^[2]"); - descriptions.add("dytParamsWriter",desc); - -} - -DEFINE_FWK_MODULE(DYTParamsWriter); diff --git a/RecoMuon/GlobalTrackingTools/test/writeDytParamsFromFile_cfg.py b/RecoMuon/GlobalTrackingTools/test/writeDytParamsFromFile_cfg.py deleted file mode 100644 index 0714a49154ee2..0000000000000 --- a/RecoMuon/GlobalTrackingTools/test/writeDytParamsFromFile_cfg.py +++ /dev/null @@ -1,33 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -process = cms.Process("WriteDYTParamsFromFile") - -process.source = cms.Source("EmptySource", - numberEventsInRun = cms.untracked.uint32(1), - firstRun = cms.untracked.uint32(1) - ) - -process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(1) ) - -process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") - -process.GlobalTag.globaltag = "PRE_LS172_V15::All" - -process.PoolDBOutputService = cms.Service("PoolDBOutputService", - process.CondDBSetup, - timetype = cms.untracked.string('runnumber'), - connect = cms.string('sqlite_file:dytParamsFromFile.db'), - authenticationMethod = cms.untracked.uint32(0), - toPut = cms.VPSet(cms.PSet(record = cms.string('DYTParamsObjectRcd'), - tag = cms.string('test') - ) - ) - ) - -process.dytParamsWriter = cms.EDAnalyzer("DYTParamsWriter", - inputFileName = cms.string("dyt_params_example.txt"), - inputFunction = cms.string("[0]x+[1]") - ) - - -process.clientPath = cms.Path(process.dytParamsWriter) From db7b1f56e96d8812a80eefbc581c75d44558c590 Mon Sep 17 00:00:00 2001 From: Carlo Battilana Date: Fri, 5 Dec 2014 15:51:20 +0100 Subject: [PATCH 09/28] BulidFile fix : removed DYTParamsWriter --- RecoMuon/GlobalTrackingTools/test/BuildFile.xml | 3 --- 1 file changed, 3 deletions(-) diff --git a/RecoMuon/GlobalTrackingTools/test/BuildFile.xml b/RecoMuon/GlobalTrackingTools/test/BuildFile.xml index 17ffffff5b452..6ed089d915d5e 100644 --- a/RecoMuon/GlobalTrackingTools/test/BuildFile.xml +++ b/RecoMuon/GlobalTrackingTools/test/BuildFile.xml @@ -6,6 +6,3 @@ - - - From 4f6ba707126caa27a989efba8614869c0cab14d1 Mon Sep 17 00:00:00 2001 From: Bill Ford Date: Fri, 5 Dec 2014 16:12:16 -0700 Subject: [PATCH 10/28] Option to use old CPE error if charge exceeds one MIP --- .../interface/StripCPEfromTrackAngle.h | 5 +++++ .../python/StripCPEfromTrackAngle_cfi.py | 1 + .../src/StripCPEfromTrackAngle.cc | 11 ++++++++++- 3 files changed, 16 insertions(+), 1 deletion(-) diff --git a/RecoLocalTracker/SiStripRecHitConverter/interface/StripCPEfromTrackAngle.h b/RecoLocalTracker/SiStripRecHitConverter/interface/StripCPEfromTrackAngle.h index 13b04123862e0..815243449bb38 100644 --- a/RecoLocalTracker/SiStripRecHitConverter/interface/StripCPEfromTrackAngle.h +++ b/RecoLocalTracker/SiStripRecHitConverter/interface/StripCPEfromTrackAngle.h @@ -20,6 +20,10 @@ class StripCPEfromTrackAngle : public StripCPE //Set to true if we are using the old error parameterization const bool useLegacyError; + //Clusters with charge/path > this cut will use old error parameterization + // (overridden by useLegacyError; negative value disables the cut) + const float maxChgOneMIP; + public: StripClusterParameterEstimator::LocalValues localParameters( const SiStripCluster&, const GeomDetUnit&, const LocalTrajectoryParameters&) const; @@ -36,6 +40,7 @@ class StripCPEfromTrackAngle : public StripCPE const SiStripLatency& latency) : StripCPE(conf, mag, geom, lorentz, backPlaneCorrection, confObj, latency ) , useLegacyError(conf.existsAs("useLegacyError") ? conf.getParameter("useLegacyError") : true) + , maxChgOneMIP(conf.existsAs("maxChgOneMIP") ? conf.getParameter("maxChgOneMIP") : -6000.) { mLC_P[0] = conf.existsAs("mLC_P0") ? conf.getParameter("mLC_P0") : -.326; mLC_P[1] = conf.existsAs("mLC_P1") ? conf.getParameter("mLC_P1") : .618; diff --git a/RecoLocalTracker/SiStripRecHitConverter/python/StripCPEfromTrackAngle_cfi.py b/RecoLocalTracker/SiStripRecHitConverter/python/StripCPEfromTrackAngle_cfi.py index cada6cf223584..ccad7ddc914a6 100644 --- a/RecoLocalTracker/SiStripRecHitConverter/python/StripCPEfromTrackAngle_cfi.py +++ b/RecoLocalTracker/SiStripRecHitConverter/python/StripCPEfromTrackAngle_cfi.py @@ -17,4 +17,5 @@ mTEC_P0 = cms.double(-1.885), mTEC_P1 = cms.double( .471), useLegacyError = cms.bool(True), + maxChgOneMIP = cms.double(-6000.) ) diff --git a/RecoLocalTracker/SiStripRecHitConverter/src/StripCPEfromTrackAngle.cc b/RecoLocalTracker/SiStripRecHitConverter/src/StripCPEfromTrackAngle.cc index 64bacb51ea5bb..7d37145e6c4cf 100644 --- a/RecoLocalTracker/SiStripRecHitConverter/src/StripCPEfromTrackAngle.cc +++ b/RecoLocalTracker/SiStripRecHitConverter/src/StripCPEfromTrackAngle.cc @@ -1,5 +1,6 @@ #include "RecoLocalTracker/SiStripRecHitConverter/interface/StripCPEfromTrackAngle.h" #include "Geometry/CommonTopologies/interface/StripTopology.h" +#include "DataFormats/SiStripCluster/interface/SiStripClusterTools.h" #include "vdt/vdtMath.h" @@ -38,7 +39,15 @@ localParameters( const SiStripCluster& cluster, const GeomDetUnit& det, const Lo const unsigned N = cluster.amplitudes().size(); const float fullProjection = p.coveredStrips( track+p.drift, ltp.position()); - const float uerr2 = useLegacyError || cluster.isMerged() ? legacyStripErrorSquared(N,std::abs(fullProjection)) : stripErrorSquared( N, std::abs(fullProjection),ssdid.subDetector() ); + float uerr2; + if (useLegacyError) { + uerr2 = legacyStripErrorSquared(N,std::abs(fullProjection)); + } else if (maxChgOneMIP < 0.0) { + uerr2 = cluster.isMerged() ? legacyStripErrorSquared(N,std::abs(fullProjection)) : stripErrorSquared( N, std::abs(fullProjection),ssdid.subDetector() ); + } else { + float dQdx = siStripClusterTools::chargePerCM(ssdid, cluster, ltp); + uerr2 = dQdx > maxChgOneMIP ? legacyStripErrorSquared(N,std::abs(fullProjection)) : stripErrorSquared( N, std::abs(fullProjection),ssdid.subDetector() ); + } const float strip = cluster.barycenter() - 0.5f*(1.f-p.backplanecorrection) * fullProjection + 0.5f*p.coveredStrips(track, ltp.position()); From 3d846b2c704ee8f9af8405a45020e36caf35dc94 Mon Sep 17 00:00:00 2001 From: "W. David Dagenhart" Date: Tue, 9 Dec 2014 09:23:26 -0600 Subject: [PATCH 11/28] Add service callback with path and consumes info Add new callback that services can register for that will deliver information about the paths, end paths, and modules on them. It will also deliver information about the dependencies between modules in the current process based on the consumes information. It also makes available the information in the consumes declarations. Also includes a new configuration option to the Tracer that will dump this information and the Tracer code is an example of how a service accesses this information. New and expanded unit tests included. --- .../interface/ProductHolderIndexHelper.h | 2 + .../Provenance/interface/ProductRegistry.h | 7 + .../src/ProductHolderIndexHelper.cc | 20 +++ DataFormats/Provenance/src/ProductRegistry.cc | 3 + .../productHolderIndexHelper_t.cppunit.cc | 4 + FWCore/Framework/interface/EDConsumerBase.h | 16 +- FWCore/Framework/interface/EventProcessor.h | 2 + .../interface/PathsAndConsumesOfModules.h | 72 ++++++++ FWCore/Framework/interface/Schedule.h | 27 +++ FWCore/Framework/interface/SubProcess.h | 4 + .../interface/stream/EDAnalyzerAdaptorBase.h | 11 ++ .../stream/ProducingModuleAdaptorBase.h | 10 ++ FWCore/Framework/src/EDConsumerBase.cc | 152 +++++++++++++++- FWCore/Framework/src/EventProcessor.cc | 3 + .../src/PathsAndConsumesOfModules.cc | 95 ++++++++++ FWCore/Framework/src/Schedule.cc | 56 ++++++ FWCore/Framework/src/StreamSchedule.cc | 68 +++++++ FWCore/Framework/src/StreamSchedule.h | 16 ++ FWCore/Framework/src/SubProcess.cc | 4 + FWCore/Framework/src/Worker.h | 9 + FWCore/Framework/src/WorkerT.h | 15 ++ .../src/stream/EDAnalyzerAdaptorBase.cc | 16 ++ .../src/stream/ProducingModuleAdaptorBase.cc | 18 ++ .../Framework/test/productregistry.cppunit.cc | 23 ++- FWCore/Framework/test/stubs/ToyAnalyzers.cc | 27 +++ .../Framework/test/stubs/ToyIntProducers.cc | 34 ++++ .../test_deepCall_allowUnscheduled_true.log | 1 + FWCore/Integration/test/run_TestGetBy.sh | 14 +- .../Integration/test/testConsumesInfo_cfg.py | 151 ++++++++++++++++ .../unit_test_outputs/testConsumesInfo_1.log | 167 ++++++++++++++++++ .../test/unit_test_outputs/testGetBy1.log | 2 + .../test/unit_test_outputs/testGetBy2.log | 1 + .../testSubProcess.grep2.txt | 5 + .../interface/ActivityRegistry.h | 13 +- .../ServiceRegistry/interface/ConsumesInfo.h | 66 +++++++ .../interface/PathsAndConsumesOfModulesBase.h | 95 ++++++++++ .../ServiceRegistry/src/ActivityRegistry.cc | 3 + FWCore/ServiceRegistry/src/ConsumesInfo.cc | 22 +++ .../src/PathsAndConsumesOfModulesBase.cc | 7 + FWCore/Services/src/Tracer.cc | 97 ++++++++++ FWCore/Services/src/Tracer.h | 4 + 41 files changed, 1348 insertions(+), 14 deletions(-) create mode 100644 FWCore/Framework/interface/PathsAndConsumesOfModules.h create mode 100644 FWCore/Framework/src/PathsAndConsumesOfModules.cc create mode 100644 FWCore/Integration/test/testConsumesInfo_cfg.py create mode 100644 FWCore/Integration/test/unit_test_outputs/testConsumesInfo_1.log create mode 100644 FWCore/ServiceRegistry/interface/ConsumesInfo.h create mode 100644 FWCore/ServiceRegistry/interface/PathsAndConsumesOfModulesBase.h create mode 100644 FWCore/ServiceRegistry/src/ConsumesInfo.cc create mode 100644 FWCore/ServiceRegistry/src/PathsAndConsumesOfModulesBase.cc diff --git a/DataFormats/Provenance/interface/ProductHolderIndexHelper.h b/DataFormats/Provenance/interface/ProductHolderIndexHelper.h index 1aebea0a42167..26ade16e7296c 100644 --- a/DataFormats/Provenance/interface/ProductHolderIndexHelper.h +++ b/DataFormats/Provenance/interface/ProductHolderIndexHelper.h @@ -125,6 +125,8 @@ namespace edm { ProductHolderIndex index(unsigned int i) const; unsigned int numberOfMatches() const { return numberOfMatches_; } bool isFullyResolved(unsigned int i) const; + char const* moduleLabel(unsigned int i) const; + char const* processName(unsigned int i) const; private: ProductHolderIndexHelper const* productHolderIndexHelper_; unsigned int startInIndexAndNames_; diff --git a/DataFormats/Provenance/interface/ProductRegistry.h b/DataFormats/Provenance/interface/ProductRegistry.h index 109ed5e034f7e..3ee7874e4f61b 100644 --- a/DataFormats/Provenance/interface/ProductRegistry.h +++ b/DataFormats/Provenance/interface/ProductRegistry.h @@ -20,6 +20,7 @@ #include #include #include +#include #include #include "FWCore/Utilities/interface/HideStdSharedPtrFromRoot.h" @@ -118,6 +119,10 @@ namespace edm { return transient_.missingDictionaries_; } + std::vector > const& aliasToOriginal() const { + return transient_.aliasToOriginal_; + } + ProductHolderIndex const& getNextIndexValue(BranchType branchType) const; void initializeTransients() {transient_.reset();} @@ -144,6 +149,8 @@ namespace edm { std::map branchIDToIndex_; std::vector missingDictionaries_; + + std::vector > aliasToOriginal_; }; private: diff --git a/DataFormats/Provenance/src/ProductHolderIndexHelper.cc b/DataFormats/Provenance/src/ProductHolderIndexHelper.cc index 0822a88b76cd0..46321d0192f6c 100644 --- a/DataFormats/Provenance/src/ProductHolderIndexHelper.cc +++ b/DataFormats/Provenance/src/ProductHolderIndexHelper.cc @@ -110,6 +110,26 @@ namespace edm { return (productHolderIndexHelper_->indexAndNames_[startInIndexAndNames_ + i].startInProcessNames() != 0U); } + char const* + ProductHolderIndexHelper::Matches::processName(unsigned int i) const { + if (i >= numberOfMatches_) { + throw Exception(errors::LogicError) + << "ProductHolderIndexHelper::Matches::processName - Argument is out of range.\n"; + } + unsigned int startInProcessNames = productHolderIndexHelper_->indexAndNames_[startInIndexAndNames_ + i].startInProcessNames(); + return &productHolderIndexHelper_->processNames_[startInProcessNames]; + } + + char const* + ProductHolderIndexHelper::Matches::moduleLabel(unsigned int i) const { + if (i >= numberOfMatches_) { + throw Exception(errors::LogicError) + << "ProductHolderIndexHelper::Matches::moduleLabel - Argument is out of range.\n"; + } + unsigned int start = productHolderIndexHelper_->indexAndNames_[startInIndexAndNames_ + i].startInBigNamesContainer(); + return &productHolderIndexHelper_->bigNamesContainer_[start]; + } + ProductHolderIndexHelper::Matches ProductHolderIndexHelper::relatedIndexes(KindOfType kindOfType, TypeID const& typeID, diff --git a/DataFormats/Provenance/src/ProductRegistry.cc b/DataFormats/Provenance/src/ProductRegistry.cc index 9b082ad45c82c..53967d48aee64 100644 --- a/DataFormats/Provenance/src/ProductRegistry.cc +++ b/DataFormats/Provenance/src/ProductRegistry.cc @@ -108,6 +108,8 @@ namespace edm { std::pair ret = productList_.insert(std::make_pair(BranchKey(bd), bd)); assert(ret.second); + transient_.aliasToOriginal_.emplace_back(labelAlias, + productDesc.moduleLabel()); addCalled(bd, false); } @@ -151,6 +153,7 @@ namespace edm { if(initializeLookupInfo) { initializeLookupTables(); } + sort_all(transient_.aliasToOriginal_); } void diff --git a/DataFormats/Provenance/test/productHolderIndexHelper_t.cppunit.cc b/DataFormats/Provenance/test/productHolderIndexHelper_t.cppunit.cc index 1771e295ecd18..aa1603465f02d 100644 --- a/DataFormats/Provenance/test/productHolderIndexHelper_t.cppunit.cc +++ b/DataFormats/Provenance/test/productHolderIndexHelper_t.cppunit.cc @@ -214,6 +214,10 @@ void TestProductHolderIndexHelper::testManyEntries() { CPPUNIT_ASSERT(indexB2 == 18); CPPUNIT_ASSERT(indexB3 == 17); + CPPUNIT_ASSERT(std::string(matches.moduleLabel(4)) == "labelB"); + CPPUNIT_ASSERT(std::string(matches.processName(4)) == "processB3"); + CPPUNIT_ASSERT(std::string(matches.processName(0)) == ""); + matches = helper.relatedIndexes(ELEMENT_TYPE, typeID_Simple); CPPUNIT_ASSERT(matches.numberOfMatches() == 2); ProductHolderIndex indexC = matches.index(1); diff --git a/FWCore/Framework/interface/EDConsumerBase.h b/FWCore/Framework/interface/EDConsumerBase.h index b3e3b6a596dc1..93abe44a5f51f 100644 --- a/FWCore/Framework/interface/EDConsumerBase.h +++ b/FWCore/Framework/interface/EDConsumerBase.h @@ -19,10 +19,13 @@ // // system include files +#include +#include #include // user include files #include "FWCore/Framework/interface/ProductHolderIndexAndSkipBit.h" +#include "FWCore/ServiceRegistry/interface/ConsumesInfo.h" #include "FWCore/Utilities/interface/TypeID.h" #include "FWCore/Utilities/interface/TypeToGet.h" #include "FWCore/Utilities/interface/InputTag.h" @@ -36,7 +39,9 @@ // forward declarations namespace edm { + class ModuleDescription; class ProductHolderIndexHelper; + class ProductRegistry; class ConsumesCollector; template class WillGetIfMatch; @@ -75,7 +80,14 @@ namespace edm { void modulesDependentUpon(const std::string& iProcessName, std::vector& oModuleLabels) const; - + + void modulesWhoseProductsAreConsumed(std::vector& modules, + ProductRegistry const& preg, + std::map const& labelsToDesc, + std::string const& processName) const; + + std::vector consumesInfo() const; + protected: friend class ConsumesCollector; template friend class WillGetIfMatch; @@ -133,7 +145,7 @@ namespace edm { const EDConsumerBase& operator=(const EDConsumerBase&) = delete; unsigned int recordConsumes(BranchType iBranch, TypeToGet const& iType, edm::InputTag const& iTag, bool iAlwaysGets); - + void throwTypeMismatch(edm::TypeID const&, EDGetToken) const; void throwBranchMismatch(BranchType, EDGetToken) const; void throwBadToken(edm::TypeID const& iType, EDGetToken iToken) const; diff --git a/FWCore/Framework/interface/EventProcessor.h b/FWCore/Framework/interface/EventProcessor.h index 5ac2fd10ee878..1529154a61f8a 100644 --- a/FWCore/Framework/interface/EventProcessor.h +++ b/FWCore/Framework/interface/EventProcessor.h @@ -15,6 +15,7 @@ configured in the user's main() function, and is set running. #include "FWCore/Framework/interface/Frameworkfwd.h" #include "FWCore/Framework/interface/IEventProcessor.h" #include "FWCore/Framework/interface/InputSource.h" +#include "FWCore/Framework/interface/PathsAndConsumesOfModules.h" #include "FWCore/Framework/src/PrincipalCache.h" #include "FWCore/Framework/src/SignallingProductRegistry.h" #include "FWCore/Framework/src/PreallocationConfiguration.h" @@ -264,6 +265,7 @@ namespace edm { std::unique_ptr act_table_; std::shared_ptr processConfiguration_; ProcessContext processContext_; + PathsAndConsumesOfModules pathsAndConsumesOfModules_; std::auto_ptr schedule_; std::auto_ptr subProcess_; std::unique_ptr historyAppender_; diff --git a/FWCore/Framework/interface/PathsAndConsumesOfModules.h b/FWCore/Framework/interface/PathsAndConsumesOfModules.h new file mode 100644 index 0000000000000..8653bf7c4d88d --- /dev/null +++ b/FWCore/Framework/interface/PathsAndConsumesOfModules.h @@ -0,0 +1,72 @@ +#ifndef FWCore_Framework_PathsAndConsumesOfModules_h +#define FWCore_Framework_PathsAndConsumesOfModules_h + +/**\class edm::PathsAndConsumesOfModules + + Description: See comments in the base class + + Usage: + +*/ +// +// Original Author: W. David Dagenhart +// Created: 11/5/2014 + +#include "FWCore/ServiceRegistry/interface/ConsumesInfo.h" +#include "FWCore/ServiceRegistry/interface/PathsAndConsumesOfModulesBase.h" + +#include +#include +#include +#include + +namespace edm { + + class ModuleDescription; + class ProductRegistry; + class Schedule; + + class PathsAndConsumesOfModules : public PathsAndConsumesOfModulesBase { + public: + + virtual ~PathsAndConsumesOfModules(); + + void initialize(Schedule const*, std::shared_ptr); + + private: + + virtual std::vector const& doPaths() const override { return paths_; } + virtual std::vector const& doEndPaths() const override { return endPaths_; } + + virtual std::vector const& doAllModules() const override { return allModuleDescriptions_; } + virtual ModuleDescription const* doModuleDescription(unsigned int moduleID) const override; + + virtual std::vector const& doModulesOnPath(unsigned int pathIndex) const override; + virtual std::vector const& doModulesOnEndPath(unsigned int endPathIndex) const override; + virtual std::vector const& doModulesWhoseProductsAreConsumedBy(unsigned int moduleID) const override; + + virtual std::vector doConsumesInfo(unsigned int moduleID) const override; + + unsigned int moduleIndex(unsigned int moduleID) const; + + // data members + + std::vector paths_; + std::vector endPaths_; + + std::vector allModuleDescriptions_; + + std::vector > modulesOnPaths_; + std::vector > modulesOnEndPaths_; + + // Gives a translation from the module ID to the index into the + // following data member + std::vector > moduleIDToIndex_; + + std::vector > modulesWhoseProductsAreConsumedBy_; + + Schedule const* schedule_; + std::shared_ptr preg_; + }; +} +#endif diff --git a/FWCore/Framework/interface/Schedule.h b/FWCore/Framework/interface/Schedule.h index 0453b20e496e7..a549f27ad9a66 100644 --- a/FWCore/Framework/interface/Schedule.h +++ b/FWCore/Framework/interface/Schedule.h @@ -88,6 +88,7 @@ #include #include #include +#include namespace edm { @@ -100,6 +101,7 @@ namespace edm { class ExceptionCollector; class OutputModuleCommunicator; class ProcessContext; + class ProductRegistry; class PreallocationConfiguration; class StreamSchedule; class GlobalSchedule; @@ -190,10 +192,35 @@ namespace edm { ///adds to oLabelsToFill the labels for all paths in the process void availablePaths(std::vector& oLabelsToFill) const; + ///Adds to oLabelsToFill the labels for all trigger paths in the process. + ///This is different from availablePaths because it includes the + ///empty paths to match the entries in TriggerResults exactly. + void triggerPaths(std::vector& oLabelsToFill) const; + + ///adds to oLabelsToFill the labels for all end paths in the process + void endPaths(std::vector& oLabelsToFill) const; + ///adds to oLabelsToFill in execution order the labels of all modules in path iPathLabel void modulesInPath(std::string const& iPathLabel, std::vector& oLabelsToFill) const; + ///adds the ModuleDescriptions into the vector for the modules scheduled in path iPathLabel + ///hint is a performance optimization if you might know the position of the module in the path + void moduleDescriptionsInPath(std::string const& iPathLabel, + std::vector& descriptions, + unsigned int hint) const; + + ///adds the ModuleDescriptions into the vector for the modules scheduled in path iEndPathLabel + ///hint is a performance optimization if you might know the position of the module in the path + void moduleDescriptionsInEndPath(std::string const& iEndPathLabel, + std::vector& descriptions, + unsigned int hint) const; + + void fillModuleAndConsumesInfo(std::vector& allModuleDescriptions, + std::vector >& moduleIDToIndex, + std::vector >& modulesWhoseProductsAreConsumedBy, + ProductRegistry const& preg) const; + /// Return the number of events this Schedule has tried to process /// (inclues both successes and failures, including failures due /// to exceptions during processing). diff --git a/FWCore/Framework/interface/SubProcess.h b/FWCore/Framework/interface/SubProcess.h index a507b951595d4..b854562b3f882 100644 --- a/FWCore/Framework/interface/SubProcess.h +++ b/FWCore/Framework/interface/SubProcess.h @@ -3,6 +3,7 @@ #include "DataFormats/Provenance/interface/BranchID.h" #include "FWCore/Framework/interface/EventSetupProvider.h" +#include "FWCore/Framework/interface/PathsAndConsumesOfModules.h" #include "FWCore/Framework/src/PrincipalCache.h" #include "FWCore/Framework/interface/ScheduleItems.h" #include "FWCore/Framework/interface/Schedule.h" @@ -23,6 +24,7 @@ #include namespace edm { + class ActivityRegistry; class BranchDescription; class BranchIDListHelper; class HistoryAppender; @@ -229,6 +231,7 @@ namespace edm { } + std::shared_ptr actReg_; ServiceToken serviceToken_; std::shared_ptr parentPreg_; std::shared_ptr preg_; @@ -237,6 +240,7 @@ namespace edm { std::unique_ptr act_table_; std::shared_ptr processConfiguration_; ProcessContext processContext_; + PathsAndConsumesOfModules pathsAndConsumesOfModules_; //We require 1 history for each Run, Lumi and Stream // The vectors first hold Stream info, then Lumi then Run unsigned int historyLumiOffset_; diff --git a/FWCore/Framework/interface/stream/EDAnalyzerAdaptorBase.h b/FWCore/Framework/interface/stream/EDAnalyzerAdaptorBase.h index fd70770027d54..2628aa09bc4c6 100644 --- a/FWCore/Framework/interface/stream/EDAnalyzerAdaptorBase.h +++ b/FWCore/Framework/interface/stream/EDAnalyzerAdaptorBase.h @@ -19,6 +19,8 @@ // // system include files +#include +#include #include // user include files @@ -27,6 +29,7 @@ #include "FWCore/Framework/interface/Frameworkfwd.h" #include "DataFormats/Provenance/interface/ModuleDescription.h" #include "FWCore/ParameterSet/interface/ParameterSetfwd.h" +#include "FWCore/ServiceRegistry/interface/ConsumesInfo.h" #include "FWCore/Utilities/interface/StreamID.h" #include "FWCore/Utilities/interface/RunIndex.h" #include "FWCore/Utilities/interface/LuminosityBlockIndex.h" @@ -90,6 +93,14 @@ namespace edm { void modulesDependentUpon(const std::string& iProcessName, std::vector& oModuleLabels) const; + + void modulesWhoseProductsAreConsumed(std::vector& modules, + ProductRegistry const& preg, + std::map const& labelsToDesc, + std::string const& processName) const; + + std::vector consumesInfo() const; + private: EDAnalyzerAdaptorBase(const EDAnalyzerAdaptorBase&); // stop default diff --git a/FWCore/Framework/interface/stream/ProducingModuleAdaptorBase.h b/FWCore/Framework/interface/stream/ProducingModuleAdaptorBase.h index 03bdfa363cf9a..c24288d12a0a7 100644 --- a/FWCore/Framework/interface/stream/ProducingModuleAdaptorBase.h +++ b/FWCore/Framework/interface/stream/ProducingModuleAdaptorBase.h @@ -19,6 +19,9 @@ // // system include files +#include +#include +#include // user include files #include "DataFormats/Provenance/interface/BranchType.h" @@ -32,6 +35,7 @@ #include "FWCore/Framework/interface/Event.h" #include "FWCore/Framework/interface/Run.h" #include "FWCore/Framework/interface/LuminosityBlock.h" +#include "FWCore/ServiceRegistry/interface/ConsumesInfo.h" // forward declarations @@ -81,6 +85,12 @@ namespace edm { void modulesDependentUpon(const std::string& iProcessName, std::vector& oModuleLabels) const; + void modulesWhoseProductsAreConsumed(std::vector& modules, + ProductRegistry const& preg, + std::map const& labelsToDesc, + std::string const& processName) const; + + std::vector consumesInfo() const; protected: template void createStreamModules(F iFunc) { diff --git a/FWCore/Framework/src/EDConsumerBase.cc b/FWCore/Framework/src/EDConsumerBase.cc index defbc1eb108d1..57389241f5ef7 100644 --- a/FWCore/Framework/src/EDConsumerBase.cc +++ b/FWCore/Framework/src/EDConsumerBase.cc @@ -11,16 +11,20 @@ // // system include files +#include #include -#include #include +#include +#include // user include files #include "FWCore/Framework/interface/EDConsumerBase.h" #include "FWCore/Framework/interface/ConsumesCollector.h" +#include "FWCore/Utilities/interface/BranchType.h" #include "FWCore/Utilities/interface/Likely.h" #include "FWCore/Utilities/interface/Exception.h" #include "DataFormats/Provenance/interface/ProductHolderIndexHelper.h" +#include "DataFormats/Provenance/interface/ProductRegistry.h" using namespace edm; @@ -376,9 +380,7 @@ namespace { void EDConsumerBase::modulesDependentUpon(const std::string& iProcessName, - std::vector& oModuleLabels - ) const -{ + std::vector& oModuleLabels) const { std::set uniqueModules; for(unsigned int index=0, iEnd=m_tokenInfo.size();index (index); @@ -396,6 +398,142 @@ EDConsumerBase::modulesDependentUpon(const std::string& iProcessName, oModuleLabels = std::vector(uniqueModules.begin(),uniqueModules.end()); } -// -// static member functions -// + +namespace { + void + insertFoundModuleLabel(const char* consumedModuleLabel, + std::vector& modules, + std::set& alreadyFound, + std::map const& labelsToDesc, + ProductRegistry const& preg) { + // Convert from label string to module description, eliminate duplicates, + // then insert into the vector of modules + auto it = labelsToDesc.find(consumedModuleLabel); + if(it != labelsToDesc.end()) { + if(alreadyFound.insert(consumedModuleLabel).second) { + modules.push_back(it->second); + } + return; + } + // Deal with EDAlias's by converting to the original module label first + std::vector > const& aliasToOriginal = preg.aliasToOriginal(); + std::pair target(consumedModuleLabel, std::string()); + auto iter = std::lower_bound(aliasToOriginal.begin(), aliasToOriginal.end(), target); + if(iter != aliasToOriginal.end() && iter->first == consumedModuleLabel) { + + std::string const& originalModuleLabel = iter->second; + auto iter2 = labelsToDesc.find(originalModuleLabel); + if(iter2 != labelsToDesc.end()) { + if(alreadyFound.insert(originalModuleLabel).second) { + modules.push_back(iter2->second); + } + return; + } + } + // Ignore the source products, we are only interested in module products. + // As far as I know, it should never be anything else so throw if something + // unknown gets passed in. + if(std::string(consumedModuleLabel) != "source") { + throw cms::Exception("EDConsumerBase", "insertFoundModuleLabel") + << "Couldn't find ModuleDescription for the consumed module label: " + << std::string(consumedModuleLabel) << "\n"; + } + } +} + +void +EDConsumerBase::modulesWhoseProductsAreConsumed(std::vector& modules, + ProductRegistry const& preg, + std::map const& labelsToDesc, + std::string const& processName) const { + + ProductHolderIndexHelper const& iHelper = *preg.productLookup(InEvent); + + std::set alreadyFound; + + auto itKind = m_tokenInfo.begin(); + auto itLabels = m_tokenInfo.begin(); + for(auto itInfo = m_tokenInfo.begin(),itEnd = m_tokenInfo.end(); + itInfo != itEnd; ++itInfo,++itKind,++itLabels) { + + if(itInfo->m_branchType == InEvent) { + + const unsigned int labelStart = itLabels->m_startOfModuleLabel; + const char* consumedModuleLabel = &(m_tokenLabels[labelStart]); + const char* consumedProcessName = consumedModuleLabel+itLabels->m_deltaToProcessName; + + if(*consumedModuleLabel != '\0') { // not a consumesMany + if(*consumedProcessName != '\0') { // process name is specified in consumes call + if (processName == consumedProcessName && + iHelper.index(*itKind, + itInfo->m_type, + consumedModuleLabel, + consumedModuleLabel+itLabels->m_deltaToProductInstance, + consumedModuleLabel+itLabels->m_deltaToProcessName) != ProductHolderIndexInvalid) { + insertFoundModuleLabel(consumedModuleLabel, modules, alreadyFound, labelsToDesc, preg); + } + } else { // process name was empty + auto matches = iHelper.relatedIndexes(*itKind, + itInfo->m_type, + consumedModuleLabel, + consumedModuleLabel+itLabels->m_deltaToProductInstance); + for(unsigned int j = 0; j < matches.numberOfMatches(); ++j) { + if(processName == matches.processName(j)) { + insertFoundModuleLabel(consumedModuleLabel, modules, alreadyFound, labelsToDesc, preg); + } + } + } + // consumesMany case + } else if(itInfo->m_index.productHolderIndex() == ProductHolderIndexInvalid) { + auto matches = iHelper.relatedIndexes(*itKind, + itInfo->m_type); + for(unsigned int j = 0; j < matches.numberOfMatches(); ++j) { + if(processName == matches.processName(j)) { + insertFoundModuleLabel(matches.moduleLabel(j), modules, alreadyFound, labelsToDesc, preg); + } + } + } + } + } +} + +std::vector +EDConsumerBase::consumesInfo() const { + + // Use this to eliminate duplicate entries related + // to consumesMany items where only the type was specified + // and the there are multiple matches. In these cases the + // label, instance, and process will be empty. + std::set alreadySeenTypes; + + std::vector result; + auto itAlways = m_tokenInfo.begin(); + auto itKind = m_tokenInfo.begin(); + auto itLabels = m_tokenInfo.begin(); + for(auto itInfo = m_tokenInfo.begin(),itEnd = m_tokenInfo.end(); + itInfo != itEnd; ++itInfo,++itKind,++itLabels, ++itAlways) { + + const unsigned int labelStart = itLabels->m_startOfModuleLabel; + const char* consumedModuleLabel = &(m_tokenLabels[labelStart]); + const char* consumedInstance = consumedModuleLabel+itLabels->m_deltaToProductInstance; + const char* consumedProcessName = consumedModuleLabel+itLabels->m_deltaToProcessName; + + // consumesMany case + if(*consumedModuleLabel == '\0') { + if(!alreadySeenTypes.insert(itInfo->m_type).second) { + continue; + } + } + + // Just copy the information into the ConsumesInfo data structure + result.emplace_back(itInfo->m_type, + consumedModuleLabel, + consumedInstance, + consumedProcessName, + itInfo->m_branchType, + *itKind, + *itAlways, + itInfo->m_index.skipCurrentProcess()); + } + return result; +} diff --git a/FWCore/Framework/src/EventProcessor.cc b/FWCore/Framework/src/EventProcessor.cc index 8385dc9914bf2..52daf067bfbea 100644 --- a/FWCore/Framework/src/EventProcessor.cc +++ b/FWCore/Framework/src/EventProcessor.cc @@ -593,6 +593,9 @@ namespace edm { preallocations_.numberOfRuns(), preallocations_.numberOfThreads()); actReg_->preallocateSignal_(bounds); + pathsAndConsumesOfModules_.initialize(schedule_.get(), preg_); + actReg_->preBeginJobSignal_(pathsAndConsumesOfModules_, processContext_); + //NOTE: This implementation assumes 'Job' means one call // the EventProcessor::run // If it really means once per 'application' then this code will diff --git a/FWCore/Framework/src/PathsAndConsumesOfModules.cc b/FWCore/Framework/src/PathsAndConsumesOfModules.cc new file mode 100644 index 0000000000000..4c5601847ada8 --- /dev/null +++ b/FWCore/Framework/src/PathsAndConsumesOfModules.cc @@ -0,0 +1,95 @@ +#include "FWCore/Framework/interface/PathsAndConsumesOfModules.h" + +#include "FWCore/Framework/interface/Schedule.h" +#include "FWCore/Framework/src/Worker.h" +#include "FWCore/Utilities/interface/EDMException.h" + +#include + +namespace edm { + + PathsAndConsumesOfModules::~PathsAndConsumesOfModules() { + } + + void PathsAndConsumesOfModules::initialize(Schedule const* schedule, std::shared_ptr preg) { + + schedule_ = schedule; + preg_ = preg; + + paths_.clear(); + schedule->triggerPaths(paths_); + + endPaths_.clear(); + schedule->endPaths(endPaths_); + + modulesOnPaths_.resize(paths_.size()); + unsigned int i = 0; + unsigned int hint = 0; + for(auto const& path : paths_) { + schedule->moduleDescriptionsInPath(path, modulesOnPaths_.at(i), hint); + if(!modulesOnPaths_.at(i).empty()) ++hint; + ++i; + } + + modulesOnEndPaths_.resize(endPaths_.size()); + i = 0; + hint = 0; + for(auto const& endpath : endPaths_) { + schedule->moduleDescriptionsInEndPath(endpath, modulesOnEndPaths_.at(i), hint); + if(!modulesOnEndPaths_.at(i).empty()) ++hint; + ++i; + } + + schedule->fillModuleAndConsumesInfo(allModuleDescriptions_, + moduleIDToIndex_, + modulesWhoseProductsAreConsumedBy_, + *preg); + } + + ModuleDescription const* + PathsAndConsumesOfModules::doModuleDescription(unsigned int moduleID) const { + unsigned int dummy = 0; + auto target = std::make_pair(moduleID, dummy); + std::vector >::const_iterator iter = + std::lower_bound(moduleIDToIndex_.begin(), moduleIDToIndex_.end(), target); + if (iter == moduleIDToIndex_.end() || iter->first != moduleID) { + throw Exception(errors::LogicError) + << "PathsAndConsumesOfModules::moduleDescription: Unknown moduleID\n"; + } + return allModuleDescriptions_.at(iter->second); + } + + std::vector const& + PathsAndConsumesOfModules::doModulesOnPath(unsigned int pathIndex) const { + return modulesOnPaths_.at(pathIndex); + } + + std::vector const& + PathsAndConsumesOfModules::doModulesOnEndPath(unsigned int endPathIndex) const { + return modulesOnEndPaths_.at(endPathIndex); + } + + std::vector const& + PathsAndConsumesOfModules::doModulesWhoseProductsAreConsumedBy(unsigned int moduleID) const { + return modulesWhoseProductsAreConsumedBy_.at(moduleIndex(moduleID)); + } + + std::vector + PathsAndConsumesOfModules::doConsumesInfo(unsigned int moduleID) const { + Worker const* worker = schedule_->allWorkers().at(moduleIndex(moduleID)); + return worker->consumesInfo(); + } + + unsigned int + PathsAndConsumesOfModules::moduleIndex(unsigned int moduleID) const { + unsigned int dummy = 0; + auto target = std::make_pair(moduleID, dummy); + std::vector >::const_iterator iter = + std::lower_bound(moduleIDToIndex_.begin(), moduleIDToIndex_.end(), target); + if (iter == moduleIDToIndex_.end() || iter->first != moduleID) { + throw Exception(errors::LogicError) + << "PathsAndConsumesOfModules::moduleIndex: Unknown moduleID\n"; + } + return iter->second; + } +} diff --git a/FWCore/Framework/src/Schedule.cc b/FWCore/Framework/src/Schedule.cc index 553607863ba8b..0f7c73f1087dd 100644 --- a/FWCore/Framework/src/Schedule.cc +++ b/FWCore/Framework/src/Schedule.cc @@ -1021,12 +1021,68 @@ namespace edm { streamSchedules_[0]->availablePaths(oLabelsToFill); } + void + Schedule::triggerPaths(std::vector& oLabelsToFill) const { + streamSchedules_[0]->triggerPaths(oLabelsToFill); + } + + void + Schedule::endPaths(std::vector& oLabelsToFill) const { + streamSchedules_[0]->endPaths(oLabelsToFill); + } + void Schedule::modulesInPath(std::string const& iPathLabel, std::vector& oLabelsToFill) const { streamSchedules_[0]->modulesInPath(iPathLabel,oLabelsToFill); } + void + Schedule::moduleDescriptionsInPath(std::string const& iPathLabel, + std::vector& descriptions, + unsigned int hint) const { + streamSchedules_[0]->moduleDescriptionsInPath(iPathLabel, descriptions, hint); + } + + void + Schedule::moduleDescriptionsInEndPath(std::string const& iEndPathLabel, + std::vector& descriptions, + unsigned int hint) const { + streamSchedules_[0]->moduleDescriptionsInEndPath(iEndPathLabel, descriptions, hint); + } + + void + Schedule::fillModuleAndConsumesInfo(std::vector& allModuleDescriptions, + std::vector >& moduleIDToIndex, + std::vector >& modulesWhoseProductsAreConsumedBy, + ProductRegistry const& preg) const { + allModuleDescriptions.clear(); + moduleIDToIndex.clear(); + modulesWhoseProductsAreConsumedBy.clear(); + + allModuleDescriptions.reserve(allWorkers().size()); + moduleIDToIndex.reserve(allWorkers().size()); + modulesWhoseProductsAreConsumedBy.resize(allWorkers().size()); + + std::map labelToDesc; + unsigned int i = 0; + for (auto const& worker : allWorkers()) { + ModuleDescription const* p = worker->descPtr(); + allModuleDescriptions.push_back(p); + moduleIDToIndex.push_back(std::pair(p->id(), i)); + labelToDesc[p->moduleLabel()] = p; + ++i; + } + sort_all(moduleIDToIndex); + + i = 0; + for (auto const& worker : allWorkers()) { + std::vector& modules = modulesWhoseProductsAreConsumedBy.at(i); + worker->modulesWhoseProductsAreConsumed(modules, preg, labelToDesc); + ++i; + } + } + void Schedule::enableEndPaths(bool active) { endpathsAreActive_ = active; diff --git a/FWCore/Framework/src/StreamSchedule.cc b/FWCore/Framework/src/StreamSchedule.cc index 26f9b7c02160a..3eb04625ac505 100644 --- a/FWCore/Framework/src/StreamSchedule.cc +++ b/FWCore/Framework/src/StreamSchedule.cc @@ -550,6 +550,16 @@ namespace edm { std::bind(&Path::name, std::placeholders::_1)); } + void + StreamSchedule::triggerPaths(std::vector& oLabelsToFill) const { + oLabelsToFill = trig_name_list_; + } + + void + StreamSchedule::endPaths(std::vector& oLabelsToFill) const { + oLabelsToFill = end_path_name_list_; + } + void StreamSchedule::modulesInPath(std::string const& iPathLabel, std::vector& oLabelsToFill) const { @@ -567,6 +577,64 @@ namespace edm { } } + void + StreamSchedule::moduleDescriptionsInPath(std::string const& iPathLabel, + std::vector& descriptions, + unsigned int hint) const { + descriptions.clear(); + bool found = false; + TrigPaths::const_iterator itFound; + + if(hint < trig_paths_.size()) { + itFound = trig_paths_.begin() + hint; + if(itFound->name() == iPathLabel) found = true; + } + if(!found) { + // if the hint did not work, do it the slow way + itFound = std::find_if (trig_paths_.begin(), + trig_paths_.end(), + std::bind(std::equal_to(), + iPathLabel, + std::bind(&Path::name, std::placeholders::_1))); + if (itFound != trig_paths_.end()) found = true; + } + if (found) { + descriptions.reserve(itFound->size()); + for (size_t i = 0; i < itFound->size(); ++i) { + descriptions.push_back(itFound->getWorker(i)->descPtr()); + } + } + } + + void + StreamSchedule::moduleDescriptionsInEndPath(std::string const& iEndPathLabel, + std::vector& descriptions, + unsigned int hint) const { + descriptions.clear(); + bool found = false; + TrigPaths::const_iterator itFound; + + if(hint < end_paths_.size()) { + itFound = end_paths_.begin() + hint; + if(itFound->name() == iEndPathLabel) found = true; + } + if(!found) { + // if the hint did not work, do it the slow way + itFound = std::find_if (end_paths_.begin(), + end_paths_.end(), + std::bind(std::equal_to(), + iEndPathLabel, + std::bind(&Path::name, std::placeholders::_1))); + if (itFound != end_paths_.end()) found = true; + } + if (found) { + descriptions.reserve(itFound->size()); + for (size_t i = 0; i < itFound->size(); ++i) { + descriptions.push_back(itFound->getWorker(i)->descPtr()); + } + } + } + void StreamSchedule::enableEndPaths(bool active) { endpathsAreActive_ = active; diff --git a/FWCore/Framework/src/StreamSchedule.h b/FWCore/Framework/src/StreamSchedule.h index 20c778f837d30..45fa6580612ea 100644 --- a/FWCore/Framework/src/StreamSchedule.h +++ b/FWCore/Framework/src/StreamSchedule.h @@ -191,10 +191,26 @@ namespace edm { ///adds to oLabelsToFill the labels for all paths in the process void availablePaths(std::vector& oLabelsToFill) const; + ///adds to oLabelsToFill the labels for all trigger paths in the process + ///this is different from availablePaths because it includes the + ///empty paths so matches the entries in TriggerResults exactly. + void triggerPaths(std::vector& oLabelsToFill) const; + + ///adds to oLabelsToFill the labels for all end paths in the process + void endPaths(std::vector& oLabelsToFill) const; + ///adds to oLabelsToFill in execution order the labels of all modules in path iPathLabel void modulesInPath(std::string const& iPathLabel, std::vector& oLabelsToFill) const; + void moduleDescriptionsInPath(std::string const& iPathLabel, + std::vector& descriptions, + unsigned int hint) const; + + void moduleDescriptionsInEndPath(std::string const& iEndPathLabel, + std::vector& descriptions, + unsigned int hint) const; + /// Return the number of events this StreamSchedule has tried to process /// (inclues both successes and failures, including failures due /// to exceptions during processing). diff --git a/FWCore/Framework/src/SubProcess.cc b/FWCore/Framework/src/SubProcess.cc index b42d42ed40fca..5cf052c28ca18 100644 --- a/FWCore/Framework/src/SubProcess.cc +++ b/FWCore/Framework/src/SubProcess.cc @@ -25,6 +25,7 @@ #include "FWCore/Framework/src/PreallocationConfiguration.h" #include "FWCore/ParameterSet/interface/IllegalParameters.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ServiceRegistry/interface/ActivityRegistry.h" #include "FWCore/Utilities/interface/ExceptionCollector.h" #include @@ -110,6 +111,7 @@ namespace edm { std::shared_ptr subProcessParameterSet(popSubProcessParameterSet(*processParameterSet_).release()); ScheduleItems items(*parentProductRegistry, *this); + actReg_ = items.actReg_; ParameterSet const& optionsPset(processParameterSet_->getUntrackedParameterSet("options", ParameterSet())); IllegalParameters::setThrowAnException(optionsPset.getUntrackedParameter("throwIfIllegalParameter", true)); @@ -197,6 +199,8 @@ namespace edm { fixBranchIDListsForEDAliases(droppedBranchIDToKeptBranchID()); } ServiceRegistry::Operate operate(serviceToken_); + pathsAndConsumesOfModules_.initialize(schedule_.get(), preg_); + actReg_->preBeginJobSignal_(pathsAndConsumesOfModules_, processContext_); schedule_->beginJob(*preg_); if(subProcess_.get()) subProcess_->doBeginJob(); } diff --git a/FWCore/Framework/src/Worker.h b/FWCore/Framework/src/Worker.h index 00efa6c46fb95..ba84c8345a14f 100644 --- a/FWCore/Framework/src/Worker.h +++ b/FWCore/Framework/src/Worker.h @@ -30,6 +30,7 @@ the worker is reset(). #include "FWCore/Framework/interface/ProductHolderIndexAndSkipBit.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" #include "FWCore/ServiceRegistry/interface/ActivityRegistry.h" +#include "FWCore/ServiceRegistry/interface/ConsumesInfo.h" #include "FWCore/ServiceRegistry/interface/InternalContext.h" #include "FWCore/ServiceRegistry/interface/ModuleCallingContext.h" #include "FWCore/ServiceRegistry/interface/ParentContext.h" @@ -43,8 +44,10 @@ the worker is reset(). #include "FWCore/Framework/interface/Frameworkfwd.h" +#include #include #include +#include #include namespace edm { @@ -107,6 +110,12 @@ namespace edm { virtual void modulesDependentUpon(std::vector& oModuleLabels) const = 0; + virtual void modulesWhoseProductsAreConsumed(std::vector& modules, + ProductRegistry const& preg, + std::map const& labelsToDesc) const = 0; + + virtual std::vector consumesInfo() const = 0; + virtual Types moduleType() const =0; void clearCounters() { diff --git a/FWCore/Framework/src/WorkerT.h b/FWCore/Framework/src/WorkerT.h index 8c52e29f50a19..027d7ea91e3e7 100644 --- a/FWCore/Framework/src/WorkerT.h +++ b/FWCore/Framework/src/WorkerT.h @@ -11,12 +11,17 @@ WorkerT: Code common to all workers. #include "FWCore/Framework/interface/UnscheduledHandler.h" #include "FWCore/Framework/src/Worker.h" #include "FWCore/Framework/src/WorkerParams.h" +#include "FWCore/ServiceRegistry/interface/ConsumesInfo.h" +#include #include +#include +#include namespace edm { class ModuleCallingContext; + class ModuleDescription; class ProductHolderIndexAndSkipBit; class ProductRegistry; class ThinnedAssociationsHelper; @@ -105,6 +110,16 @@ namespace edm { module_->modulesDependentUpon(module_->moduleDescription().processName(),oModuleLabels); } + virtual void modulesWhoseProductsAreConsumed(std::vector& modules, + ProductRegistry const& preg, + std::map const& labelsToDesc) const override { + module_->modulesWhoseProductsAreConsumed(modules, preg, labelsToDesc, module_->moduleDescription().processName()); + } + + virtual std::vector consumesInfo() const override { + return module_->consumesInfo(); + } + virtual void itemsToGet(BranchType branchType, std::vector& indexes) const override { module_->itemsToGet(branchType, indexes); } diff --git a/FWCore/Framework/src/stream/EDAnalyzerAdaptorBase.cc b/FWCore/Framework/src/stream/EDAnalyzerAdaptorBase.cc index c0857a5f66038..54e3dfdd92033 100644 --- a/FWCore/Framework/src/stream/EDAnalyzerAdaptorBase.cc +++ b/FWCore/Framework/src/stream/EDAnalyzerAdaptorBase.cc @@ -11,6 +11,7 @@ // // system include files +#include // user include files #include "FWCore/Framework/interface/stream/EDAnalyzerAdaptorBase.h" @@ -119,6 +120,21 @@ EDAnalyzerAdaptorBase::modulesDependentUpon(const std::string& iProcessName, return m_streamModules[0]->modulesDependentUpon(iProcessName, oModuleLabels); } +void +EDAnalyzerAdaptorBase::modulesWhoseProductsAreConsumed(std::vector& modules, + ProductRegistry const& preg, + std::map const& labelsToDesc, + std::string const& processName) const { + assert(not m_streamModules.empty()); + return m_streamModules[0]->modulesWhoseProductsAreConsumed(modules, preg, labelsToDesc, processName); +} + +std::vector +EDAnalyzerAdaptorBase::consumesInfo() const { + assert(not m_streamModules.empty()); + return m_streamModules[0]->consumesInfo(); +} + bool EDAnalyzerAdaptorBase::doEvent(EventPrincipal& ep, EventSetup const& c, ActivityRegistry* act, diff --git a/FWCore/Framework/src/stream/ProducingModuleAdaptorBase.cc b/FWCore/Framework/src/stream/ProducingModuleAdaptorBase.cc index 5822d98831e12..cb60bfb3b90e8 100644 --- a/FWCore/Framework/src/stream/ProducingModuleAdaptorBase.cc +++ b/FWCore/Framework/src/stream/ProducingModuleAdaptorBase.cc @@ -11,6 +11,7 @@ // // system include files +#include // user include files #include "FWCore/Framework/interface/stream/ProducingModuleAdaptorBase.h" @@ -111,6 +112,23 @@ namespace edm { return m_streamModules[0]->modulesDependentUpon(iProcessName, oModuleLabels); } + template< typename T> + void + ProducingModuleAdaptorBase::modulesWhoseProductsAreConsumed(std::vector& modules, + ProductRegistry const& preg, + std::map const& labelsToDesc, + std::string const& processName) const { + assert(not m_streamModules.empty()); + return m_streamModules[0]->modulesWhoseProductsAreConsumed(modules, preg, labelsToDesc, processName); + } + + template< typename T> + std::vector + ProducingModuleAdaptorBase::consumesInfo() const { + assert(not m_streamModules.empty()); + return m_streamModules[0]->consumesInfo(); + } + template< typename T> void ProducingModuleAdaptorBase::updateLookup(BranchType iType, diff --git a/FWCore/Framework/test/productregistry.cppunit.cc b/FWCore/Framework/test/productregistry.cppunit.cc index c1d10b2a569c8..fc1542663caef 100644 --- a/FWCore/Framework/test/productregistry.cppunit.cc +++ b/FWCore/Framework/test/productregistry.cppunit.cc @@ -32,6 +32,7 @@ CPPUNIT_TEST(testWatch); CPPUNIT_TEST_EXCEPTION(testCircular,cms::Exception); CPPUNIT_TEST(testProductRegistration); +CPPUNIT_TEST(testAddAlias); CPPUNIT_TEST_SUITE_END(); @@ -43,6 +44,7 @@ CPPUNIT_TEST_SUITE_END(); void testWatch(); void testCircular(); void testProductRegistration(); + void testAddAlias(); private: std::shared_ptr intBranch_; @@ -105,12 +107,12 @@ void testProductRegistry::setUp() { edm::ParameterSet pset; pset.registerIt(); - intBranch_.reset(new edm::BranchDescription(edm::InEvent, "label", "PROD", + intBranch_.reset(new edm::BranchDescription(edm::InEvent, "labeli", "PROD", "int", "int", "int", "", pset.id(), edm::TypeWithDict(typeid(int)))); - floatBranch_.reset(new edm::BranchDescription(edm::InEvent, "label", "PROD", + floatBranch_.reset(new edm::BranchDescription(edm::InEvent, "labelf", "PROD", "float", "float", "float", "", pset.id(), edm::TypeWithDict(typeid(float)))); @@ -215,3 +217,20 @@ void testProductRegistry:: testProductRegistration() { throw; } } + +void testProductRegistry::testAddAlias() { + edm::ProductRegistry reg; + + reg.addProduct(*intBranch_); + reg.addLabelAlias(*intBranch_, "aliasi", "instanceAlias"); + + reg.addProduct(*floatBranch_); + reg.addLabelAlias(*floatBranch_, "aliasf", "instanceAlias"); + + reg.setFrozen(false); + std::vector > const& v = reg.aliasToOriginal(); + CPPUNIT_ASSERT(v.at(0).first == "aliasf" && + v.at(0).second == "labelf" && + v.at(1).first == "aliasi" && + v.at(1).second == "labeli"); +} diff --git a/FWCore/Framework/test/stubs/ToyAnalyzers.cc b/FWCore/Framework/test/stubs/ToyAnalyzers.cc index 4191b27010e26..763fdd2a98fe2 100644 --- a/FWCore/Framework/test/stubs/ToyAnalyzers.cc +++ b/FWCore/Framework/test/stubs/ToyAnalyzers.cc @@ -10,6 +10,7 @@ Toy EDAnalyzers for testing purposes only. #include "DataFormats/TestObjects/interface/ToyProducts.h" // #include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/stream/EDAnalyzer.h" #include "FWCore/Framework/interface/Event.h" #include "FWCore/Framework/interface/MakerMacros.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" @@ -68,6 +69,30 @@ namespace edmtest { edm::InputTag moduleLabel_; }; + //-------------------------------------------------------------------- + // + class ConsumingStreamAnalyzer : public edm::stream::EDAnalyzer<> { + public: + ConsumingStreamAnalyzer(edm::ParameterSet const& iPSet) : + value_(iPSet.getUntrackedParameter("valueMustMatch")), + moduleLabel_(iPSet.getUntrackedParameter("moduleLabel"), "") { + mayConsume(moduleLabel_); + } + + void analyze(edm::Event const& iEvent, edm::EventSetup const&) { + edm::Handle handle; + iEvent.getByLabel(moduleLabel_, handle); + if(handle->value != value_) { + throw cms::Exception("ValueMissMatch") + << "The value for \"" << moduleLabel_ << "\" is " + << handle->value << " but it was supposed to be " << value_; + } + } + private: + int value_; + edm::InputTag moduleLabel_; + }; + //-------------------------------------------------------------------- // class SCSimpleAnalyzer : public edm::EDAnalyzer { @@ -173,10 +198,12 @@ namespace edmtest { using edmtest::NonAnalyzer; using edmtest::IntTestAnalyzer; +using edmtest::ConsumingStreamAnalyzer; using edmtest::SCSimpleAnalyzer; using edmtest::DSVAnalyzer; DEFINE_FWK_MODULE(NonAnalyzer); DEFINE_FWK_MODULE(IntTestAnalyzer); +DEFINE_FWK_MODULE(ConsumingStreamAnalyzer); DEFINE_FWK_MODULE(SCSimpleAnalyzer); DEFINE_FWK_MODULE(DSVAnalyzer); diff --git a/FWCore/Framework/test/stubs/ToyIntProducers.cc b/FWCore/Framework/test/stubs/ToyIntProducers.cc index 99c143a64cb78..a3d096efce027 100644 --- a/FWCore/Framework/test/stubs/ToyIntProducers.cc +++ b/FWCore/Framework/test/stubs/ToyIntProducers.cc @@ -6,6 +6,7 @@ Toy EDProducers of Ints for testing purposes only. ----------------------------------------------------------------------*/ #include "DataFormats/Common/interface/Handle.h" +#include "DataFormats/Common/interface/TriggerResults.h" #include "DataFormats/TestObjects/interface/ToyProducts.h" // #include "FWCore/Framework/interface/EDProducer.h" @@ -14,6 +15,7 @@ Toy EDProducers of Ints for testing purposes only. #include "FWCore/Framework/interface/MakerMacros.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" #include "FWCore/Utilities/interface/EDMException.h" +#include "FWCore/Utilities/interface/InputTag.h" // #include #include @@ -87,6 +89,8 @@ namespace edmtest { int value_; }; + //-------------------------------------------------------------------- + void IntProducer::produce(edm::Event& e, edm::EventSetup const&) { // EventSetup is not used. @@ -94,6 +98,34 @@ namespace edmtest { e.put(std::move(p)); } + class ConsumingIntProducer : public edm::stream::EDProducer<> { + public: + explicit ConsumingIntProducer(edm::ParameterSet const& p) : + value_(p.getParameter("ivalue")) { + produces(); + // not used, only exists to test PathAndConsumesOfModules + consumes(edm::InputTag("TriggerResults")); + consumesMany(); + } + explicit ConsumingIntProducer(int i) : value_(i) { + produces(); + // not used, only exists to test PathAndConsumesOfModules + consumes(edm::InputTag("TriggerResults")); + consumesMany(); + } + virtual ~ConsumingIntProducer() {} + virtual void produce(edm::Event& e, edm::EventSetup const& c); + + private: + int value_; + }; + + void + ConsumingIntProducer::produce(edm::Event& e, edm::EventSetup const&) { + std::unique_ptr p(new IntProduct(value_)); + e.put(std::move(p)); + } + //-------------------------------------------------------------------- // // Produces an IntProduct instance whose value is the event number, @@ -242,6 +274,7 @@ namespace edmtest { using edmtest::FailingProducer; using edmtest::NonProducer; using edmtest::IntProducer; +using edmtest::ConsumingIntProducer; using edmtest::EventNumberIntProducer; using edmtest::TransientIntProducer; using edmtest::IntProducerFromTransient; @@ -250,6 +283,7 @@ using edmtest::AddIntsProducer; DEFINE_FWK_MODULE(FailingProducer); DEFINE_FWK_MODULE(NonProducer); DEFINE_FWK_MODULE(IntProducer); +DEFINE_FWK_MODULE(ConsumingIntProducer); DEFINE_FWK_MODULE(EventNumberIntProducer); DEFINE_FWK_MODULE(TransientIntProducer); DEFINE_FWK_MODULE(IntProducerFromTransient); diff --git a/FWCore/Framework/test/unit_test_outputs/test_deepCall_allowUnscheduled_true.log b/FWCore/Framework/test/unit_test_outputs/test_deepCall_allowUnscheduled_true.log index 2af086870caa9..ae6987b72a930 100644 --- a/FWCore/Framework/test/unit_test_outputs/test_deepCall_allowUnscheduled_true.log +++ b/FWCore/Framework/test/unit_test_outputs/test_deepCall_allowUnscheduled_true.log @@ -15,6 +15,7 @@ Module type=IntProducer, Module label=one, Parameter Set ID=bece7daf7ab0166d4f60 ++++ starting: constructing module with label 'result4' id = 6 ++++ finished: constructing module with label 'result4' id = 6 ++ preallocate: 1 concurrent runs, 1 concurrent luminosity sections, 1 streams +++ starting: begin job ++++ starting: begin job for module with label 'one' id = 3 Module type=IntProducer, Module label=one, Parameter Set ID=bece7daf7ab0166d4f6047cc887d46b8 ++++ finished: begin job for module with label 'one' id = 3 diff --git a/FWCore/Integration/test/run_TestGetBy.sh b/FWCore/Integration/test/run_TestGetBy.sh index 38fb5d6ec107d..361c1b6b09e0f 100755 --- a/FWCore/Integration/test/run_TestGetBy.sh +++ b/FWCore/Integration/test/run_TestGetBy.sh @@ -6,15 +6,25 @@ function die { echo Failure $1: status $2 ; exit $2 ; } pushd ${LOCAL_TMP_DIR} - cmsRun -p ${LOCAL_TEST_DIR}/${test}1_cfg.py > testGetBy1.log || die "cmsRun ${test}1_cfg.py" $? + echo "testGetBy1" + cmsRun -p ${LOCAL_TEST_DIR}/${test}1_cfg.py > testGetBy1.log 2>/dev/null || die "cmsRun ${test}1_cfg.py" $? diff ${LOCAL_TEST_DIR}/unit_test_outputs/testGetBy1.log testGetBy1.log || die "comparing testGetBy1.log" $? - cmsRun -p ${LOCAL_TEST_DIR}/${test}2_cfg.py > testGetBy2.log || die "cmsRun ${test}2_cfg.py" $? + echo "testGetBy2" + cmsRun -p ${LOCAL_TEST_DIR}/${test}2_cfg.py > testGetBy2.log 2>/dev/null || die "cmsRun ${test}2_cfg.py" $? grep -v "Initiating request to open file" testGetBy2.log | grep -v "Successfully opened file" | grep -v "Closed file" > testGetBy2_1.log diff ${LOCAL_TEST_DIR}/unit_test_outputs/testGetBy2.log testGetBy2_1.log || die "comparing testGetBy2.log" $? + echo "testGetBy3" cmsRun -p ${LOCAL_TEST_DIR}/${test}3_cfg.py || die "cmsRun ${test}3_cfg.py" $? + echo "testConsumesInfo" + cmsRun -p ${LOCAL_TEST_DIR}/testConsumesInfo_cfg.py > testConsumesInfo.log 2>/dev/null || die "cmsRun testConsumesInfo_cfg.py" $? + grep -v "++" testConsumesInfo.log > testConsumesInfo_1.log + rm testConsumesInfo.log + rm testConsumesInfo.root + diff ${LOCAL_TEST_DIR}/unit_test_outputs/testConsumesInfo_1.log testConsumesInfo_1.log || die "comparing testConsumesInfo_1.log" $? + popd exit 0 diff --git a/FWCore/Integration/test/testConsumesInfo_cfg.py b/FWCore/Integration/test/testConsumesInfo_cfg.py new file mode 100644 index 0000000000000..bc420cd093bd6 --- /dev/null +++ b/FWCore/Integration/test/testConsumesInfo_cfg.py @@ -0,0 +1,151 @@ +import FWCore.ParameterSet.Config as cms + +process = cms.Process("PROD1") + +process.Tracer = cms.Service('Tracer', + dumpPathsAndConsumes = cms.untracked.bool(True) +) + +process.MessageLogger = cms.Service("MessageLogger", + destinations = cms.untracked.vstring('cout', + 'cerr' + ), + categories = cms.untracked.vstring( + 'Tracer' + ), + cout = cms.untracked.PSet( + default = cms.untracked.PSet ( + limit = cms.untracked.int32(0) + ), + Tracer = cms.untracked.PSet( + limit=cms.untracked.int32(100000000) + ) + ) +) + +process.options = cms.untracked.PSet( + allowUnscheduled = cms.untracked.bool(True), + numberOfStreams = cms.untracked.uint32(1), + numberOfConcurrentRuns = cms.untracked.uint32(1), + numberOfConcurrentLuminosityBlocks = cms.untracked.uint32(1) +) + +process.source = cms.Source("IntSource") +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(3) +) + +process.out = cms.OutputModule("PoolOutputModule", + fileName = cms.untracked.string('testConsumesInfo.root'), + outputCommands = cms.untracked.vstring( + 'keep *', + 'drop *_intProducerA_*_*' + ) +) + +process.a1 = cms.EDAnalyzer("TestFindProduct", + inputTags = cms.untracked.VInputTag( cms.InputTag("source") ), + expectedSum = cms.untracked.int32(12), + inputTagsNotFound = cms.untracked.VInputTag( + cms.InputTag("source", processName=cms.InputTag.skipCurrentProcess()), + cms.InputTag("intProducer", processName=cms.InputTag.skipCurrentProcess()), + cms.InputTag("intProducerU", processName=cms.InputTag.skipCurrentProcess()) + ) +) + +process.a2 = cms.EDAnalyzer("TestFindProduct", + inputTags = cms.untracked.VInputTag( cms.InputTag("intProducerA") ), + expectedSum = cms.untracked.int32(300) +) + +process.a3 = cms.EDAnalyzer("TestFindProduct", + inputTags = cms.untracked.VInputTag( cms.InputTag("aliasForInt") ), + expectedSum = cms.untracked.int32(300) +) + +process.intProducer = cms.EDProducer("IntProducer", ivalue = cms.int32(1)) + +process.intProducerU = cms.EDProducer("IntProducer", ivalue = cms.int32(10)) + +process.intProducerA = cms.EDProducer("IntProducer", ivalue = cms.int32(100)) + +process.aliasForInt = cms.EDAlias( + intProducerA = cms.VPSet( + cms.PSet(type = cms.string('edmtestIntProduct') + ) + ) +) + +process.intVectorProducer = cms.EDProducer("IntVectorProducer", + count = cms.int32(9), + ivalue = cms.int32(11) +) + +process.test = cms.EDAnalyzer("TestResultAnalyzer") + +process.testView1 = cms.EDAnalyzer("TestFindProduct", + inputTags = cms.untracked.VInputTag(), + inputTagsView = cms.untracked.VInputTag( cms.InputTag("intVectorProducer", "", "PROD1") ) +) + +process.testStreamingProducer = cms.EDProducer("ConsumingIntProducer", + ivalue = cms.int32(111) +) + +process.testStreamingAnalyzer = cms.EDAnalyzer("ConsumingStreamAnalyzer", + valueMustMatch = cms.untracked.int32(111), + moduleLabel = cms.untracked.string("testStreamingProducer") +) + +process.p = cms.Path(process.intProducer * process.a1 * process.a2 * process.a3 * + process.test * process.testView1 * + process.testStreamingProducer * process.testStreamingAnalyzer) +process.p2 = cms.Path(process.intProducer * process.a1 * process.a2 * process.a3) +process.p11 = cms.Path() + +process.e = cms.EndPath(process.out) +process.p1ep2 = cms.EndPath() + +copyProcess = cms.Process("COPY") +process.subProcess = cms.SubProcess(copyProcess, + outputCommands = cms.untracked.vstring( + "keep *", + "drop *_intProducerA_*_*" + ) +) + +copyProcess.intVectorProducer = cms.EDProducer("IntVectorProducer", + count = cms.int32(9), + ivalue = cms.int32(11) +) + +copyProcess.testView1 = cms.EDAnalyzer("TestFindProduct", + inputTags = cms.untracked.VInputTag(), + inputTagsView = cms.untracked.VInputTag( cms.InputTag("intVectorProducer", "", "PROD1") ) +) + +copyProcess.testView2 = cms.EDAnalyzer("TestFindProduct", + inputTags = cms.untracked.VInputTag(), + inputTagsView = cms.untracked.VInputTag( cms.InputTag("intVectorProducer", "", "COPY") ) +) + +copyProcess.test = cms.EDAnalyzer("TestResultAnalyzer") + +copyProcess.thingWithMergeProducer = cms.EDProducer("ThingWithMergeProducer") +copyProcess.testMergeResults = cms.EDAnalyzer("TestMergeResults") + +copyProcess.testStreamingProducer = cms.EDProducer("ConsumingIntProducer", + ivalue = cms.int32(11) +) + +copyProcess.testStreamingAnalyzer = cms.EDAnalyzer("ConsumingStreamAnalyzer", + valueMustMatch = cms.untracked.int32(11), + moduleLabel = cms.untracked.string("testStreamingProducer") +) + +copyProcess.p3 = cms.Path(copyProcess.intVectorProducer * copyProcess.test * copyProcess.thingWithMergeProducer * + copyProcess.testMergeResults * copyProcess.testView1 * copyProcess.testView2 * + copyProcess.testStreamingProducer * copyProcess.testStreamingAnalyzer) + +copyProcess.ep1 = cms.EndPath(copyProcess.intVectorProducer) +copyProcess.ep2 = cms.EndPath() diff --git a/FWCore/Integration/test/unit_test_outputs/testConsumesInfo_1.log b/FWCore/Integration/test/unit_test_outputs/testConsumesInfo_1.log new file mode 100644 index 0000000000000..0fc1c4d186122 --- /dev/null +++ b/FWCore/Integration/test/unit_test_outputs/testConsumesInfo_1.log @@ -0,0 +1,167 @@ +Process name = PROD1 +paths: + p + p2 + p11 +end paths: + e + p1ep2 +modules on path p: + intProducer + a1 + a2 + a3 + test + testView1 + testStreamingProducer + testStreamingAnalyzer +modules on path p2: + intProducer + a1 + a2 + a3 +modules on path p11: +modules on end path e: + out +modules on end path p1ep2: +All modules and modules in the current process whose products they consume: +(This does not include modules from previous processes or the source) + IntProducer/'intProducerA' + IntProducer/'intProducerU' + IntVectorProducer/'intVectorProducer' + IntProducer/'intProducer' + TestFindProduct/'a1' consumes products from these modules: + IntProducer/'intProducer' + IntProducer/'intProducerU' + TestFindProduct/'a2' consumes products from these modules: + IntProducer/'intProducerA' + TestFindProduct/'a3' consumes products from these modules: + IntProducer/'intProducerA' + TestResultAnalyzer/'test' consumes products from these modules: + TriggerResultInserter/'TriggerResults' + TestFindProduct/'testView1' consumes products from these modules: + IntVectorProducer/'intVectorProducer' + ConsumingIntProducer/'testStreamingProducer' consumes products from these modules: + TriggerResultInserter/'TriggerResults' + ConsumingStreamAnalyzer/'testStreamingAnalyzer' consumes products from these modules: + ConsumingIntProducer/'testStreamingProducer' + PoolOutputModule/'out' consumes products from these modules: + TriggerResultInserter/'TriggerResults' + IntProducer/'intProducerA' + IntProducer/'intProducer' + IntProducer/'intProducerU' + ConsumingIntProducer/'testStreamingProducer' + IntVectorProducer/'intVectorProducer' + TriggerResultInserter/'TriggerResults' +All modules (listed by class and label) and all their consumed products. +Consumed products are listed by type, label, instance, process. +For products not in the event, 'run' or 'lumi' is added to indicate the TTree they are from. +For products that are declared with mayConsume, 'may consume' is added. +For products consumed for Views, 'element type' is added +For products only read from previous processes, 'skip current process' is added + IntProducer/'intProducerA' + IntProducer/'intProducerU' + IntVectorProducer/'intVectorProducer' + IntProducer/'intProducer' + TestFindProduct/'a1' consumes: + edmtest::IntProduct 'source' '' '' + edmtest::IntProduct 'source' '' '', skip current process + edmtest::IntProduct 'intProducer' '' '', skip current process + edmtest::IntProduct 'intProducerU' '' '', skip current process + TestFindProduct/'a2' consumes: + edmtest::IntProduct 'intProducerA' '' '' + TestFindProduct/'a3' consumes: + edmtest::IntProduct 'aliasForInt' '' '' + TestResultAnalyzer/'test' consumes: + edm::TriggerResults '' '' '' + TestFindProduct/'testView1' consumes: + int 'intVectorProducer' '' 'PROD1', element type + ConsumingIntProducer/'testStreamingProducer' consumes: + edm::TriggerResults 'TriggerResults' '' '' + edm::TriggerResults '' '' '' + ConsumingStreamAnalyzer/'testStreamingAnalyzer' consumes: + edmtest::IntProduct 'testStreamingProducer' '' '', may consume + PoolOutputModule/'out' consumes: + edm::TriggerResults 'TriggerResults' '' 'PROD1' + edmtest::IntProduct 'aliasForInt' '' 'PROD1' + edmtest::IntProduct 'intProducer' '' 'PROD1' + edmtest::IntProduct 'intProducerU' '' 'PROD1' + edmtest::IntProduct 'source' '' 'PROD1' + edmtest::IntProduct 'testStreamingProducer' '' 'PROD1' + std::vector 'intVectorProducer' '' 'PROD1' + TriggerResultInserter/'TriggerResults' + +Process name = COPY +paths: + p3 +end paths: + ep1 + ep2 +modules on path p3: + intVectorProducer + test + thingWithMergeProducer + testMergeResults + testView1 + testView2 + testStreamingProducer + testStreamingAnalyzer +modules on end path ep1: + intVectorProducer +modules on end path ep2: +All modules and modules in the current process whose products they consume: +(This does not include modules from previous processes or the source) + IntVectorProducer/'intVectorProducer' + TestResultAnalyzer/'test' consumes products from these modules: + TriggerResultInserter/'TriggerResults' + ThingWithMergeProducer/'thingWithMergeProducer' + TestMergeResults/'testMergeResults' + TestFindProduct/'testView1' + TestFindProduct/'testView2' consumes products from these modules: + IntVectorProducer/'intVectorProducer' + ConsumingIntProducer/'testStreamingProducer' consumes products from these modules: + TriggerResultInserter/'TriggerResults' + ConsumingStreamAnalyzer/'testStreamingAnalyzer' consumes products from these modules: + ConsumingIntProducer/'testStreamingProducer' + TriggerResultInserter/'TriggerResults' +All modules (listed by class and label) and all their consumed products. +Consumed products are listed by type, label, instance, process. +For products not in the event, 'run' or 'lumi' is added to indicate the TTree they are from. +For products that are declared with mayConsume, 'may consume' is added. +For products consumed for Views, 'element type' is added +For products only read from previous processes, 'skip current process' is added + IntVectorProducer/'intVectorProducer' + TestResultAnalyzer/'test' consumes: + edm::TriggerResults '' '' '' + ThingWithMergeProducer/'thingWithMergeProducer' + TestMergeResults/'testMergeResults' consumes: + edmtest::Thing 'thingWithMergeProducer' 'event' 'PROD' + edmtest::Thing 'thingWithMergeProducer' 'endRun' 'PROD', run + edmtest::ThingWithMerge 'thingWithMergeProducer' 'endRun' 'PROD', run + edmtest::ThingWithIsEqual 'thingWithMergeProducer' 'endRun' 'PROD', run + edmtest::Thing 'thingWithMergeProducer' 'endRun' '', run + edmtest::ThingWithMerge 'thingWithMergeProducer' 'endRun' '', run + edmtest::ThingWithIsEqual 'thingWithMergeProducer' 'endRun' '', run + edmtest::Thing 'thingWithMergeProducer' 'endLumi' 'PROD', lumi + edmtest::ThingWithMerge 'thingWithMergeProducer' 'endLumi' 'PROD', lumi + edmtest::ThingWithIsEqual 'thingWithMergeProducer' 'endLumi' 'PROD', lumi + edmtest::Thing 'thingWithMergeProducer' 'endLumi' '', lumi + edmtest::ThingWithMerge 'thingWithMergeProducer' 'endLumi' '', lumi + edmtest::ThingWithIsEqual 'thingWithMergeProducer' 'endLumi' '', lumi + TestFindProduct/'testView1' consumes: + int 'intVectorProducer' '' 'PROD1', element type + TestFindProduct/'testView2' consumes: + int 'intVectorProducer' '' 'COPY', element type + ConsumingIntProducer/'testStreamingProducer' consumes: + edm::TriggerResults 'TriggerResults' '' '' + edm::TriggerResults '' '' '' + ConsumingStreamAnalyzer/'testStreamingAnalyzer' consumes: + edmtest::IntProduct 'testStreamingProducer' '' '', may consume + TriggerResultInserter/'TriggerResults' + +TestFindProduct sum = 12 +TestFindProduct sum = 300 +TestFindProduct sum = 300 +TestFindProduct sum = 33 +TestFindProduct sum = 33 +TestFindProduct sum = 33 diff --git a/FWCore/Integration/test/unit_test_outputs/testGetBy1.log b/FWCore/Integration/test/unit_test_outputs/testGetBy1.log index 433ac8c7328c2..da10ff928b95f 100644 --- a/FWCore/Integration/test/unit_test_outputs/testGetBy1.log +++ b/FWCore/Integration/test/unit_test_outputs/testGetBy1.log @@ -23,6 +23,7 @@ Module type=IntProducer, Module label=intProducerA, Parameter Set ID=38971365e81 ++++ starting: constructing module with label 'intVectorProducer' id = 9 ++++ finished: constructing module with label 'intVectorProducer' id = 9 ++ preallocate: 1 concurrent runs, 1 concurrent luminosity sections, 1 streams +++ starting: begin job ++++ starting: begin job for module with label 'intProducerA' id = 7 Module type=IntProducer, Module label=intProducerA, Parameter Set ID=38971365e8174cb2ccc12430661ba6d4 ++++ finished: begin job for module with label 'intProducerA' id = 7 @@ -43,6 +44,7 @@ Module type=IntProducer, Module label=intProducerA, Parameter Set ID=38971365e81 ++++ finished: begin job for module with label 'out' id = 6 ++++ starting: begin job for module with label 'TriggerResults' id = 1 ++++ finished: begin job for module with label 'TriggerResults' id = 1 +++ starting: begin job ++ finished: begin job ++++ starting: begin stream for module: stream = 0 label = 'intProducer' id = 2 ++++ finished: begin stream for module: stream = 0 label = 'intProducer' id = 2 diff --git a/FWCore/Integration/test/unit_test_outputs/testGetBy2.log b/FWCore/Integration/test/unit_test_outputs/testGetBy2.log index fe8220f25848d..9447b1eaa7c65 100644 --- a/FWCore/Integration/test/unit_test_outputs/testGetBy2.log +++ b/FWCore/Integration/test/unit_test_outputs/testGetBy2.log @@ -17,6 +17,7 @@ Module type=IntProducer, Module label=intProducer, Parameter Set ID=0e62dace196e ++++ starting: constructing module with label 'intVectorProducer' id = 5 ++++ finished: constructing module with label 'intVectorProducer' id = 5 ++ preallocate: 1 concurrent runs, 1 concurrent luminosity sections, 1 streams +++ starting: begin job ++++ starting: begin job for module with label 'intProducerU' id = 4 ++++ finished: begin job for module with label 'intProducerU' id = 4 ++++ starting: begin job for module with label 'intVectorProducer' id = 5 diff --git a/FWCore/Integration/test/unit_test_outputs/testSubProcess.grep2.txt b/FWCore/Integration/test/unit_test_outputs/testSubProcess.grep2.txt index 8c279a09c9c81..d6257fe7a8539 100644 --- a/FWCore/Integration/test/unit_test_outputs/testSubProcess.grep2.txt +++ b/FWCore/Integration/test/unit_test_outputs/testSubProcess.grep2.txt @@ -33,6 +33,9 @@ ++++ starting: constructing module with label 'out' id = 16 ++++ finished: constructing module with label 'out' id = 16 ++ preallocate: 1 concurrent runs, 1 concurrent luminosity sections, 1 streams +++ starting: begin job +++ starting: begin job +++ starting: begin job ++++ starting: begin job for module with label 'thingWithMergeProducer' id = 2 ++++ finished: begin job for module with label 'thingWithMergeProducer' id = 2 ++++ starting: begin job for module with label 'get' id = 3 @@ -49,6 +52,8 @@ ++++ finished: begin job for module with label 'noPut' id = 8 ++++ starting: begin job for module with label 'TriggerResults' id = 1 ++++ finished: begin job for module with label 'TriggerResults' id = 1 +++ starting: begin job +++ starting: begin job ++++ starting: begin job for module with label 'thingWithMergeProducer' id = 10 ++++ finished: begin job for module with label 'thingWithMergeProducer' id = 10 ++++ starting: begin job for module with label 'test' id = 11 diff --git a/FWCore/ServiceRegistry/interface/ActivityRegistry.h b/FWCore/ServiceRegistry/interface/ActivityRegistry.h index 56a1742a27c5d..a33c245fbc3ea 100644 --- a/FWCore/ServiceRegistry/interface/ActivityRegistry.h +++ b/FWCore/ServiceRegistry/interface/ActivityRegistry.h @@ -56,7 +56,9 @@ namespace edm { class GlobalContext; class StreamContext; class PathContext; + class ProcessContext; class ModuleCallingContext; + class PathsAndConsumesOfModulesBase; namespace service { class SystemBounds; } @@ -97,7 +99,16 @@ namespace edm { preallocateSignal_.connect(iSlot); } AR_WATCH_USING_METHOD_1(watchPreallocate) - + + typedef signalslot::Signal PreBeginJob; + ///signal is emitted before all modules have gotten their beginJob called + PreBeginJob preBeginJobSignal_; + ///convenience function for attaching to signal + void watchPreBeginJob(PreBeginJob::slot_type const& iSlot) { + preBeginJobSignal_.connect(iSlot); + } + AR_WATCH_USING_METHOD_2(watchPreBeginJob) + typedef signalslot::Signal PostBeginJob; ///signal is emitted after all modules have gotten their beginJob called PostBeginJob postBeginJobSignal_; diff --git a/FWCore/ServiceRegistry/interface/ConsumesInfo.h b/FWCore/ServiceRegistry/interface/ConsumesInfo.h new file mode 100644 index 0000000000000..67391972d56ab --- /dev/null +++ b/FWCore/ServiceRegistry/interface/ConsumesInfo.h @@ -0,0 +1,66 @@ +#ifndef FWCore_ServiceRegistry_ConsumesInfo_h +#define FWCore_ServiceRegistry_ConsumesInfo_h + +/**\class edm::ConsumesInfo + + Description: Contains information about a product + a module will get (consume). + + Usage: These are typically returned by the PathsAndConsumesOfModules + object obtained in the PreBeginJob callback for a service. +*/ +// +// Original Author: W. David Dagenhart +// Created: 12/4/2014 + +#include "FWCore/Utilities/interface/BranchType.h" +#include "FWCore/Utilities/interface/ProductKindOfType.h" +#include "FWCore/Utilities/interface/TypeID.h" + +#include + +namespace edm { + class ConsumesInfo { + public: + + ConsumesInfo(TypeID const& iType, + char const* iLabel, + char const* iInstance, + char const* iProcess, + BranchType iBranchType, + KindOfType iKindOfType, + bool iAlwaysGets, + bool iSkipCurrentProcess_); + + TypeID const& type() const { return type_; } + std::string const& label() const { return label_; } + std::string const& instance() const { return instance_; } + std::string const& process() const { return process_; } + BranchType branchType() const { return branchType_; } + KindOfType kindOfType() const { return kindOfType_; } + bool alwaysGets() const { return alwaysGets_; } + bool skipCurrentProcess() const { return skipCurrentProcess_; } + + // This provides information from EDConsumerBase + // There a couple cases that need explanation. + // + // consumesMany + // The label, instance and process are all empty. + // + // process is empty - A get will search over processes in reverse + // time order (unknown which process the product will be gotten + // from and it is possible for this to vary from event to event) + + private: + + TypeID type_; + std::string label_; + std::string instance_; + std::string process_; + BranchType branchType_; + KindOfType kindOfType_; + bool alwaysGets_; + bool skipCurrentProcess_; + }; +} +#endif diff --git a/FWCore/ServiceRegistry/interface/PathsAndConsumesOfModulesBase.h b/FWCore/ServiceRegistry/interface/PathsAndConsumesOfModulesBase.h new file mode 100644 index 0000000000000..b359bb7533be7 --- /dev/null +++ b/FWCore/ServiceRegistry/interface/PathsAndConsumesOfModulesBase.h @@ -0,0 +1,95 @@ +#ifndef FWCore_ServiceRegistry_PathsAndConsumesOfModulesBase_h +#define FWCore_ServiceRegistry_PathsAndConsumesOfModulesBase_h + +/**\class edm::PathsAndConsumesOfModulesBase + + Description: Contains information about paths and end paths + as well as the modules on them. Also contains information + about all modules that might run. Also contains information + about the products a module is declared to consume and the + dependences between modules which can be derived from + those declarations. + + Usage: This is typically passed as an argument to the + PreBeginJob callback for a service. + + In a SubProcess job, an instance of this class this will + contain information about 1 Process/SubProcess, but a + service will be passed a separate object for its process + and each SubProcess descended from it. +*/ +// +// Original Author: W. David Dagenhart +// Created: 11/5/2014 + +#include "FWCore/ServiceRegistry/interface/ConsumesInfo.h" + +#include +#include + +namespace edm { + + class ModuleDescription; + + class PathsAndConsumesOfModulesBase { + public: + + virtual ~PathsAndConsumesOfModulesBase(); + + std::vector const& paths() const { return doPaths(); } + std::vector const& endPaths() const { return doEndPaths(); } + + std::vector const& allModules() const { + return doAllModules(); + } + + ModuleDescription const* moduleDescription(unsigned int moduleID) const { + return doModuleDescription(moduleID); + } + + std::vector const& modulesOnPath(unsigned int pathIndex) const { + return doModulesOnPath(pathIndex); + } + + std::vector const& modulesOnEndPath(unsigned int endPathIndex) const { + return doModulesOnEndPath(endPathIndex); + } + + // The modules in the returned vector will be from the current process + // (not the prior process, and it will never include the source even + // though the source can make products) and these modules will declare + // they produce (they might or might not really produce) at least one + // product in the event (not run, not lumi) that the module corresponding + // to the moduleID argument declares it consumes (includes declarations using + // consumes, maybeConsumes, or consumesMany). Note that if a module declares + // it consumes a module label that is an EDAlias, the corresponding module + // description will be included in the returned vector (but the label in the + // module description is not the EDAlias label). + std::vector const& modulesWhoseProductsAreConsumedBy(unsigned int moduleID) const { + return doModulesWhoseProductsAreConsumedBy(moduleID); + } + + // This returns the declared consumes information for a module. + // Note the other functions above return a reference to an object + // that is held in memory throughout the job, while the following + // function returns a newly created object each time. We do not + // expect this to be called during a normal production job where + // performance and memory are important. These objects are bigger + // than just a pointer. + std::vector consumesInfo(unsigned int moduleID) const { + return doConsumesInfo(moduleID); + } + + private: + + virtual std::vector const& doPaths() const = 0; + virtual std::vector const& doEndPaths() const = 0; + virtual std::vector const& doAllModules() const = 0; + virtual ModuleDescription const* doModuleDescription(unsigned int moduleID) const = 0; + virtual std::vector const& doModulesOnPath(unsigned int pathIndex) const = 0; + virtual std::vector const& doModulesOnEndPath(unsigned int endPathIndex) const = 0; + virtual std::vector const& doModulesWhoseProductsAreConsumedBy(unsigned int moduleID) const = 0; + virtual std::vector doConsumesInfo(unsigned int moduleID) const = 0; + }; +} +#endif diff --git a/FWCore/ServiceRegistry/src/ActivityRegistry.cc b/FWCore/ServiceRegistry/src/ActivityRegistry.cc index 4f9c6f0bfedaa..acd0e7e9b4b13 100644 --- a/FWCore/ServiceRegistry/src/ActivityRegistry.cc +++ b/FWCore/ServiceRegistry/src/ActivityRegistry.cc @@ -130,6 +130,8 @@ namespace edm { void ActivityRegistry::connectLocals(ActivityRegistry& iOther) { + preBeginJobSignal_.connect(std::cref(iOther.preBeginJobSignal_)); + preModuleBeginStreamSignal_.connect(std::cref(iOther.preModuleBeginStreamSignal_)); postModuleBeginStreamSignal_.connect(std::cref(iOther.postModuleBeginStreamSignal_)); @@ -267,6 +269,7 @@ namespace edm { void ActivityRegistry::copySlotsFrom(ActivityRegistry& iOther) { copySlotsToFrom(preallocateSignal_,iOther.preallocateSignal_); + copySlotsToFrom(preBeginJobSignal_, iOther.preBeginJobSignal_); copySlotsToFrom(postBeginJobSignal_, iOther.postBeginJobSignal_); copySlotsToFromReverse(postEndJobSignal_, iOther.postEndJobSignal_); diff --git a/FWCore/ServiceRegistry/src/ConsumesInfo.cc b/FWCore/ServiceRegistry/src/ConsumesInfo.cc new file mode 100644 index 0000000000000..f373bebfa17c2 --- /dev/null +++ b/FWCore/ServiceRegistry/src/ConsumesInfo.cc @@ -0,0 +1,22 @@ +#include "FWCore/ServiceRegistry/interface/ConsumesInfo.h" + +namespace edm { + + ConsumesInfo::ConsumesInfo(TypeID const& iType, + char const* iLabel, + char const* iInstance, + char const* iProcess, + BranchType iBranchType, + KindOfType iKindOfType, + bool iAlwaysGets, + bool iSkipCurrentProcess_) : + type_(iType), + label_(iLabel), + instance_(iInstance), + process_(iProcess), + branchType_(iBranchType), + kindOfType_(iKindOfType), + alwaysGets_(iAlwaysGets), + skipCurrentProcess_(iSkipCurrentProcess_) { + } +} diff --git a/FWCore/ServiceRegistry/src/PathsAndConsumesOfModulesBase.cc b/FWCore/ServiceRegistry/src/PathsAndConsumesOfModulesBase.cc new file mode 100644 index 0000000000000..59ac3b10e6ebc --- /dev/null +++ b/FWCore/ServiceRegistry/src/PathsAndConsumesOfModulesBase.cc @@ -0,0 +1,7 @@ +#include "FWCore/ServiceRegistry/interface/PathsAndConsumesOfModulesBase.h" + +namespace edm { + + PathsAndConsumesOfModulesBase::~PathsAndConsumesOfModulesBase() { + } +} diff --git a/FWCore/Services/src/Tracer.cc b/FWCore/Services/src/Tracer.cc index 2ea212d655646..41452a38f0cf5 100644 --- a/FWCore/Services/src/Tracer.cc +++ b/FWCore/Services/src/Tracer.cc @@ -14,7 +14,12 @@ #include "FWCore/Framework/interface/Run.h" #include "FWCore/Framework/interface/LuminosityBlock.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/ServiceRegistry/interface/ConsumesInfo.h" +#include "FWCore/ServiceRegistry/interface/PathsAndConsumesOfModulesBase.h" #include "FWCore/ServiceRegistry/interface/SystemBounds.h" +#include "FWCore/Utilities/interface/BranchType.h" +#include "FWCore/Utilities/interface/Exception.h" +#include "FWCore/Utilities/interface/ProductKindOfType.h" #include "FWCore/Utilities/interface/TimeOfDay.h" #include "DataFormats/Provenance/interface/EventID.h" @@ -28,10 +33,12 @@ #include "FWCore/ServiceRegistry/interface/GlobalContext.h" #include "FWCore/ServiceRegistry/interface/ModuleCallingContext.h" #include "FWCore/ServiceRegistry/interface/PathContext.h" +#include "FWCore/ServiceRegistry/interface/ProcessContext.h" #include "FWCore/ServiceRegistry/interface/StreamContext.h" #include "DataFormats/Common/interface/HLTPathStatus.h" #include +#include using namespace edm::service; @@ -60,6 +67,7 @@ Tracer::Tracer(ParameterSet const& iPS, ActivityRegistry&iRegistry) : indention_(iPS.getUntrackedParameter("indention")), dumpContextForLabels_(), dumpNonModuleContext_(iPS.getUntrackedParameter("dumpNonModuleContext")), + dumpPathsAndConsumes_(iPS.getUntrackedParameter("dumpPathsAndConsumes")), printTimestamps_(iPS.getUntrackedParameter("printTimestamps")) { for (std::string & label: iPS.getUntrackedParameter>("dumpContextForLabels")) @@ -67,6 +75,7 @@ Tracer::Tracer(ParameterSet const& iPS, ActivityRegistry&iRegistry) : iRegistry.watchPreallocate(this, &Tracer::preallocate); + iRegistry.watchPreBeginJob(this, &Tracer::preBeginJob); iRegistry.watchPostBeginJob(this, &Tracer::postBeginJob); iRegistry.watchPostEndJob(this, &Tracer::postEndJob); @@ -205,6 +214,7 @@ Tracer::fillDescriptions(edm::ConfigurationDescriptions & descriptions) { desc.addUntracked("indention", "++")->setComment("Prefix characters for output. The characters are repeated to form the indentation."); desc.addUntracked>("dumpContextForLabels", std::vector{})->setComment("Prints context information to cout for the module transitions associated with these modules' labels"); desc.addUntracked("dumpNonModuleContext", false)->setComment("Prints context information to cout for the transitions not associated with any module label"); + desc.addUntracked("dumpPathsAndConsumes", false)->setComment("Prints information to cout about paths, endpaths, products consumed by modules and the dependencies between modules created by the products they consume"); desc.addUntracked("printTimestamps", false)->setComment("Prints a time stamp for every transition"); descriptions.add("Tracer", desc); descriptions.setComment("This service prints each phase the framework is processing, e.g. constructing a module,running a module, etc."); @@ -218,6 +228,93 @@ Tracer::preallocate(service::SystemBounds const& bounds) { } void +Tracer::preBeginJob(PathsAndConsumesOfModulesBase const& pathsAndConsumes, ProcessContext const& pc) { + LogAbsolute out("Tracer"); + out << TimeStamper(printTimestamps_) << indention_ << " starting: begin job"; + if(dumpPathsAndConsumes_) { + out << "\n" << "Process name = " << pc.processName() << "\n"; + out << "paths:\n"; + std::vector const& paths = pathsAndConsumes.paths(); + for(auto const& path : paths) { + out << " " << path << "\n"; + } + out << "end paths:\n"; + std::vector const& endpaths = pathsAndConsumes.endPaths(); + for(auto const& endpath : endpaths) { + out << " " << endpath << "\n"; + } + for(unsigned int j = 0; j < paths.size(); ++j) { + std::vector const& modulesOnPath = pathsAndConsumes.modulesOnPath(j); + out << "modules on path " << paths.at(j) << ":\n"; + for(auto const& desc : modulesOnPath) { + out << " " << desc->moduleLabel() << "\n"; + } + } + for(unsigned int j = 0; j < endpaths.size(); ++j) { + std::vector const& modulesOnEndPath = pathsAndConsumes.modulesOnEndPath(j); + out << "modules on end path " << endpaths.at(j) << ":\n"; + for(auto const& desc : modulesOnEndPath) { + out << " " << desc->moduleLabel() << "\n"; + } + } + std::vector const& allModules = pathsAndConsumes.allModules(); + out << "All modules and modules in the current process whose products they consume:\n"; + out << "(This does not include modules from previous processes or the source)\n"; + for(auto const& module : allModules) { + out << " " << module->moduleName() << "/\'" << module->moduleLabel() << "\'"; + unsigned int moduleID = module->id(); + if(pathsAndConsumes.moduleDescription(moduleID) != module) { + throw cms::Exception("TestFailure") << "Tracer::preBeginJob, moduleDescription returns incorrect value"; + } + std::vector const& modulesWhoseProductsAreConsumedBy = + pathsAndConsumes.modulesWhoseProductsAreConsumedBy(moduleID); + if(!modulesWhoseProductsAreConsumedBy.empty()) { + out << " consumes products from these modules:\n"; + for(auto const& producingModule : modulesWhoseProductsAreConsumedBy) { + out << " " << producingModule->moduleName() << "/\'" << producingModule->moduleLabel() << "\'\n"; + } + } else { + out << "\n"; + } + } + out << "All modules (listed by class and label) and all their consumed products.\n"; + out << "Consumed products are listed by type, label, instance, process.\n"; + out << "For products not in the event, \'run\' or \'lumi\' is added to indicate the TTree they are from.\n"; + out << "For products that are declared with mayConsume, \'may consume\' is added.\n"; + out << "For products consumed for Views, \'element type\' is added\n"; + out << "For products only read from previous processes, \'skip current process\' is added\n"; + for(auto const* module : allModules) { + out << " " << module->moduleName() << "/\'" << module->moduleLabel() << "\'"; + std::vector consumesInfo = pathsAndConsumes.consumesInfo(module->id()); + if(!consumesInfo.empty()) { + out << " consumes:\n"; + for(auto const& info : consumesInfo) { + out << " " << info.type() << " \'" << info.label() << "\' \'" << info.instance(); + out << "\' \'" << info.process() << "\'"; + if(info.branchType() == InLumi) { + out << ", lumi"; + } else if(info.branchType() == InRun) { + out << ", run"; + } + if(!info.alwaysGets()) { + out << ", may consume"; + } + if(info.kindOfType() == ELEMENT_TYPE) { + out << ", element type"; + } + if(info.skipCurrentProcess()) { + out << ", skip current process"; + } + out << "\n"; + } + } else { + out << "\n"; + } + } + } +} + +void Tracer::postBeginJob() { LogAbsolute("Tracer") << TimeStamper(printTimestamps_) << indention_ << " finished: begin job"; } diff --git a/FWCore/Services/src/Tracer.h b/FWCore/Services/src/Tracer.h index 038f77314d126..4b02dbf09fca6 100644 --- a/FWCore/Services/src/Tracer.h +++ b/FWCore/Services/src/Tracer.h @@ -38,6 +38,8 @@ namespace edm { class ModuleCallingContext; class ModuleDescription; class PathContext; + class PathsAndConsumesOfModulesBase; + class ProcessContext; class Run; class StreamContext; @@ -50,6 +52,7 @@ namespace edm { void preallocate(service::SystemBounds const&); + void preBeginJob(PathsAndConsumesOfModulesBase const&, ProcessContext const&); void postBeginJob(); void postEndJob(); @@ -145,6 +148,7 @@ namespace edm { std::string indention_; std::set dumpContextForLabels_; bool dumpNonModuleContext_; + bool dumpPathsAndConsumes_; bool printTimestamps_; }; } From 0585bf21ae098f14f144b9a3d361178e6cc830e6 Mon Sep 17 00:00:00 2001 From: nhanvtran Date: Tue, 9 Dec 2014 23:26:23 -0600 Subject: [PATCH 12/28] adding fix for miniAOD definitions of charged particles --- CommonTools/PileupAlgos/plugins/PuppiProducer.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CommonTools/PileupAlgos/plugins/PuppiProducer.cc b/CommonTools/PileupAlgos/plugins/PuppiProducer.cc index e3622110513c3..b02f61b262dbc 100644 --- a/CommonTools/PileupAlgos/plugins/PuppiProducer.cc +++ b/CommonTools/PileupAlgos/plugins/PuppiProducer.cc @@ -111,8 +111,8 @@ void PuppiProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { if(closestVtx != 0 && pVtxId == 0 && fabs(pReco.charge) > 0) pReco.id = 1; if(closestVtx != 0 && pVtxId > 0 && fabs(pReco.charge) > 0) pReco.id = 2; //Add a dZ cut if wanted (this helps) - if(fUseDZ && pDZ > -9999 && closestVtx == 0 && (fabs(pDZ) < fDZCut)) pReco.id = 1; - if(fUseDZ && pDZ > -9999 && closestVtx == 0 && (fabs(pDZ) > fDZCut)) pReco.id = 2; + if(fUseDZ && pDZ > -9999 && closestVtx == 0 && (fabs(pDZ) < fDZCut) && fabs(pReco.charge) > 0) pReco.id = 1; + if(fUseDZ && pDZ > -9999 && closestVtx == 0 && (fabs(pDZ) > fDZCut) && fabs(pReco.charge) > 0) pReco.id = 2; //std::cout << "pVtxId = " << pVtxId << ", and charge = " << itPF->charge() << ", and closestVtx = " << closestVtx << ", and id = " << pReco.id << std::endl; From 83e594731c7972ec910ba7f4c8b7e808096f0c51 Mon Sep 17 00:00:00 2001 From: Philip Date: Wed, 10 Dec 2014 09:54:50 +0100 Subject: [PATCH 13/28] fixed chi2 constraint on pedestal and time --- .../src/PulseShapeFitOOTPileupCorrection.cc | 24 +++++++++---------- 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/RecoLocalCalo/HcalRecAlgos/src/PulseShapeFitOOTPileupCorrection.cc b/RecoLocalCalo/HcalRecAlgos/src/PulseShapeFitOOTPileupCorrection.cc index 4c42a09aee01e..138e9308b3f2b 100644 --- a/RecoLocalCalo/HcalRecAlgos/src/PulseShapeFitOOTPileupCorrection.cc +++ b/RecoLocalCalo/HcalRecAlgos/src/PulseShapeFitOOTPileupCorrection.cc @@ -132,18 +132,18 @@ namespace FitterFuncs{ for (i=0;i Date: Wed, 10 Dec 2014 12:33:50 +0100 Subject: [PATCH 14/28] Updating relval_steps.py to switch to the pythia8 tune 8CUEP8M1 which is planned for run2 --- .../python/relval_steps.py | 282 +++++++++--------- 1 file changed, 141 insertions(+), 141 deletions(-) diff --git a/Configuration/PyReleaseValidation/python/relval_steps.py b/Configuration/PyReleaseValidation/python/relval_steps.py index 1da319fd218c4..e7e0b8ca2e0a2 100644 --- a/Configuration/PyReleaseValidation/python/relval_steps.py +++ b/Configuration/PyReleaseValidation/python/relval_steps.py @@ -124,9 +124,9 @@ def merge(dictlist,TELL=False): #wmsplit = {} #### Production test section #### -steps['ProdMinBias']=merge([{'cfg':'MinBias_8TeV_cfi','--relval':'9000,300'},step1Defaults]) -steps['ProdTTbar']=merge([{'cfg':'TTbar_Tauola_8TeV_cfi','--relval':'9000,100'},step1Defaults]) -steps['ProdQCD_Pt_3000_3500']=merge([{'cfg':'QCD_Pt_3000_3500_8TeV_cfi','--relval':'9000,50'},step1Defaults]) +steps['ProdMinBias']=merge([{'cfg':'MinBias_8TeV_pythia8_TuneCUETP8M1_cff','--relval':'9000,300'},step1Defaults]) +steps['ProdTTbar']=merge([{'cfg':'TTbar_Tauola_8TeV_TuneCUETP8M1_cfi','--relval':'9000,100'},step1Defaults]) +steps['ProdQCD_Pt_3000_3500']=merge([{'cfg':'QCD_Pt_3000_3500_8TeV_TuneCUETP8M1_cfi','--relval':'9000,50'},step1Defaults]) #### data #### #list of run to harvest for 2010A: 144086,144085,144084,144083,144011,139790,139789,139788,139787,138937,138934,138924,138923 @@ -249,65 +249,65 @@ def gen2015(fragment,howMuch): return merge([{'cfg':fragment},howMuch,step1Up2015Defaults]) ### Production test: 13 TeV equivalents -steps['ProdMinBias_13']=gen2015('MinBias_13TeV_cfi',Kby(9,100)) -steps['ProdTTbar_13']=gen2015('TTbar_Tauola_13TeV_cfi',Kby(9,100)) -steps['ProdZEE_13']=gen2015('ZEE_13TeV_cfi',Kby(9,100)) -steps['ProdQCD_Pt_3000_3500_13']=gen2015('QCD_Pt_3000_3500_13TeV_cfi',Kby(9,100)) - -steps['MinBias']=gen('MinBias_8TeV_cfi',Kby(9,300)) -steps['QCD_Pt_3000_3500']=gen('QCD_Pt_3000_3500_8TeV_cfi',Kby(9,25)) -steps['QCD_Pt_600_800']=gen('QCD_Pt_600_800_8TeV_cfi',Kby(9,50)) -steps['QCD_Pt_80_120']=gen('QCD_Pt_80_120_8TeV_cfi',Kby(9,100)) -steps['MinBias_13']=gen2015('MinBias_13TeV_cfi',Kby(100,300)) # set HS to provide adequate pool for PU -steps['QCD_Pt_3000_3500_13']=gen2015('QCD_Pt_3000_3500_13TeV_cfi',Kby(9,25)) -steps['QCD_Pt_600_800_13']=gen2015('QCD_Pt_600_800_13TeV_cfi',Kby(9,50)) -steps['QCD_Pt_80_120_13']=gen2015('QCD_Pt_80_120_13TeV_cfi',Kby(9,100)) - -steps['QCD_Pt_30_80_BCtoE_8TeV']=gen('QCD_Pt_30_80_BCtoE_8TeV',Kby(9000,100)) -steps['QCD_Pt_80_170_BCtoE_8TeV']=gen('QCD_Pt_80_170_BCtoE_8TeV',Kby(9000,100)) -steps['SingleElectronPt10']=gen('SingleElectronPt10_cfi',Kby(9,3000)) -steps['SingleElectronPt35']=gen('SingleElectronPt35_cfi',Kby(9,500)) -steps['SingleElectronPt1000']=gen('SingleElectronPt1000_cfi',Kby(9,50)) -steps['SingleElectronFlatPt1To100']=gen('SingleElectronFlatPt1To100_cfi',Mby(2,100)) -steps['SingleGammaPt10']=gen('SingleGammaPt10_cfi',Kby(9,3000)) -steps['SingleGammaPt35']=gen('SingleGammaPt35_cfi',Kby(9,500)) -steps['SingleMuPt1']=gen('SingleMuPt1_cfi',Kby(25,1000)) -steps['SingleMuPt10']=gen('SingleMuPt10_cfi',Kby(25,500)) -steps['SingleMuPt100']=gen('SingleMuPt100_cfi',Kby(9,500)) -steps['SingleMuPt1000']=gen('SingleMuPt1000_cfi',Kby(9,500)) -steps['SingleElectronPt10_UP15']=gen2015('SingleElectronPt10_cfi',Kby(9,3000)) -steps['SingleElectronPt35_UP15']=gen2015('SingleElectronPt35_cfi',Kby(9,500)) -steps['SingleElectronPt1000_UP15']=gen2015('SingleElectronPt1000_cfi',Kby(9,50)) -steps['SingleElectronFlatPt1To100_UP15']=gen2015('SingleElectronFlatPt1To100_cfi',Mby(2,100)) -steps['SingleGammaPt10_UP15']=gen2015('SingleGammaPt10_cfi',Kby(9,3000)) -steps['SingleGammaPt35_UP15']=gen2015('SingleGammaPt35_cfi',Kby(9,500)) -steps['SingleMuPt1_UP15']=gen2015('SingleMuPt1_cfi',Kby(25,1000)) -steps['SingleMuPt10_UP15']=gen2015('SingleMuPt10_cfi',Kby(25,500)) -steps['SingleMuPt100_UP15']=gen2015('SingleMuPt100_cfi',Kby(9,500)) -steps['SingleMuPt1000_UP15']=gen2015('SingleMuPt1000_cfi',Kby(9,500)) -steps['TTbar']=gen('TTbar_Tauola_8TeV_cfi',Kby(9,100)) -steps['TTbarLepton']=gen('TTbarLepton_Tauola_8TeV_cfi',Kby(9,100)) -steps['ZEE']=gen('ZEE_8TeV_cfi',Kby(9,100)) -steps['Wjet_Pt_80_120']=gen('Wjet_Pt_80_120_8TeV_cfi',Kby(9,100)) -steps['Wjet_Pt_3000_3500']=gen('Wjet_Pt_3000_3500_8TeV_cfi',Kby(9,50)) +steps['ProdMinBias_13']=gen2015('MinBias_13TeV_pythia8_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ProdTTbar_13']=gen2015('TTbar_Tauola_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ProdZEE_13']=gen2015('ZEE_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ProdQCD_Pt_3000_3500_13']=gen2015('QCD_Pt_3000_3500_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) + +steps['MinBias']=gen('MinBias_8TeV_pythia8_TuneCUETP8M1_cff',Kby(9,300)) +steps['QCD_Pt_3000_3500']=gen('QCD_Pt_3000_3500_8TeV_TuneCUETP8M1_cfi',Kby(9,25)) +steps['QCD_Pt_600_800']=gen('QCD_Pt_600_800_8TeV_TuneCUETP8M1_cfi',Kby(9,50)) +steps['QCD_Pt_80_120']=gen('QCD_Pt_80_120_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['MinBias_13']=gen2015('MinBias_13TeV_pythia8_TuneCUETP8M1_cfi',Kby(100,300)) # set HS to provide adequate pool for PU +steps['QCD_Pt_3000_3500_13']=gen2015('QCD_Pt_3000_3500_13TeV_TuneCUETP8M1_cfi',Kby(9,25)) +steps['QCD_Pt_600_800_13']=gen2015('QCD_Pt_600_800_13TeV_TuneCUETP8M1_cfi',Kby(9,50)) +steps['QCD_Pt_80_120_13']=gen2015('QCD_Pt_80_120_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) + +steps['QCD_Pt_30_80_BCtoE_8TeV']=gen('QCD_Pt_30_80_BCtoE_8TeV_TuneCUETP8M1_cfi',Kby(9000,100)) +steps['QCD_Pt_80_170_BCtoE_8TeV']=gen('QCD_Pt_80_170_BCtoE_8TeV_TuneCUETP8M1_cfi',Kby(9000,100)) +steps['SingleElectronPt10']=gen('SingleElectronPt10_pythia8_cfi',Kby(9,3000)) +steps['SingleElectronPt35']=gen('SingleElectronPt35_pythia8_cfi',Kby(9,500)) +steps['SingleElectronPt1000']=gen('SingleElectronPt1000_pythia8_cfi',Kby(9,50)) +steps['SingleElectronFlatPt1To100']=gen('SingleElectronFlatPt1To100_pythia8_cfi',Mby(2,100)) +steps['SingleGammaPt10']=gen('SingleGammaPt10_pythia8_cfi',Kby(9,3000)) +steps['SingleGammaPt35']=gen('SingleGammaPt35_pythia8_cfi',Kby(9,500)) +steps['SingleMuPt1']=gen('SingleMuPt1_pythia8_cfi',Kby(25,1000)) +steps['SingleMuPt10']=gen('SingleMuPt10_pythia8_cfi',Kby(25,500)) +steps['SingleMuPt100']=gen('SingleMuPt100_pythia8_cfi',Kby(9,500)) +steps['SingleMuPt1000']=gen('SingleMuPt1000_pythia8_cfi',Kby(9,500)) +steps['SingleElectronPt10_UP15']=gen2015('SingleElectronPt10_pythia8_cfi',Kby(9,3000)) +steps['SingleElectronPt35_UP15']=gen2015('SingleElectronPt35_pythia8_cfi',Kby(9,500)) +steps['SingleElectronPt1000_UP15']=gen2015('SingleElectronPt1000_pythia8_cfi',Kby(9,50)) +steps['SingleElectronFlatPt1To100_UP15']=gen2015('SingleElectronFlatPt1To100_pythia8_cfi',Mby(2,100)) +steps['SingleGammaPt10_UP15']=gen2015('SingleGammaPt10_pythia8_cfi',Kby(9,3000)) +steps['SingleGammaPt35_UP15']=gen2015('SingleGammaPt35_pythia8_cfi',Kby(9,500)) +steps['SingleMuPt1_UP15']=gen2015('SingleMuPt1_pythia8_cfi',Kby(25,1000)) +steps['SingleMuPt10_UP15']=gen2015('SingleMuPt10_pythia8_cfi',Kby(25,500)) +steps['SingleMuPt100_UP15']=gen2015('SingleMuPt100_pythia8_cfi',Kby(9,500)) +steps['SingleMuPt1000_UP15']=gen2015('SingleMuPt1000_pythia8_cfi',Kby(9,500)) +steps['TTbar']=gen('TTbar_Tauola_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['TTbarLepton']=gen('TTbarLepton_Tauola_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ZEE']=gen('ZEE_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['Wjet_Pt_80_120']=gen('Wjet_Pt_80_120_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['Wjet_Pt_3000_3500']=gen('Wjet_Pt_3000_3500_8TeV_TuneCUETP8M1_cfi',Kby(9,50)) steps['LM1_sfts']=gen('LM1_sfts_8TeV_cfi',Kby(9,100)) -steps['QCD_FlatPt_15_3000']=gen('QCDForPF_8TeV_cfi',Kby(5,100)) -steps['QCD_FlatPt_15_3000HS']=gen('QCDForPF_8TeV_cfi',Kby(50,100)) -steps['TTbar_13']=gen2015('TTbar_Tauola_13TeV_cfi',Kby(9,100)) -steps['TTbarLepton_13']=gen2015('TTbarLepton_Tauola_13TeV_cfi',Kby(9,100)) -steps['ZEE_13']=gen2015('ZEE_13TeV_cfi',Kby(9,100)) -steps['Wjet_Pt_80_120_13']=gen2015('Wjet_Pt_80_120_13TeV_cfi',Kby(9,100)) -steps['Wjet_Pt_3000_3500_13']=gen2015('Wjet_Pt_3000_3500_13TeV_cfi',Kby(9,50)) +steps['QCD_FlatPt_15_3000']=gen('QCDForPF_8TeV_TuneCUETP8M1_cfi',Kby(5,100)) +steps['QCD_FlatPt_15_3000HS']=gen('QCDForPF_8TeV_TuneCUETP8M1_cfi',Kby(50,100)) +steps['TTbar_13']=gen2015('TTbar_Tauola_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['TTbarLepton_13']=gen2015('TTbarLepton_Tauola_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ZEE_13']=gen2015('ZEE_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['Wjet_Pt_80_120_13']=gen2015('Wjet_Pt_80_120_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['Wjet_Pt_3000_3500_13']=gen2015('Wjet_Pt_3000_3500_13TeV_TuneCUETP8M1_cfi',Kby(9,50)) steps['LM1_sfts_13']=gen2015('LM1_sfts_13TeV_cfi',Kby(9,100)) -steps['QCD_FlatPt_15_3000_13']=gen2015('QCDForPF_13TeV_cfi',Kby(9,100)) -steps['QCD_FlatPt_15_3000HS_13']=gen2015('QCDForPF_13TeV_cfi',Kby(50,100)) +steps['QCD_FlatPt_15_3000_13']=gen2015('QCDForPF_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['QCD_FlatPt_15_3000HS_13']=gen2015('QCDForPF_13TeV_TuneCUETP8M1_cfi',Kby(50,100)) -steps['ZpMM_2250_8TeV_Tauola']=gen('ZpMM_2250_8TeV_Tauola_cfi',Kby(9,100)) -steps['ZpEE_2250_8TeV_Tauola']=gen('ZpEE_2250_8TeV_Tauola_cfi',Kby(9,100)) -steps['ZpTT_1500_8TeV_Tauola']=gen('ZpTT_1500_8TeV_Tauola_cfi',Kby(9,100)) -steps['ZpMM_2250_13TeV_Tauola']=gen2015('ZpMM_2250_13TeV_Tauola_cfi',Kby(9,100)) -steps['ZpEE_2250_13TeV_Tauola']=gen2015('ZpEE_2250_13TeV_Tauola_cfi',Kby(9,100)) -steps['ZpTT_1500_13TeV_Tauola']=gen2015('ZpTT_1500_13TeV_Tauola_cfi',Kby(9,100)) +steps['ZpMM_2250_8TeV_Tauola']=gen('ZpMM_2250_8TeV_Tauola_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ZpEE_2250_8TeV_Tauola']=gen('ZpEE_2250_8TeV_Tauola_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ZpTT_1500_8TeV_Tauola']=gen('ZpTT_1500_8TeV_Tauola_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ZpMM_2250_13TeV_Tauola']=gen2015('ZpMM_2250_13TeV_Tauola_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ZpEE_2250_13TeV_Tauola']=gen2015('ZpEE_2250_13TeV_Tauola_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ZpTT_1500_13TeV_Tauola']=gen2015('ZpTT_1500_13TeV_Tauola_TuneCUETP8M1_cfi',Kby(9,100)) def identitySim(wf): return merge([{'--restoreRND':'SIM','--process':'SIM2', '--inputCommands':'"keep *","drop *TagInfo*_*_*_*"' },wf]) @@ -422,20 +422,20 @@ def identitySim(wf): '--customise':'Validation/Configuration/ECALHCAL.customise,SimGeneral/MixingModule/fullMixCustomize_cff.setCrossingFrameOn', '--beamspot':'NoSmear'} -steps['SingleElectronE120EHCAL']=merge([{'cfg':'SingleElectronE120EHCAL_cfi'},ecalHcal,Kby(25,250),step1Defaults]) -steps['SinglePiE50HCAL']=merge([{'cfg':'SinglePiE50HCAL_cfi'},ecalHcal,Kby(25,250),step1Defaults]) +steps['SingleElectronE120EHCAL']=merge([{'cfg':'SingleElectronE120EHCAL_pythia8_cfi'},ecalHcal,Kby(25,250),step1Defaults]) +steps['SinglePiE50HCAL']=merge([{'cfg':'SinglePiE50HCAL_pythia8_cfi'},ecalHcal,Kby(25,250),step1Defaults]) -steps['MinBiasHS']=gen('MinBias_8TeV_cfi',Kby(25,300)) -steps['InclusiveppMuX']=gen('InclusiveppMuX_8TeV_cfi',Mby(11,45000)) -steps['SingleElectronFlatPt5To100']=gen('SingleElectronFlatPt5To100_cfi',Kby(25,250)) -steps['SinglePiPt1']=gen('SinglePiPt1_cfi',Kby(25,250)) -steps['SingleMuPt1HS']=gen('SingleMuPt1_cfi',Kby(25,1000)) -steps['ZPrime5000Dijet']=gen('ZPrime5000JJ_8TeV_cfi',Kby(25,100)) -steps['SinglePi0E10']=gen('SinglePi0E10_cfi',Kby(25,100)) -steps['SinglePiPt10']=gen('SinglePiPt10_cfi',Kby(25,250)) -steps['SingleGammaFlatPt10To100']=gen('SingleGammaFlatPt10To100_cfi',Kby(25,250)) -steps['SingleTauPt50Pythia']=gen('SingleTaupt_50_cfi',Kby(25,100)) -steps['SinglePiPt100']=gen('SinglePiPt100_cfi',Kby(25,250)) +steps['MinBiasHS']=gen('MinBias_8TeV_pythia8_TuneCUETP8M1_cff',Kby(25,300)) +steps['InclusiveppMuX']=gen('InclusiveppMuX_8TeV_TuneCUETP8M1_cfi',Mby(11,45000)) +steps['SingleElectronFlatPt5To100']=gen('SingleElectronFlatPt5To100_pythia8_cfi',Kby(25,250)) +steps['SinglePiPt1']=gen('SinglePiPt1_pythia8_cfi',Kby(25,250)) +steps['SingleMuPt1HS']=gen('SingleMuPt1_pythia8_cfi',Kby(25,1000)) +steps['ZPrime5000Dijet']=gen('ZPrime5000JJ_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) +steps['SinglePi0E10']=gen('SinglePi0E10_pythia8_cfi',Kby(25,100)) +steps['SinglePiPt10']=gen('SinglePiPt10_pythia8_cfi',Kby(25,250)) +steps['SingleGammaFlatPt10To100']=gen('SingleGammaFlatPt10To100_pythia8_cfi',Kby(25,250)) +steps['SingleTauPt50Pythia']=gen('SingleTaupt_50_pythia8_cfi',Kby(25,100)) +steps['SinglePiPt100']=gen('SinglePiPt100_pythia8_cfi',Kby(25,250)) def genS(fragment,howMuch): @@ -443,37 +443,37 @@ def genS(fragment,howMuch): return merge([{'cfg':fragment},stCond,howMuch,step1Defaults]) steps['Higgs200ChargedTaus']=genS('H200ChargedTaus_Tauola_8TeV_cfi',Kby(9,100)) -steps['JpsiMM']=genS('JpsiMM_8TeV_cfi',Kby(66,1000)) -steps['WE']=genS('WE_8TeV_cfi',Kby(9,100)) -steps['WM']=genS('WM_8TeV_cfi',Kby(9,200)) -steps['WpM']=genS('WpM_8TeV_cfi',Kby(9,200)) -steps['ZMM']=genS('ZMM_8TeV_cfi',Kby(18,300)) -steps['ZpMM']=genS('ZpMM_8TeV_cfi',Kby(9,200)) +steps['JpsiMM']=genS('JpsiMM_8TeV_TuneCUETP8M1_cfi',Kby(66,1000)) +steps['WE']=genS('WE_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['WM']=genS('WM_8TeV_TuneCUETP8M1_cfi',Kby(9,200)) +steps['WpM']=genS('WpM_8TeV_TuneCUETP8M1_cfi',Kby(9,200)) +steps['ZMM']=genS('ZMM_8TeV_TuneCUETP8M1_cfi',Kby(18,300)) +steps['ZpMM']=genS('ZpMM_8TeV_TuneCUETP8M1_cfi',Kby(9,200)) steps['Higgs200ChargedTaus_13']=gen2015('H200ChargedTaus_Tauola_13TeV_cfi',Kby(9,100)) -steps['Upsilon1SToMuMu_13']=gen2015('Upsilon1SToMuMu_forSTEAM_13TeV_cfi',Kby(17,190)) -steps['BuToKstarMuMu_13']=gen2015('BuToKstarMuMu_forSTEAM_13TeV_cfi',Kby(2250,25000)) -steps['BsToMuMu_13']=gen2015('BsToMuMu_forSTEAM_13TeV_cfi',Kby(30000,333333)) -steps['JpsiMuMu_Pt-15']=gen2015('JpsiMuMu_Pt-15_forSTEAM_13TeV_cfi',Kby(11000,122000)) -steps['BuToKstarPsi2S_13']=gen2015('BuToKstarPsi2S_forSTEAM_13TeV_cfi',Kby(16000,176000)) -steps['WE_13']=gen2015('WE_13TeV_cfi',Kby(9,100)) -steps['WM_13']=gen2015('WM_13TeV_cfi',Kby(9,200)) -steps['WpM_13']=gen2015('WpM_13TeV_cfi',Kby(9,200)) -steps['ZMM_13']=gen2015('ZMM_13TeV_cfi',Kby(18,300)) -steps['ZpMM_13']=gen2015('ZpMM_13TeV_cfi',Kby(9,200)) - -steps['ZTT']=genS('ZTT_Tauola_All_hadronic_8TeV_cfi',Kby(9,150)) -steps['H130GGgluonfusion']=genS('H130GGgluonfusion_8TeV_cfi',Kby(9,100)) -steps['PhotonJets_Pt_10']=genS('PhotonJet_Pt_10_8TeV_cfi',Kby(9,150)) -steps['QQH1352T_Tauola']=genS('QQH1352T_Tauola_8TeV_cfi',Kby(9,100)) -steps['ZTT_13']=gen2015('ZTT_Tauola_All_hadronic_13TeV_cfi',Kby(9,150)) -steps['H130GGgluonfusion_13']=gen2015('H130GGgluonfusion_13TeV_cfi',Kby(9,100)) -steps['PhotonJets_Pt_10_13']=gen2015('PhotonJet_Pt_10_13TeV_cfi',Kby(9,150)) -steps['QQH1352T_Tauola_13']=gen2015('QQH1352T_Tauola_13TeV_cfi',Kby(9,100)) -#steps['ZmumuJets_Pt_20_300']=gen('ZmumuJets_Pt_20_300_GEN_8TeV_cfg',Kby(25,100)) -steps['ADDMonoJet_d3MD3']=genS('ADDMonoJet_8TeV_d3MD3_cfi',Kby(9,100)) -steps['ADDMonoJet_d3MD3_13']=gen2015('ADDMonoJet_13TeV_d3MD3_cfi',Kby(9,100)) -steps['RSKKGluon_m3000GeV_13']=gen2015('RSKKGluon_m3000GeV_13TeV_cff',Kby(9,100)) -steps['Pythia6_BuJpsiK_TuneZ2star_13']=gen2015('Pythia6_BuJpsiK_TuneZ2star_13TeV_cfi',Kby(36000,400000)) +steps['Upsilon1SToMuMu_13']=gen2015('Upsilon1SToMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi',Kby(17,190)) +steps['BuToKstarMuMu_13']=gen2015('BuToKstarMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi',Kby(2250,25000)) +steps['BsToMuMu_13']=gen2015('BsToMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi',Kby(30000,333333)) +steps['JpsiMuMu_Pt-15']=gen2015('JpsiMuMu_Pt-15_forSTEAM_13TeV_TuneCUETP8M1_cfi',Kby(11000,122000)) +steps['BuToKstarPsi2S_13']=gen2015('BuToKstarPsi2S_forSTEAM_13TeV_TuneCUETP8M1_cfi',Kby(16000,176000)) +steps['WE_13']=gen2015('WE_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['WM_13']=gen2015('WM_13TeV_TuneCUETP8M1_cfi',Kby(9,200)) +steps['WpM_13']=gen2015('WpM_13TeV_TuneCUETP8M1_cfi',Kby(9,200)) +steps['ZMM_13']=gen2015('ZMM_13TeV_TuneCUETP8M1_cfi',Kby(18,300)) +steps['ZpMM_13']=gen2015('ZpMM_13TeV_TuneCUETP8M1_cfi',Kby(9,200)) + +steps['ZTT']=genS('ZTT_Tauola_All_hadronic_8TeV_TuneCUETP8M1_cfi',Kby(9,150)) +steps['H130GGgluonfusion']=genS('H130GGgluonfusion_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['PhotonJets_Pt_10']=genS('PhotonJet_Pt_10_8TeV_TuneCUETP8M1_cfi',Kby(9,150)) +steps['QQH1352T_Tauola']=genS('QQH1352T_Tauola_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ZTT_13']=gen2015('ZTT_Tauola_All_hadronic_13TeV_TuneCUETP8M1_cfi',Kby(9,150)) +steps['H130GGgluonfusion_13']=gen2015('H130GGgluonfusion_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['PhotonJets_Pt_10_13']=gen2015('PhotonJet_Pt_10_13TeV_TuneCUETP8M1_cfi',Kby(9,150)) +steps['QQH1352T_Tauola_13']=gen2015('QQH1352T_Tauola_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) +#steps['ZmumuJets_Pt_20_300']=gen('ZmumuJets_Pt_20_300_GEN_8TeV_TuneCUETP8M1_cfg',Kby(25,100)) +steps['ADDMonoJet_d3MD3']=genS('ADDMonoJet_8TeV_d3MD3_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ADDMonoJet_d3MD3_13']=gen2015('ADDMonoJet_13TeV_d3MD3_TuneCUETP8M1_cfi',Kby(9,100)) +steps['RSKKGluon_m3000GeV_13']=gen2015('RSKKGluon_m3000GeV_13TeV_TuneCUETP8M1_cff',Kby(9,100)) +steps['Pythia6_BuJpsiK_TuneZ2star_13']=gen2015('Pythia6_BuJpsiK_TuneZ2star_13TeV_TuneCUETP8M1_cfi',Kby(36000,400000)) steps['MinBias2INPUT']={'INPUT':InputInfo(dataSet='/RelValMinBias/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} steps['Higgs200ChargedTausINPUT']={'INPUT':InputInfo(dataSet='/RelValHiggs200ChargedTaus/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} @@ -506,23 +506,23 @@ def genS(fragment,howMuch): # steps['CosmicsINPUT']={'INPUT':InputInfo(dataSet='/RelValCosmics/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} steps['BeamHaloINPUT']={'INPUT':InputInfo(dataSet='/RelValBeamHalo/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} -steps['QCD_Pt_50_80']=genS('QCD_Pt_50_80_8TeV_cfi',Kby(25,100)) -steps['QCD_Pt_15_20']=genS('QCD_Pt_15_20_8TeV_cfi',Kby(25,100)) +steps['QCD_Pt_50_80']=genS('QCD_Pt_50_80_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) +steps['QCD_Pt_15_20']=genS('QCD_Pt_15_20_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) steps['ZTTHS']=merge([Kby(25,100),steps['ZTT']]) -steps['QQH120Inv']=genS('QQH120Inv_8TeV_cfi',Kby(25,100)) +steps['QQH120Inv']=genS('QQH120Inv_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) steps['TTbar2HS']=merge([Kby(25,100),steps['TTbar']]) -steps['JpsiMM_Pt_20_inf']=genS('JpsiMM_Pt_20_inf_8TeV_cfi',Kby(70,280)) -steps['QCD_Pt_120_170']=genS('QCD_Pt_120_170_8TeV_cfi',Kby(25,100)) -steps['H165WW2L']=genS('H165WW2L_Tauola_8TeV_cfi',Kby(25,100)) -steps['UpsMM']=genS('UpsMM_8TeV_cfi',Kby(56250,225)) -steps['RSGrav']=genS('RS750_quarks_and_leptons_8TeV_cff',Kby(25,100)) +steps['JpsiMM_Pt_20_inf']=genS('JpsiMM_Pt_20_inf_8TeV_TuneCUETP8M1_cfi',Kby(70,280)) +steps['QCD_Pt_120_170']=genS('QCD_Pt_120_170_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) +steps['H165WW2L']=genS('H165WW2L_Tauola_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) +steps['UpsMM']=genS('UpsMM_8TeV_TuneCUETP8M1_cfi',Kby(56250,225)) +steps['RSGrav']=genS('RS750_quarks_and_leptons_TuneCUETP8M1_8TeV_cff',Kby(25,100)) steps['QCD_Pt_80_120_2HS']=merge([Kby(25,100),steps['QCD_Pt_80_120']]) -steps['bJpsiX']=genS('bJpsiX_8TeV_cfi',Mby(325,1300000)) -steps['QCD_Pt_30_50']=genS('QCD_Pt_30_50_8TeV_cfi',Kby(25,100)) -steps['H200ZZ4L']=genS('H200ZZ4L_Tauola_8TeV_cfi',Kby(25,100)) +steps['bJpsiX']=genS('bJpsiX_8TeV_TuneCUETP8M1_cfi',Mby(325,1300000)) +steps['QCD_Pt_30_50']=genS('QCD_Pt_30_50_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) +steps['H200ZZ4L']=genS('H200ZZ4L_Tauola_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) steps['LM9p']=genS('LM9p_8TeV_cff',Kby(25,100)) -steps['QCD_Pt_20_30']=genS('QCD_Pt_20_30_8TeV_cfi',Kby(25,100)) -steps['QCD_Pt_170_230']=genS('QCD_Pt_170_230_8TeV_cfi',Kby(25,100)) +steps['QCD_Pt_20_30']=genS('QCD_Pt_20_30_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) +steps['QCD_Pt_170_230']=genS('QCD_Pt_170_230_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) @@ -598,43 +598,43 @@ def addForAll(steps,d): #step1FastDefaults -steps['TTbarFS']=merge([{'cfg':'TTbar_Tauola_8TeV_cfi'},Kby(100,1000),step1FastDefaults]) -steps['SingleMuPt1FS']=merge([{'cfg':'SingleMuPt1_cfi'},step1FastDefaults]) -steps['SingleMuPt10FS']=merge([{'cfg':'SingleMuPt10_cfi'},step1FastDefaults]) -steps['SingleMuPt100FS']=merge([{'cfg':'SingleMuPt100_cfi'},step1FastDefaults]) -steps['SinglePiPt1FS']=merge([{'cfg':'SinglePiPt1_cfi'},step1FastDefaults]) -steps['SinglePiPt10FS']=merge([{'cfg':'SinglePiPt10_cfi'},step1FastDefaults]) -steps['SinglePiPt100FS']=merge([{'cfg':'SinglePiPt100_cfi'},step1FastDefaults]) -steps['ZEEFS']=merge([{'cfg':'ZEE_8TeV_cfi'},Kby(100,2000),step1FastDefaults]) -steps['ZTTFS']=merge([{'cfg':'ZTT_Tauola_OneLepton_OtherHadrons_8TeV_cfi'},Kby(100,2000),step1FastDefaults]) -steps['QCDFlatPt153000FS']=merge([{'cfg':'QCDForPF_8TeV_cfi'},Kby(27,2000),step1FastDefaults]) -steps['QCD_Pt_80_120FS']=merge([{'cfg':'QCD_Pt_80_120_8TeV_cfi'},Kby(100,500),stCond,step1FastDefaults]) -steps['QCD_Pt_3000_3500FS']=merge([{'cfg':'QCD_Pt_3000_3500_8TeV_cfi'},Kby(100,500),stCond,step1FastDefaults]) -steps['H130GGgluonfusionFS']=merge([{'cfg':'H130GGgluonfusion_8TeV_cfi'},step1FastDefaults]) -steps['SingleGammaFlatPt10To10FS']=merge([{'cfg':'SingleGammaFlatPt10To100_cfi'},Kby(100,500),step1FastDefaults]) +steps['TTbarFS']=merge([{'cfg':'TTbar_Tauola_8TeV_TuneCUETP8M1_cfi'},Kby(100,1000),step1FastDefaults]) +steps['SingleMuPt1FS']=merge([{'cfg':'SingleMuPt1_pythia8_cfi'},step1FastDefaults]) +steps['SingleMuPt10FS']=merge([{'cfg':'SingleMuPt10_pythia8_cfi'},step1FastDefaults]) +steps['SingleMuPt100FS']=merge([{'cfg':'SingleMuPt100_pythia8_cfi'},step1FastDefaults]) +steps['SinglePiPt1FS']=merge([{'cfg':'SinglePiPt1_pythia8_cfi'},step1FastDefaults]) +steps['SinglePiPt10FS']=merge([{'cfg':'SinglePiPt10_pythia8_cfi'},step1FastDefaults]) +steps['SinglePiPt100FS']=merge([{'cfg':'SinglePiPt100_pythia8_cfi'},step1FastDefaults]) +steps['ZEEFS']=merge([{'cfg':'ZEE_8TeV_TuneCUETP8M1_cfi'},Kby(100,2000),step1FastDefaults]) +steps['ZTTFS']=merge([{'cfg':'ZTT_Tauola_OneLepton_OtherHadrons_8TeV_TuneCUETP8M1_cfi'},Kby(100,2000),step1FastDefaults]) +steps['QCDFlatPt153000FS']=merge([{'cfg':'QCDForPF_8TeV_TuneCUETP8M1_cfi'},Kby(27,2000),step1FastDefaults]) +steps['QCD_Pt_80_120FS']=merge([{'cfg':'QCD_Pt_80_120_8TeV_TuneCUETP8M1_cfi'},Kby(100,500),stCond,step1FastDefaults]) +steps['QCD_Pt_3000_3500FS']=merge([{'cfg':'QCD_Pt_3000_3500_8TeV_TuneCUETP8M1_cfi'},Kby(100,500),stCond,step1FastDefaults]) +steps['H130GGgluonfusionFS']=merge([{'cfg':'H130GGgluonfusion_8TeV_TuneCUETP8M1_cfi'},step1FastDefaults]) +steps['SingleGammaFlatPt10To10FS']=merge([{'cfg':'SingleGammaFlatPt10To100_pythia8_cfi'},Kby(100,500),step1FastDefaults]) #step1FastUpg2015Defaults -steps['TTbarFS_13']=merge([{'cfg':'TTbar_Tauola_13TeV_cfi'},Kby(100,1000),step1FastUpg2015Defaults]) -steps['ZEEFS_13']=merge([{'cfg':'ZEE_13TeV_cfi'},Kby(100,2000),step1FastUpg2015Defaults]) -steps['ZTTFS_13']=merge([{'cfg':'ZTT_Tauola_OneLepton_OtherHadrons_13TeV_cfi'},Kby(100,2000),step1FastUpg2015Defaults]) -steps['QCDFlatPt153000FS_13']=merge([{'cfg':'QCDForPF_13TeV_cfi'},Kby(27,2000),step1FastUpg2015Defaults]) -steps['QCD_Pt_80_120FS_13']=merge([{'cfg':'QCD_Pt_80_120_13TeV_cfi'},Kby(100,500),step1FastUpg2015Defaults]) -steps['QCD_Pt_3000_3500FS_13']=merge([{'cfg':'QCD_Pt_3000_3500_13TeV_cfi'},Kby(100,500),step1FastUpg2015Defaults]) -steps['H130GGgluonfusionFS_13']=merge([{'cfg':'H130GGgluonfusion_13TeV_cfi'},step1FastUpg2015Defaults]) -steps['SingleMuPt10FS_UP15']=merge([{'cfg':'SingleMuPt10_cfi'},step1FastUpg2015Defaults]) -steps['SingleMuPt100FS_UP15']=merge([{'cfg':'SingleMuPt100_cfi'},step1FastUpg2015Defaults]) +steps['TTbarFS_13']=merge([{'cfg':'TTbar_Tauola_13TeV_TuneCUETP8M1_cfi'},Kby(100,1000),step1FastUpg2015Defaults]) +steps['ZEEFS_13']=merge([{'cfg':'ZEE_13TeV_TuneCUETP8M1_cfi'},Kby(100,2000),step1FastUpg2015Defaults]) +steps['ZTTFS_13']=merge([{'cfg':'ZTT_Tauola_OneLepton_OtherHadrons_13TeV_TuneCUETP8M1_cfi'},Kby(100,2000),step1FastUpg2015Defaults]) +steps['QCDFlatPt153000FS_13']=merge([{'cfg':'QCDForPF_13TeV_TuneCUETP8M1_cfi'},Kby(27,2000),step1FastUpg2015Defaults]) +steps['QCD_Pt_80_120FS_13']=merge([{'cfg':'QCD_Pt_80_120_13TeV_TuneCUETP8M1_cfi'},Kby(100,500),step1FastUpg2015Defaults]) +steps['QCD_Pt_3000_3500FS_13']=merge([{'cfg':'QCD_Pt_3000_3500_13TeV_TuneCUETP8M1_cfi'},Kby(100,500),step1FastUpg2015Defaults]) +steps['H130GGgluonfusionFS_13']=merge([{'cfg':'H130GGgluonfusion_13TeV_TuneCUETP8M1_cfi'},step1FastUpg2015Defaults]) +steps['SingleMuPt10FS_UP15']=merge([{'cfg':'SingleMuPt10_pythia8_cfi'},step1FastUpg2015Defaults]) +steps['SingleMuPt100FS_UP15']=merge([{'cfg':'SingleMuPt100_pythia8_cfi'},step1FastUpg2015Defaults]) #step1FastPU -steps['MinBiasFS_13_ForMixing']=merge([{'cfg':'MinBias_13TeV_cfi'},Kby(100,1000),step1FastPUNewMixing]) +steps['MinBiasFS_13_ForMixing']=merge([{'cfg':'MinBias_13TeV_pythia8_TuneCUETP8M1_cfi'},Kby(100,1000),step1FastPUNewMixing]) -steps['TTbarSFS']=merge([{'cfg':'TTbar_Tauola_8TeV_cfi'}, +steps['TTbarSFS']=merge([{'cfg':'TTbar_Tauola_8TeV_TuneCUETP8M1_cfi'}, {'-s':'GEN,SIM', '--eventcontent':'FEVTDEBUG', '--datatier':'GEN-SIM', '--fast':''}, step1Defaults]) -steps['TTbarSFSA']=merge([{'cfg':'TTbar_Tauola_8TeV_cfi', +steps['TTbarSFSA']=merge([{'cfg':'TTbar_Tauola_8TeV_TuneCUETP8M1_cfi', '-s':'GEN,SIM,RECO,EI,HLT:@fake,VALIDATION', '--fast':''}, step1FastDefaults]) From ea7f17027cea71e40c38859e02a5562884416525 Mon Sep 17 00:00:00 2001 From: inugent Date: Thu, 11 Dec 2014 01:52:02 +0100 Subject: [PATCH 15/28] Adding first stages of fixes for missing particle gun routines and patches for broken RelVal sequences --- .../python/SingleMuPt1000_pythia8_cfi.py | 17 +++++++++++++++++ .../python/SingleMuPt100_pythia8_cfi.py | 17 +++++++++++++++++ .../python/SingleMuPt10_pythia8_cfi.py | 17 +++++++++++++++++ .../ZpEE_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py | 1 + .../ZpMM_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py | 2 ++ .../python/ZpTT_1500_8TeV_Tauola_cfi.py | 1 - .../PyReleaseValidation/python/relval_steps.py | 12 ++++++------ 7 files changed, 60 insertions(+), 7 deletions(-) create mode 100755 Configuration/Generator/python/SingleMuPt1000_pythia8_cfi.py create mode 100755 Configuration/Generator/python/SingleMuPt100_pythia8_cfi.py create mode 100755 Configuration/Generator/python/SingleMuPt10_pythia8_cfi.py diff --git a/Configuration/Generator/python/SingleMuPt1000_pythia8_cfi.py b/Configuration/Generator/python/SingleMuPt1000_pythia8_cfi.py new file mode 100755 index 0000000000000..e2758efa4deac --- /dev/null +++ b/Configuration/Generator/python/SingleMuPt1000_pythia8_cfi.py @@ -0,0 +1,17 @@ +import FWCore.ParameterSet.Config as cms +generator = cms.EDFilter("Pythia8PtGun", + PGunParameters = cms.PSet( + MaxPt = cms.double(1000.01), + MinPt = cms.double(999.99), + ParticleID = cms.vint32(-13), + AddAntiParticle = cms.bool(True), + MaxEta = cms.double(2.5), + MaxPhi = cms.double(3.14159265359), + MinEta = cms.double(-2.5), + MinPhi = cms.double(-3.14159265359) ## in radians + ), + Verbosity = cms.untracked.int32(0), ## set to 1 (or greater) for printouts + psethack = cms.string('single mu pt 1000'), + firstRun = cms.untracked.uint32(1), + PythiaParameters = cms.PSet(parameterSets = cms.vstring()) + ) diff --git a/Configuration/Generator/python/SingleMuPt100_pythia8_cfi.py b/Configuration/Generator/python/SingleMuPt100_pythia8_cfi.py new file mode 100755 index 0000000000000..51402ad8dbde3 --- /dev/null +++ b/Configuration/Generator/python/SingleMuPt100_pythia8_cfi.py @@ -0,0 +1,17 @@ +import FWCore.ParameterSet.Config as cms +generator = cms.EDFilter("Pythia8PtGun", + PGunParameters = cms.PSet( + MaxPt = cms.double(100.01), + MinPt = cms.double(99.99), + ParticleID = cms.vint32(-13), + AddAntiParticle = cms.bool(True), + MaxEta = cms.double(2.5), + MaxPhi = cms.double(3.14159265359), + MinEta = cms.double(-2.5), + MinPhi = cms.double(-3.14159265359) ## in radians + ), + Verbosity = cms.untracked.int32(0), ## set to 1 (or greater) for printouts + psethack = cms.string('single mu pt 100'), + firstRun = cms.untracked.uint32(1), + PythiaParameters = cms.PSet(parameterSets = cms.vstring()) + ) diff --git a/Configuration/Generator/python/SingleMuPt10_pythia8_cfi.py b/Configuration/Generator/python/SingleMuPt10_pythia8_cfi.py new file mode 100755 index 0000000000000..cec667732fe23 --- /dev/null +++ b/Configuration/Generator/python/SingleMuPt10_pythia8_cfi.py @@ -0,0 +1,17 @@ +import FWCore.ParameterSet.Config as cms +generator = cms.EDFilter("Pythia8PtGun", + PGunParameters = cms.PSet( + MaxPt = cms.double(10.01), + MinPt = cms.double(9.99), + ParticleID = cms.vint32(-13), + AddAntiParticle = cms.bool(True), + MaxEta = cms.double(2.5), + MaxPhi = cms.double(3.14159265359), + MinEta = cms.double(-2.5), + MinPhi = cms.double(-3.14159265359) ## in radians + ), + Verbosity = cms.untracked.int32(0), ## set to 1 (or greater) for printouts + psethack = cms.string('single mu pt 10'), + firstRun = cms.untracked.uint32(1), + PythiaParameters = cms.PSet(parameterSets = cms.vstring()) + ) diff --git a/Configuration/Generator/python/ZpEE_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py b/Configuration/Generator/python/ZpEE_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py index 996479028c690..cc344b38d0a42 100644 --- a/Configuration/Generator/python/ZpEE_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py +++ b/Configuration/Generator/python/ZpEE_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py @@ -1,6 +1,7 @@ import FWCore.ParameterSet.Config as cms from Configuration.Generator.Pythia8CommonSettings_cfi import * from Configuration.Generator.Pythia8CUEP8M1Settings_cfi import * +from GeneratorInterface.ExternalDecays.TauolaSettings_cff import * source = cms.Source("EmptySource") generator = cms.EDFilter("Pythia8GeneratorFilter", #pythiaHepMCVerbosity = cms.untracked.bool(False), diff --git a/Configuration/Generator/python/ZpMM_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py b/Configuration/Generator/python/ZpMM_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py index 4c89ab8efc37e..88b03e7e12dd6 100644 --- a/Configuration/Generator/python/ZpMM_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py +++ b/Configuration/Generator/python/ZpMM_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py @@ -1,6 +1,7 @@ import FWCore.ParameterSet.Config as cms from Configuration.Generator.Pythia8CommonSettings_cfi import * from Configuration.Generator.Pythia8CUEP8M1Settings_cfi import * +from GeneratorInterface.ExternalDecays.TauolaSettings_cff import * source = cms.Source("EmptySource") generator = cms.EDFilter("Pythia8GeneratorFilter", #pythiaHepMCVerbosity = cms.untracked.bool(False), @@ -56,3 +57,4 @@ ) ) ) +ProductionFilterSequence = cms.Sequence(generator) diff --git a/Configuration/Generator/python/ZpTT_1500_8TeV_Tauola_cfi.py b/Configuration/Generator/python/ZpTT_1500_8TeV_Tauola_cfi.py index 42625daa3eff2..8a030393358f4 100644 --- a/Configuration/Generator/python/ZpTT_1500_8TeV_Tauola_cfi.py +++ b/Configuration/Generator/python/ZpTT_1500_8TeV_Tauola_cfi.py @@ -1,7 +1,6 @@ import FWCore.ParameterSet.Config as cms from Configuration.Generator.PythiaUEZ2starSettings_cfi import * from GeneratorInterface.ExternalDecays.TauolaSettings_cff import * - generator = cms.EDFilter("Pythia6GeneratorFilter", pythiaHepMCVerbosity = cms.untracked.bool(False), comEnergy = cms.double(8000.0), diff --git a/Configuration/PyReleaseValidation/python/relval_steps.py b/Configuration/PyReleaseValidation/python/relval_steps.py index e7e0b8ca2e0a2..fb50924634067 100644 --- a/Configuration/PyReleaseValidation/python/relval_steps.py +++ b/Configuration/PyReleaseValidation/python/relval_steps.py @@ -302,11 +302,11 @@ def gen2015(fragment,howMuch): steps['QCD_FlatPt_15_3000_13']=gen2015('QCDForPF_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['QCD_FlatPt_15_3000HS_13']=gen2015('QCDForPF_13TeV_TuneCUETP8M1_cfi',Kby(50,100)) -steps['ZpMM_2250_8TeV_Tauola']=gen('ZpMM_2250_8TeV_Tauola_TuneCUETP8M1_cfi',Kby(9,100)) -steps['ZpEE_2250_8TeV_Tauola']=gen('ZpEE_2250_8TeV_Tauola_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ZpMM_2250_8TeV_Tauola']=gen('ZpMM_2250_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ZpEE_2250_8TeV_Tauola']=gen('ZpEE_2250_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['ZpTT_1500_8TeV_Tauola']=gen('ZpTT_1500_8TeV_Tauola_TuneCUETP8M1_cfi',Kby(9,100)) -steps['ZpMM_2250_13TeV_Tauola']=gen2015('ZpMM_2250_13TeV_Tauola_TuneCUETP8M1_cfi',Kby(9,100)) -steps['ZpEE_2250_13TeV_Tauola']=gen2015('ZpEE_2250_13TeV_Tauola_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ZpMM_2250_13TeV_Tauola']=gen2015('ZpMM_2250_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ZpEE_2250_13TeV_Tauola']=gen2015('ZpEE_2250_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['ZpTT_1500_13TeV_Tauola']=gen2015('ZpTT_1500_13TeV_Tauola_TuneCUETP8M1_cfi',Kby(9,100)) def identitySim(wf): @@ -464,11 +464,11 @@ def genS(fragment,howMuch): steps['ZTT']=genS('ZTT_Tauola_All_hadronic_8TeV_TuneCUETP8M1_cfi',Kby(9,150)) steps['H130GGgluonfusion']=genS('H130GGgluonfusion_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['PhotonJets_Pt_10']=genS('PhotonJet_Pt_10_8TeV_TuneCUETP8M1_cfi',Kby(9,150)) -steps['QQH1352T_Tauola']=genS('QQH1352T_Tauola_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['QQH1352T_Tauola']=genS('QQH1352T_Tauola_8TeV_cfi',Kby(9,100)) steps['ZTT_13']=gen2015('ZTT_Tauola_All_hadronic_13TeV_TuneCUETP8M1_cfi',Kby(9,150)) steps['H130GGgluonfusion_13']=gen2015('H130GGgluonfusion_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['PhotonJets_Pt_10_13']=gen2015('PhotonJet_Pt_10_13TeV_TuneCUETP8M1_cfi',Kby(9,150)) -steps['QQH1352T_Tauola_13']=gen2015('QQH1352T_Tauola_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['QQH1352T_Tauola_13']=gen2015('QQH1352T_Tauola_13TeV_cfi',Kby(9,100)) #steps['ZmumuJets_Pt_20_300']=gen('ZmumuJets_Pt_20_300_GEN_8TeV_TuneCUETP8M1_cfg',Kby(25,100)) steps['ADDMonoJet_d3MD3']=genS('ADDMonoJet_8TeV_d3MD3_TuneCUETP8M1_cfi',Kby(9,100)) steps['ADDMonoJet_d3MD3_13']=gen2015('ADDMonoJet_13TeV_d3MD3_TuneCUETP8M1_cfi',Kby(9,100)) From c125618d0f9ba2791454463883d4f176a744424d Mon Sep 17 00:00:00 2001 From: aelwood Date: Thu, 11 Dec 2014 11:42:23 +0100 Subject: [PATCH 16/28] Changed the alphaT filter to allow the alphaT calculation to be carried out with the delta HT kept as zero. Added a new option setDPhiZero, that is defaulted to reproduce old behaviour --- HLTrigger/JetMET/interface/AlphaT.h | 11 ++++--- HLTrigger/JetMET/interface/HLTAlphaTFilter.h | 1 + HLTrigger/JetMET/src/AlphaT.cc | 33 +++++++++++--------- HLTrigger/JetMET/src/HLTAlphaTFilter.cc | 6 ++-- 4 files changed, 30 insertions(+), 21 deletions(-) diff --git a/HLTrigger/JetMET/interface/AlphaT.h b/HLTrigger/JetMET/interface/AlphaT.h index a3474c966d396..f8d0b0a1669aa 100644 --- a/HLTrigger/JetMET/interface/AlphaT.h +++ b/HLTrigger/JetMET/interface/AlphaT.h @@ -9,10 +9,10 @@ class AlphaT { public: template - AlphaT(std::vector const & p4, bool use_et = true); + AlphaT(std::vector const & p4, bool setDHtZero = false , bool use_et = true); template - AlphaT(std::vector const & p4, bool use_et = true); + AlphaT(std::vector const & p4, bool setDHtZero = false, bool use_et = true); private: std::vector et_; @@ -25,23 +25,26 @@ class AlphaT { private: double value_(std::vector * jet_sign) const; + bool setDHtZero_; }; // ----------------------------------------------------------------------------- template -AlphaT::AlphaT(std::vector const & p4, bool use_et /* = true */) { +AlphaT::AlphaT(std::vector const & p4, bool setDHtZero, bool use_et /* = true */) { std::transform( p4.begin(), p4.end(), back_inserter(et_), ( use_et ? std::mem_fun(&T::Et) : std::mem_fun(&T::Pt) ) ); std::transform( p4.begin(), p4.end(), back_inserter(px_), std::mem_fun(&T::Px) ); std::transform( p4.begin(), p4.end(), back_inserter(py_), std::mem_fun(&T::Py) ); + setDHtZero_ = setDHtZero; } // ----------------------------------------------------------------------------- template -AlphaT::AlphaT(std::vector const & p4, bool use_et /* = true */) { +AlphaT::AlphaT(std::vector const & p4, bool setDHtZero, bool use_et /* = true */) { std::transform( p4.begin(), p4.end(), back_inserter(et_), std::mem_fun_ref( use_et ? &T::Et : &T::Pt ) ); std::transform( p4.begin(), p4.end(), back_inserter(px_), std::mem_fun_ref(&T::Px) ); std::transform( p4.begin(), p4.end(), back_inserter(py_), std::mem_fun_ref(&T::Py) ); + setDHtZero_ = setDHtZero; } diff --git a/HLTrigger/JetMET/interface/HLTAlphaTFilter.h b/HLTrigger/JetMET/interface/HLTAlphaTFilter.h index 68e25fcd753ab..e369fbbc04581 100644 --- a/HLTrigger/JetMET/interface/HLTAlphaTFilter.h +++ b/HLTrigger/JetMET/interface/HLTAlphaTFilter.h @@ -46,6 +46,7 @@ class HLTAlphaTFilter : public HLTFilter { double minAlphaT_; int triggerType_; bool dynamicAlphaT_; + bool setDHtZero_; }; #endif // HLTrigger_JetMET_HLTAlphaTFilter_h diff --git a/HLTrigger/JetMET/src/AlphaT.cc b/HLTrigger/JetMET/src/AlphaT.cc index 98964b9dd9703..67db0161e7074 100644 --- a/HLTrigger/JetMET/src/AlphaT.cc +++ b/HLTrigger/JetMET/src/AlphaT.cc @@ -25,24 +25,27 @@ double AlphaT::value_(std::vector * jet_sign) const { // Minimum Delta Et for two pseudo-jets double min_delta_sum_et = sum_et; - for (unsigned int i = 0; i < (1U << (et_.size() - 1)); i++) { //@@ iterate through different combinations - double delta_sum_et = 0.; - for (unsigned int j = 0; j < et_.size(); ++j) { //@@ iterate through jets - if (i & (1U << j)) - delta_sum_et -= et_[j]; - else - delta_sum_et += et_[j]; - } - delta_sum_et = std::abs(delta_sum_et); - if (delta_sum_et < min_delta_sum_et) { - min_delta_sum_et = delta_sum_et; - if (jet_sign) { - for (unsigned int j = 0; j < et_.size(); ++j) - (*jet_sign)[j] = ((i & (1U << j)) == 0); + if(setDHtZero_){ + min_delta_sum_et = 0.; + }else{ + for (unsigned int i = 0; i < (1U << (et_.size() - 1)); i++) { //@@ iterate through different combinations + double delta_sum_et = 0.; + for (unsigned int j = 0; j < et_.size(); ++j) { //@@ iterate through jets + if (i & (1U << j)) + delta_sum_et -= et_[j]; + else + delta_sum_et += et_[j]; + } + delta_sum_et = std::abs(delta_sum_et); + if (delta_sum_et < min_delta_sum_et) { + min_delta_sum_et = delta_sum_et; + if (jet_sign) { + for (unsigned int j = 0; j < et_.size(); ++j) + (*jet_sign)[j] = ((i & (1U << j)) == 0); + } } } } - // Alpha_T return (0.5 * (sum_et - min_delta_sum_et) / sqrt( sum_et*sum_et - (sum_px*sum_px+sum_py*sum_py) )); } diff --git a/HLTrigger/JetMET/src/HLTAlphaTFilter.cc b/HLTrigger/JetMET/src/HLTAlphaTFilter.cc index 791e2ece7b9a6..fc3efe76b6d9f 100644 --- a/HLTrigger/JetMET/src/HLTAlphaTFilter.cc +++ b/HLTrigger/JetMET/src/HLTAlphaTFilter.cc @@ -42,6 +42,7 @@ HLTAlphaTFilter::HLTAlphaTFilter(const edm::ParameterSet& iConfig) : HLTFilte minAlphaT_ = iConfig.getParameter ("minAlphaT"); triggerType_ = iConfig.getParameter("triggerType"); dynamicAlphaT_ = iConfig.getParameter("dynamicAlphaT"); + setDHtZero_ = iConfig.getParameter("setDHtZero"); // sanity checks if ( (minPtJet_.size() != etaJet_.size()) @@ -86,6 +87,7 @@ void HLTAlphaTFilter::fillDescriptions(edm::ConfigurationDescriptions& descri desc.add("minAlphaT",0.0); desc.add("triggerType",trigger::TriggerJet); desc.add("dynamicAlphaT",true); //Set to reproduce old behaviour + desc.add("setDHtZero",false); //Set to reproduce old behaviour descriptions.add(std::string("hlt")+std::string(typeid(HLTAlphaTFilter).name()),desc); } @@ -164,7 +166,7 @@ bool HLTAlphaTFilter::hltFilter(edm::Event& iEvent, const edm::EventSetup& iS // Add to JetVector LorentzV JetLVec(ijet->pt(),ijet->eta(),ijet->phi(),ijet->mass()); jets.push_back( JetLVec ); - aT = AlphaT(jets).value(); + aT = AlphaT(jets,setDHtZero_).value(); if(htFast > minHt_ && aT > minAlphaT_){ // set flat to one so that we don't carry on looping though the jets flag = 1; @@ -237,7 +239,7 @@ bool HLTAlphaTFilter::hltFilter(edm::Event& iEvent, const edm::EventSetup& iS if(flag!=1){ //Added for efficiency //Calculate the value for alphaT - float aT = AlphaT(jets).value(); + float aT = AlphaT(jets,setDHtZero_).value(); // Trigger decision! if(aT > minAlphaT_){ From 406e4c083a541b589002c696781de424860e2d40 Mon Sep 17 00:00:00 2001 From: Martin Grunewald Date: Thu, 11 Dec 2014 13:41:42 +0100 Subject: [PATCH 17/28] 74X: Moving HLT config to use 730 template --- .../python/HLT_FULL_Famos_cff.py | 65 +++++- .../Configuration/python/HLT_FULL_cff.py | 212 +++++++++++++++--- .../python/HLT_Fake_Famos_cff.py | 32 ++- .../Configuration/python/HLT_Fake_cff.py | 183 ++++++++++++--- .../python/HLT_GRun_Famos_cff.py | 56 ++++- .../Configuration/python/HLT_GRun_cff.py | 203 ++++++++++++++--- .../Configuration/python/HLT_HIon_cff.py | 143 +++++++++--- .../Configuration/python/HLT_PIon_cff.py | 143 +++++++++--- .../Configuration/test/OnData_HLT_FULL.py | 212 +++++++++++++++--- .../Configuration/test/OnData_HLT_Fake.py | 183 ++++++++++++--- .../Configuration/test/OnData_HLT_GRun.py | 203 ++++++++++++++--- .../Configuration/test/OnData_HLT_HIon.py | 143 +++++++++--- .../Configuration/test/OnData_HLT_PIon.py | 143 +++++++++--- HLTrigger/Configuration/test/OnMc_HLT_FULL.py | 212 +++++++++++++++--- HLTrigger/Configuration/test/OnMc_HLT_Fake.py | 183 ++++++++++++--- HLTrigger/Configuration/test/OnMc_HLT_GRun.py | 203 ++++++++++++++--- HLTrigger/Configuration/test/OnMc_HLT_HIon.py | 143 +++++++++--- HLTrigger/Configuration/test/OnMc_HLT_PIon.py | 143 +++++++++--- 18 files changed, 2366 insertions(+), 439 deletions(-) diff --git a/HLTrigger/Configuration/python/HLT_FULL_Famos_cff.py b/HLTrigger/Configuration/python/HLT_FULL_Famos_cff.py index 147b7aaed304d..7bf3f6d37c587 100644 --- a/HLTrigger/Configuration/python/HLT_FULL_Famos_cff.py +++ b/HLTrigger/Configuration/python/HLT_FULL_Famos_cff.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_3_0/HLT/V17 (CMSSW_7_2_3_HLT4) +# /dev/CMSSW_7_3_0/HLT/V19 (CMSSW_7_3_0) import FWCore.ParameterSet.Config as cms from FastSimulation.HighLevelTrigger.HLTSetup_cff import * HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_3_0/HLT/V17') + tableName = cms.string('/dev/CMSSW_7_3_0/HLT/V19') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1322,16 +1322,16 @@ hltEcalDigis = cms.EDProducer( "EcalRawToDigi", tccUnpacking = cms.bool( True ), FedLabel = cms.InputTag( "listfeds" ), - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), srpUnpacking = cms.bool( True ), syncCheck = cms.bool( True ), + feIdCheck = cms.bool( True ), silentMode = cms.untracked.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), + InputLabel = cms.InputTag( "rawDataCollector" ), orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), eventPut = cms.bool( True ), - InputLabel = cms.InputTag( "rawDataCollector" ), + numbTriggerTSamples = cms.int32( 1 ), numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), + orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), DoRegional = cms.bool( False ), feUnpacking = cms.bool( True ), @@ -3924,7 +3924,7 @@ L1GtObjectMapTag = cms.InputTag( "gtDigis" ), L1TechTriggerSeeding = cms.bool( False ) ) -hltPreAK8PFHT850TrimR0p1PT0p03Mass50 = cms.EDFilter( "HLTPrescaler", +hltPreAK8PFHT700TrimR0p1PT0p03Mass50 = cms.EDFilter( "HLTPrescaler", L1GtReadoutRecordTag = cms.InputTag( "gtDigis" ), offset = cms.uint32( 0 ) ) @@ -5325,6 +5325,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -5350,6 +5351,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -5688,6 +5690,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -5749,6 +5752,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -5949,6 +5953,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -6023,6 +6028,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9218,6 +9224,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9243,6 +9250,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9268,6 +9276,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9650,6 +9659,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9675,6 +9685,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9921,6 +9932,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -10028,6 +10040,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -10180,6 +10193,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -10408,6 +10422,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -10963,6 +10978,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -10988,6 +11004,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -11243,6 +11260,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -11477,6 +11495,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -11783,6 +11802,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -11984,6 +12004,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -12212,6 +12233,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -12719,6 +12741,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -13101,6 +13124,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -13252,6 +13276,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -16996,6 +17021,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17629,6 +17655,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -22590,6 +22617,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -22803,6 +22831,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -23001,6 +23030,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -23199,6 +23229,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -23912,6 +23943,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -23937,6 +23969,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -24289,6 +24322,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -24314,6 +24348,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -24339,6 +24374,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -24699,6 +24735,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -24957,6 +24994,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -25125,6 +25163,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -25315,6 +25354,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -25973,6 +26013,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -26526,6 +26567,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -26724,6 +26766,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -29027,6 +29070,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -29422,6 +29466,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -29623,6 +29668,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -30009,6 +30055,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -30355,6 +30402,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -30496,6 +30544,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -31084,7 +31133,7 @@ HLTriggerFirstPath = cms.Path( hltGetConditions + hltGetRaw + hltBoolFalse ) HLT_AK8PFJet360TrimMod_Mass30_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleJet176ORSingleJet200 + hltPreAK8PFJet360TrimModMass30 + HLTAK8CaloJetsSequence + hltAK8SingleCaloJet260 + HLTAK8PFJetsSequence + hltAK8PFJetsCorrectedMatchedToCaloJets260 + hltAK8TrimModJets + hltAK8SinglePFJet360TrimModMass30 + cms.SequencePlaceholder( "HLTEndSequence" ) ) -HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v1 = cms.Path( HLTBeginSequence + hltL1sL1HTT150ORHTT175 + hltPreAK8PFHT850TrimR0p1PT0p03Mass50 + HLTAK8CaloJetsSequence + hltAK8HtMht + hltAK8Ht600 + HLTAK8PFJetsSequence + hltAK8PFHT + hltAK8PFJetsTrimR0p1PT0p03 + hlt1AK8PFJetsTrimR0p1PT0p03Mass50 + hltAK8PFHT700 + cms.SequencePlaceholder( "HLTEndSequence" ) ) +HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v1 = cms.Path( HLTBeginSequence + hltL1sL1HTT150ORHTT175 + hltPreAK8PFHT700TrimR0p1PT0p03Mass50 + HLTAK8CaloJetsSequence + hltAK8HtMht + hltAK8Ht600 + HLTAK8PFJetsSequence + hltAK8PFHT + hltAK8PFJetsTrimR0p1PT0p03 + hlt1AK8PFJetsTrimR0p1PT0p03Mass50 + hltAK8PFHT700 + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_BTagCSV07_v1 = cms.Path( HLTBeginSequence + hltPreBTagCSV07 + HLTAK4CaloJetsSequence + HLTFastPrimaryVertexSequence + hltFastPVPixelVertexSelector + HLTBtagCSVSequenceL3 + hltBLifetimeL3FilterCSV + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_CaloJet260_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleJet200 + hltPreCaloJet260 + HLTAK4CaloJetsSequence + hltSingleCaloJet260 + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_CaloJet500_NoJetID_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleJet200 + hltPreCaloJet500NoJetID + HLTAK4CaloJetsReconstructionNoIDSequence + HLTAK4CaloJetsCorrectionNoIDSequence + hltSingleCaloJet500 + cms.SequencePlaceholder( "HLTEndSequence" ) ) diff --git a/HLTrigger/Configuration/python/HLT_FULL_cff.py b/HLTrigger/Configuration/python/HLT_FULL_cff.py index 7548ed7b9cfd1..b92a3b4174dcc 100644 --- a/HLTrigger/Configuration/python/HLT_FULL_cff.py +++ b/HLTrigger/Configuration/python/HLT_FULL_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_3_0/HLT/V17 (CMSSW_7_2_3_HLT4) +# /dev/CMSSW_7_3_0/HLT/V19 (CMSSW_7_3_0) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_3_0/HLT/V17') + tableName = cms.string('/dev/CMSSW_7_3_0/HLT/V19') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1725,16 +1725,16 @@ hltEcalDigis = cms.EDProducer( "EcalRawToDigi", tccUnpacking = cms.bool( True ), FedLabel = cms.InputTag( "listfeds" ), - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), srpUnpacking = cms.bool( True ), syncCheck = cms.bool( True ), + feIdCheck = cms.bool( True ), silentMode = cms.untracked.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), + InputLabel = cms.InputTag( "rawDataCollector" ), orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), eventPut = cms.bool( True ), - InputLabel = cms.InputTag( "rawDataCollector" ), + numbTriggerTSamples = cms.int32( 1 ), numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), + orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), DoRegional = cms.bool( False ), feUnpacking = cms.bool( True ), @@ -1855,15 +1855,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -1871,13 +1873,29 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HBHE" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ignorelowest = cms.bool( True ), win_offset = cms.double( 0.0 ), @@ -1885,7 +1903,14 @@ win_gain = cms.double( 1.0 ), tfilterEnvelope = cms.vdouble( 4.0, 12.04, 13.0, 10.56, 23.5, 8.82, 37.0, 7.38, 56.0, 6.3, 81.0, 5.64, 114.5, 5.44, 175.5, 5.38, 350.5, 5.14 ) ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( nominalPedestal = cms.double( 3.0 ), hitMultiplicityThreshold = cms.int32( 17 ), @@ -1897,6 +1922,11 @@ cms.PSet( pulseShapeParameters = cms.vdouble( -1000000.0, 1000000.0, 45.0, 0.1, 1000000.0, 0.0 ) ) ) ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( slopeMax = cms.double( -0.6 ), r1Max = cms.double( 1.0 ), @@ -1930,6 +1960,7 @@ samplesToAdd = cms.int32( 2 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( hflongEthresh = cms.double( 40.0 ), @@ -1942,7 +1973,13 @@ digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 1 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( + HFdigiflagFirstSample = cms.int32( 1 ), + HFdigiflagMinEthreshold = cms.double( 40.0 ), + HFdigiflagSamplesToAdd = cms.int32( 3 ), + HFdigiflagExpectedPeak = cms.int32( 2 ), + HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) + ), hfTimingTrustParameters = cms.PSet( hfTimingTrustLevel2 = cms.int32( 4 ), hfTimingTrustLevel1 = cms.int32( 1 ) @@ -1959,13 +1996,8 @@ long_R = cms.vdouble( 0.98 ), HcalAcceptSeverityLevel = cms.int32( 9 ) ), - digistat = cms.PSet( - HFdigiflagFirstSample = cms.int32( 1 ), - HFdigiflagMinEthreshold = cms.double( 40.0 ), - HFdigiflagSamplesToAdd = cms.int32( 3 ), - HFdigiflagExpectedPeak = cms.int32( 2 ), - HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) - ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( @@ -1983,16 +2015,44 @@ correctForTimeslew = cms.bool( False ), setNoiseFlags = cms.bool( True ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HF" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 2 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) hltHoreco = cms.EDProducer( "HcalHitReconstructor", @@ -2004,15 +2064,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -2020,16 +2082,44 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HO" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) hltTowerMakerForAll = cms.EDProducer( "CaloTowersCreator", @@ -2883,9 +2973,11 @@ ) hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( ), Timing = cms.untracked.bool( False ), @@ -5776,7 +5868,7 @@ L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), L1TechTriggerSeeding = cms.bool( False ) ) -hltPreAK8PFHT850TrimR0p1PT0p03Mass50 = cms.EDFilter( "HLTPrescaler", +hltPreAK8PFHT700TrimR0p1PT0p03Mass50 = cms.EDFilter( "HLTPrescaler", L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) @@ -5996,9 +6088,11 @@ ) hltSiPixelDigisRegForBTag = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltSelectorCentralJets20L1FastJeta' ), @@ -7981,6 +8075,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -8006,6 +8101,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -8968,6 +9064,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9029,6 +9126,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9229,6 +9327,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9338,6 +9437,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9684,9 +9784,11 @@ ) hltSiPixelDigisReg = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltL2TausForPixelIsolation' ), @@ -16821,6 +16923,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -16846,6 +16949,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -16871,6 +16975,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17253,6 +17358,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17278,6 +17384,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17524,6 +17631,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17631,6 +17739,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17783,6 +17892,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18011,6 +18121,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18566,6 +18677,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18591,6 +18703,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18846,6 +18959,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -19080,6 +19194,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -19386,6 +19501,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -19587,6 +19703,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -19815,6 +19932,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -20322,6 +20440,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -20704,6 +20823,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -20855,6 +20975,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -21049,6 +21170,7 @@ pMaxHPDEMF = cms.double( 0.02 ), minRecHitE = cms.double( 1.5 ), hlMaxHPDEMF = cms.double( -9999.0 ), + lRBXRecHitR45Cuts = cms.vdouble( 0.0, 1.0, 0.0, -0.5, 0.0, 0.0, 1.0, -0.5 ), maxCaloTowerIEta = cms.int32( 20 ), pMinEEMF = cms.double( 10.0 ), pMaxRatio = cms.double( 0.85 ), @@ -21057,9 +21179,13 @@ pMaxHighEHitTime = cms.double( 5.0 ), pMaxLowEHitTime = cms.double( 6.0 ), minHighHitE = cms.double( 25.0 ), + minR45HitE = cms.double( 5.0 ), + tRBXRecHitR45Cuts = cms.vdouble( 0.0, 1.0, 0.0, -0.2, 0.0, 0.0, 1.0, -0.2 ), + fillRecHits = cms.bool( True ), lMinZeros = cms.int32( 10 ), lMinRBXHits = cms.int32( 999 ), - fillRecHits = cms.bool( True ), + pMinRBXRechitR45Fraction = cms.double( 0.1 ), + pMinRBXRechitR45EnergyFraction = cms.double( 0.1 ), HcalRecHitFlagsToBeExcluded = cms.vint32( 11, 12, 13, 14, 15 ), calibdigiHFthreshold = cms.double( -999.0 ), minLowHitE = cms.double( 10.0 ), @@ -21086,6 +21212,7 @@ tMinRatio = cms.double( 0.73 ), TS4TS5UpperCut = cms.vdouble( 999.0, 999.0, 999.0, 999.0, 999.0 ), pMinLowEHitTime = cms.double( -6.0 ), + pMinRBXRechitR45Count = cms.int32( 1 ), pMinHPDHits = cms.int32( 10 ), lMinLowEHitTime = cms.double( -9999.0 ), recHitCollName = cms.string( "hltHbhereco" ), @@ -21112,6 +21239,7 @@ minRecHitE = cms.double( 1.5 ), severity = cms.int32( 1 ), minHighHitE = cms.double( 25.0 ), + minR45HitE = cms.double( 5.0 ), numRBXsToConsider = cms.int32( 2 ), minRatio = cms.double( -999.0 ), maxHighEHitTime = cms.double( 9999.0 ), @@ -27555,6 +27683,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -28530,6 +28659,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -34081,6 +34211,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -34294,6 +34425,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -34492,6 +34624,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -34690,6 +34823,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -35403,6 +35537,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -35428,6 +35563,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -35780,6 +35916,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -35805,6 +35942,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -35830,6 +35968,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -36178,6 +36317,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -36436,6 +36576,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -36604,6 +36745,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -36794,6 +36936,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -37452,6 +37595,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -38005,6 +38149,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -38203,6 +38348,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -40819,6 +40965,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -41214,6 +41361,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -41415,6 +41563,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -41801,6 +41950,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -42147,6 +42297,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -42288,6 +42439,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -43003,7 +43155,7 @@ HLTriggerFirstPath = cms.Path( hltGetConditions + hltGetRaw + hltBoolFalse ) HLT_AK8PFJet360TrimMod_Mass30_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleJet176ORSingleJet200 + hltPreAK8PFJet360TrimModMass30 + HLTAK8CaloJetsSequence + hltAK8SingleCaloJet260 + HLTAK8PFJetsSequence + hltAK8PFJetsCorrectedMatchedToCaloJets260 + hltAK8TrimModJets + hltAK8SinglePFJet360TrimModMass30 + HLTEndSequence ) -HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v1 = cms.Path( HLTBeginSequence + hltL1sL1HTT150ORHTT175 + hltPreAK8PFHT850TrimR0p1PT0p03Mass50 + HLTAK8CaloJetsSequence + hltAK8HtMht + hltAK8Ht600 + HLTAK8PFJetsSequence + hltAK8PFHT + hltAK8PFJetsTrimR0p1PT0p03 + hlt1AK8PFJetsTrimR0p1PT0p03Mass50 + hltAK8PFHT700 + HLTEndSequence ) +HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v1 = cms.Path( HLTBeginSequence + hltL1sL1HTT150ORHTT175 + hltPreAK8PFHT700TrimR0p1PT0p03Mass50 + HLTAK8CaloJetsSequence + hltAK8HtMht + hltAK8Ht600 + HLTAK8PFJetsSequence + hltAK8PFHT + hltAK8PFJetsTrimR0p1PT0p03 + hlt1AK8PFJetsTrimR0p1PT0p03Mass50 + hltAK8PFHT700 + HLTEndSequence ) HLT_BTagCSV07_v1 = cms.Path( HLTBeginSequence + hltPreBTagCSV07 + HLTAK4CaloJetsSequence + HLTFastPrimaryVertexSequence + hltFastPVPixelVertexSelector + HLTBtagCSVSequenceL3 + hltBLifetimeL3FilterCSV + HLTEndSequence ) HLT_CaloJet260_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleJet200 + hltPreCaloJet260 + HLTAK4CaloJetsSequence + hltSingleCaloJet260 + HLTEndSequence ) HLT_CaloJet500_NoJetID_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleJet200 + hltPreCaloJet500NoJetID + HLTAK4CaloJetsReconstructionNoIDSequence + HLTAK4CaloJetsCorrectionNoIDSequence + hltSingleCaloJet500 + HLTEndSequence ) diff --git a/HLTrigger/Configuration/python/HLT_Fake_Famos_cff.py b/HLTrigger/Configuration/python/HLT_Fake_Famos_cff.py index 40ba517487b8b..4659c5f5aad25 100644 --- a/HLTrigger/Configuration/python/HLT_Fake_Famos_cff.py +++ b/HLTrigger/Configuration/python/HLT_Fake_Famos_cff.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_3_0/Fake/V3 (CMSSW_7_2_3_HLT4) +# /dev/CMSSW_7_3_0/Fake/V4 (CMSSW_7_3_0) import FWCore.ParameterSet.Config as cms from FastSimulation.HighLevelTrigger.HLTSetup_cff import * HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_3_0/Fake/V3') + tableName = cms.string('/dev/CMSSW_7_3_0/Fake/V4') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -3184,16 +3184,16 @@ hltEcalDigis = cms.EDProducer( "EcalRawToDigi", tccUnpacking = cms.bool( True ), FedLabel = cms.InputTag( "listfeds" ), - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), srpUnpacking = cms.bool( True ), syncCheck = cms.bool( True ), + feIdCheck = cms.bool( True ), silentMode = cms.untracked.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), + InputLabel = cms.InputTag( "rawDataCollector" ), orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), eventPut = cms.bool( True ), - InputLabel = cms.InputTag( "rawDataCollector" ), + numbTriggerTSamples = cms.int32( 1 ), numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), + orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), DoRegional = cms.bool( False ), feUnpacking = cms.bool( True ), @@ -6007,6 +6007,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -6373,6 +6374,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -6398,6 +6400,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -6608,6 +6611,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -7033,6 +7037,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -10568,6 +10573,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -13582,6 +13588,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -13844,6 +13851,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -13869,6 +13877,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -14207,6 +14216,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -14232,6 +14242,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -14257,6 +14268,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -14617,6 +14629,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -14869,6 +14882,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -16013,6 +16027,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -16038,6 +16053,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -16113,6 +16129,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -16433,6 +16450,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -16540,6 +16558,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -16665,6 +16684,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), diff --git a/HLTrigger/Configuration/python/HLT_Fake_cff.py b/HLTrigger/Configuration/python/HLT_Fake_cff.py index 2da25d3ab793c..3be92a53bee52 100644 --- a/HLTrigger/Configuration/python/HLT_Fake_cff.py +++ b/HLTrigger/Configuration/python/HLT_Fake_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_3_0/Fake/V3 (CMSSW_7_2_3_HLT4) +# /dev/CMSSW_7_3_0/Fake/V4 (CMSSW_7_3_0) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_3_0/Fake/V3') + tableName = cms.string('/dev/CMSSW_7_3_0/Fake/V4') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2277,9 +2277,11 @@ ) hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( ), Timing = cms.untracked.bool( False ), @@ -4095,16 +4097,16 @@ hltEcalDigis = cms.EDProducer( "EcalRawToDigi", tccUnpacking = cms.bool( True ), FedLabel = cms.InputTag( "listfeds" ), - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), srpUnpacking = cms.bool( True ), syncCheck = cms.bool( True ), + feIdCheck = cms.bool( True ), silentMode = cms.untracked.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), + InputLabel = cms.InputTag( "rawDataCollector" ), orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), eventPut = cms.bool( True ), - InputLabel = cms.InputTag( "rawDataCollector" ), + numbTriggerTSamples = cms.int32( 1 ), numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), + orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), DoRegional = cms.bool( False ), feUnpacking = cms.bool( True ), @@ -4238,15 +4240,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -4254,13 +4258,29 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HBHE" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ignorelowest = cms.bool( True ), win_offset = cms.double( 0.0 ), @@ -4268,7 +4288,14 @@ win_gain = cms.double( 1.0 ), tfilterEnvelope = cms.vdouble( 4.0, 12.04, 13.0, 10.56, 23.5, 8.82, 37.0, 7.38, 56.0, 6.3, 81.0, 5.64, 114.5, 5.44, 175.5, 5.38, 350.5, 5.14 ) ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( nominalPedestal = cms.double( 3.0 ), hitMultiplicityThreshold = cms.int32( 17 ), @@ -4280,6 +4307,11 @@ cms.PSet( pulseShapeParameters = cms.vdouble( -1000000.0, 1000000.0, 45.0, 0.1, 1000000.0, 0.0 ) ) ) ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( slopeMax = cms.double( -0.6 ), r1Max = cms.double( 1.0 ), @@ -4313,6 +4345,7 @@ samplesToAdd = cms.int32( 2 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( hflongEthresh = cms.double( 40.0 ), @@ -4325,7 +4358,13 @@ digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 1 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( + HFdigiflagFirstSample = cms.int32( 1 ), + HFdigiflagMinEthreshold = cms.double( 40.0 ), + HFdigiflagSamplesToAdd = cms.int32( 3 ), + HFdigiflagExpectedPeak = cms.int32( 2 ), + HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) + ), hfTimingTrustParameters = cms.PSet( hfTimingTrustLevel2 = cms.int32( 4 ), hfTimingTrustLevel1 = cms.int32( 1 ) @@ -4342,13 +4381,8 @@ long_R = cms.vdouble( 0.98 ), HcalAcceptSeverityLevel = cms.int32( 9 ) ), - digistat = cms.PSet( - HFdigiflagFirstSample = cms.int32( 1 ), - HFdigiflagMinEthreshold = cms.double( 40.0 ), - HFdigiflagSamplesToAdd = cms.int32( 3 ), - HFdigiflagExpectedPeak = cms.int32( 2 ), - HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) - ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( @@ -4366,16 +4400,44 @@ correctForTimeslew = cms.bool( False ), setNoiseFlags = cms.bool( True ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HF" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 2 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) hltHoreco = cms.EDProducer( "HcalHitReconstructor", @@ -4387,15 +4449,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -4403,16 +4467,44 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HO" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) hltTowerMakerForAll = cms.EDProducer( "CaloTowersCreator", @@ -12593,6 +12685,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -13583,6 +13676,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -13608,6 +13702,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -13818,6 +13913,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -14243,6 +14339,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -19390,6 +19487,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -20138,9 +20236,11 @@ ) hltSiPixelDigisReg = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltL2TausForPixelIsolation' ), @@ -22300,6 +22400,7 @@ pMaxHPDEMF = cms.double( 0.02 ), minRecHitE = cms.double( 1.5 ), hlMaxHPDEMF = cms.double( -9999.0 ), + lRBXRecHitR45Cuts = cms.vdouble( 0.0, 1.0, 0.0, -0.5, 0.0, 0.0, 1.0, -0.5 ), maxCaloTowerIEta = cms.int32( 20 ), pMinEEMF = cms.double( 10.0 ), pMaxRatio = cms.double( 0.85 ), @@ -22308,9 +22409,13 @@ pMaxHighEHitTime = cms.double( 5.0 ), pMaxLowEHitTime = cms.double( 6.0 ), minHighHitE = cms.double( 25.0 ), + minR45HitE = cms.double( 5.0 ), + tRBXRecHitR45Cuts = cms.vdouble( 0.0, 1.0, 0.0, -0.2, 0.0, 0.0, 1.0, -0.2 ), + fillRecHits = cms.bool( True ), lMinZeros = cms.int32( 10 ), lMinRBXHits = cms.int32( 999 ), - fillRecHits = cms.bool( True ), + pMinRBXRechitR45Fraction = cms.double( 0.1 ), + pMinRBXRechitR45EnergyFraction = cms.double( 0.1 ), HcalRecHitFlagsToBeExcluded = cms.vint32( 11, 12, 13, 14, 15 ), calibdigiHFthreshold = cms.double( -999.0 ), minLowHitE = cms.double( 10.0 ), @@ -22337,6 +22442,7 @@ tMinRatio = cms.double( 0.73 ), TS4TS5UpperCut = cms.vdouble( 999.0, 999.0, 999.0, 999.0, 999.0 ), pMinLowEHitTime = cms.double( -6.0 ), + pMinRBXRechitR45Count = cms.int32( 1 ), pMinHPDHits = cms.int32( 10 ), lMinLowEHitTime = cms.double( -9999.0 ), recHitCollName = cms.string( "hltHbhereco" ), @@ -22363,6 +22469,7 @@ minRecHitE = cms.double( 1.5 ), severity = cms.int32( 1 ), minHighHitE = cms.double( 25.0 ), + minR45HitE = cms.double( 5.0 ), numRBXsToConsider = cms.int32( 2 ), minRatio = cms.double( -999.0 ), maxHighEHitTime = cms.double( 9999.0 ), @@ -22649,9 +22756,11 @@ ) hltSiPixelDigisRegForBTag = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltSelector4CentralJetsL1FastJet' ), @@ -24845,6 +24954,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -25107,6 +25217,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -25132,6 +25243,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -25470,6 +25582,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -25495,6 +25608,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -25520,6 +25634,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -25880,6 +25995,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -26132,6 +26248,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -27154,6 +27271,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -27179,6 +27297,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -27254,6 +27373,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -27574,6 +27694,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -27681,6 +27802,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -27806,6 +27928,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -28232,9 +28355,11 @@ ) hltSiPixelDigisRegForNoPU = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltSelectorJets20L1FastJetForNoPU' ), diff --git a/HLTrigger/Configuration/python/HLT_GRun_Famos_cff.py b/HLTrigger/Configuration/python/HLT_GRun_Famos_cff.py index 5837c58365445..7661f5b0131a2 100644 --- a/HLTrigger/Configuration/python/HLT_GRun_Famos_cff.py +++ b/HLTrigger/Configuration/python/HLT_GRun_Famos_cff.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_3_0/GRun/V7 (CMSSW_7_2_3_HLT4) +# /dev/CMSSW_7_3_0/GRun/V9 (CMSSW_7_3_0) import FWCore.ParameterSet.Config as cms from FastSimulation.HighLevelTrigger.HLTSetup_cff import * HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_3_0/GRun/V7') + tableName = cms.string('/dev/CMSSW_7_3_0/GRun/V9') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1322,16 +1322,16 @@ hltEcalDigis = cms.EDProducer( "EcalRawToDigi", tccUnpacking = cms.bool( True ), FedLabel = cms.InputTag( "listfeds" ), - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), srpUnpacking = cms.bool( True ), syncCheck = cms.bool( True ), + feIdCheck = cms.bool( True ), silentMode = cms.untracked.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), + InputLabel = cms.InputTag( "rawDataCollector" ), orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), eventPut = cms.bool( True ), - InputLabel = cms.InputTag( "rawDataCollector" ), + numbTriggerTSamples = cms.int32( 1 ), numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), + orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), DoRegional = cms.bool( False ), feUnpacking = cms.bool( True ), @@ -3924,7 +3924,7 @@ L1GtObjectMapTag = cms.InputTag( "gtDigis" ), L1TechTriggerSeeding = cms.bool( False ) ) -hltPreAK8PFHT850TrimR0p1PT0p03Mass50 = cms.EDFilter( "HLTPrescaler", +hltPreAK8PFHT700TrimR0p1PT0p03Mass50 = cms.EDFilter( "HLTPrescaler", L1GtReadoutRecordTag = cms.InputTag( "gtDigis" ), offset = cms.uint32( 0 ) ) @@ -5062,6 +5062,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -5087,6 +5088,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -5425,6 +5427,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -5486,6 +5489,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -5686,6 +5690,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -5760,6 +5765,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -8237,6 +8243,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -8344,6 +8351,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -8496,6 +8504,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -8724,6 +8733,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9603,6 +9613,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9837,6 +9848,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -10143,6 +10155,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -10344,6 +10357,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -10572,6 +10586,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -11022,6 +11037,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -11413,6 +11429,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -11564,6 +11581,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -19910,6 +19928,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -20123,6 +20142,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -20321,6 +20341,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -20519,6 +20540,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -21232,6 +21254,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -21257,6 +21280,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -21609,6 +21633,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -21634,6 +21659,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -21659,6 +21685,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -22019,6 +22046,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -22289,6 +22317,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -22457,6 +22486,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -22647,6 +22677,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -23305,6 +23336,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -23858,6 +23890,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -24056,6 +24089,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -26334,6 +26368,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -26729,6 +26764,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -26930,6 +26966,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -27316,6 +27353,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -27662,6 +27700,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -27803,6 +27842,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -28187,7 +28227,7 @@ HLTriggerFirstPath = cms.Path( hltGetConditions + hltGetRaw + hltBoolFalse ) HLT_AK8PFJet360TrimMod_Mass30_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleJet176ORSingleJet200 + hltPreAK8PFJet360TrimModMass30 + HLTAK8CaloJetsSequence + hltAK8SingleCaloJet260 + HLTAK8PFJetsSequence + hltAK8PFJetsCorrectedMatchedToCaloJets260 + hltAK8TrimModJets + hltAK8SinglePFJet360TrimModMass30 + cms.SequencePlaceholder( "HLTEndSequence" ) ) -HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v1 = cms.Path( HLTBeginSequence + hltL1sL1HTT150ORHTT175 + hltPreAK8PFHT850TrimR0p1PT0p03Mass50 + HLTAK8CaloJetsSequence + hltAK8HtMht + hltAK8Ht600 + HLTAK8PFJetsSequence + hltAK8PFHT + hltAK8PFJetsTrimR0p1PT0p03 + hlt1AK8PFJetsTrimR0p1PT0p03Mass50 + hltAK8PFHT700 + cms.SequencePlaceholder( "HLTEndSequence" ) ) +HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v1 = cms.Path( HLTBeginSequence + hltL1sL1HTT150ORHTT175 + hltPreAK8PFHT700TrimR0p1PT0p03Mass50 + HLTAK8CaloJetsSequence + hltAK8HtMht + hltAK8Ht600 + HLTAK8PFJetsSequence + hltAK8PFHT + hltAK8PFJetsTrimR0p1PT0p03 + hlt1AK8PFJetsTrimR0p1PT0p03Mass50 + hltAK8PFHT700 + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_CaloJet500_NoJetID_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleJet200 + hltPreCaloJet500NoJetID + HLTAK4CaloJetsReconstructionNoIDSequence + HLTAK4CaloJetsCorrectionNoIDSequence + hltSingleCaloJet500 + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_Dimuon13_PsiPrime_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMu10MuOpenHighQ + hltPreDimuon13PsiPrime + hltL1fL1sL1DoubleMu10MuOpenHighQL1Filtered0 + HLTL2muonrecoSequence + hltL2fL1sL1DoubleMu10MuOpenHighQL1f0L2PreFiltered0 + HLTL3muonrecoSequence + hltDimuon13PsiPrimeL3Filtered + hltDisplacedmumuVtxProducerDimuon13PsiPrime + hltDisplacedmumuFilterDimuon13PsiPrime + cms.SequencePlaceholder( "HLTEndSequence" ) ) HLT_Dimuon13_Upsilon_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMu10MuOpenHighQ + hltPreDimuon13Upsilon + hltL1fL1sL1DoubleMu10MuOpenHighQL1Filtered0 + HLTL2muonrecoSequence + hltL2fL1sL1DoubleMu10MuOpenHighQL1f0L2PreFiltered0 + HLTL3muonrecoSequence + hltDimuon13UpsilonL3Filtered + hltDisplacedmumuVtxProducerDimuon13Upsilon + hltDisplacedmumuFilterDimuon13Upsilon + cms.SequencePlaceholder( "HLTEndSequence" ) ) diff --git a/HLTrigger/Configuration/python/HLT_GRun_cff.py b/HLTrigger/Configuration/python/HLT_GRun_cff.py index 804da458119b5..3d4b12e2c929c 100644 --- a/HLTrigger/Configuration/python/HLT_GRun_cff.py +++ b/HLTrigger/Configuration/python/HLT_GRun_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_3_0/GRun/V7 (CMSSW_7_2_3_HLT4) +# /dev/CMSSW_7_3_0/GRun/V9 (CMSSW_7_3_0) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_3_0/GRun/V7') + tableName = cms.string('/dev/CMSSW_7_3_0/GRun/V9') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1684,16 +1684,16 @@ hltEcalDigis = cms.EDProducer( "EcalRawToDigi", tccUnpacking = cms.bool( True ), FedLabel = cms.InputTag( "listfeds" ), - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), srpUnpacking = cms.bool( True ), syncCheck = cms.bool( True ), + feIdCheck = cms.bool( True ), silentMode = cms.untracked.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), + InputLabel = cms.InputTag( "rawDataCollector" ), orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), eventPut = cms.bool( True ), - InputLabel = cms.InputTag( "rawDataCollector" ), + numbTriggerTSamples = cms.int32( 1 ), numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), + orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), DoRegional = cms.bool( False ), feUnpacking = cms.bool( True ), @@ -1814,15 +1814,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -1830,13 +1832,29 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HBHE" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ignorelowest = cms.bool( True ), win_offset = cms.double( 0.0 ), @@ -1844,7 +1862,14 @@ win_gain = cms.double( 1.0 ), tfilterEnvelope = cms.vdouble( 4.0, 12.04, 13.0, 10.56, 23.5, 8.82, 37.0, 7.38, 56.0, 6.3, 81.0, 5.64, 114.5, 5.44, 175.5, 5.38, 350.5, 5.14 ) ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( nominalPedestal = cms.double( 3.0 ), hitMultiplicityThreshold = cms.int32( 17 ), @@ -1856,6 +1881,11 @@ cms.PSet( pulseShapeParameters = cms.vdouble( -1000000.0, 1000000.0, 45.0, 0.1, 1000000.0, 0.0 ) ) ) ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( slopeMax = cms.double( -0.6 ), r1Max = cms.double( 1.0 ), @@ -1889,6 +1919,7 @@ samplesToAdd = cms.int32( 2 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( hflongEthresh = cms.double( 40.0 ), @@ -1901,7 +1932,13 @@ digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 1 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( + HFdigiflagFirstSample = cms.int32( 1 ), + HFdigiflagMinEthreshold = cms.double( 40.0 ), + HFdigiflagSamplesToAdd = cms.int32( 3 ), + HFdigiflagExpectedPeak = cms.int32( 2 ), + HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) + ), hfTimingTrustParameters = cms.PSet( hfTimingTrustLevel2 = cms.int32( 4 ), hfTimingTrustLevel1 = cms.int32( 1 ) @@ -1918,13 +1955,8 @@ long_R = cms.vdouble( 0.98 ), HcalAcceptSeverityLevel = cms.int32( 9 ) ), - digistat = cms.PSet( - HFdigiflagFirstSample = cms.int32( 1 ), - HFdigiflagMinEthreshold = cms.double( 40.0 ), - HFdigiflagSamplesToAdd = cms.int32( 3 ), - HFdigiflagExpectedPeak = cms.int32( 2 ), - HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) - ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( @@ -1942,16 +1974,44 @@ correctForTimeslew = cms.bool( False ), setNoiseFlags = cms.bool( True ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HF" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 2 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) hltHoreco = cms.EDProducer( "HcalHitReconstructor", @@ -1963,15 +2023,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -1979,16 +2041,44 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HO" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) hltTowerMakerForAll = cms.EDProducer( "CaloTowersCreator", @@ -2842,9 +2932,11 @@ ) hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( ), Timing = cms.untracked.bool( False ), @@ -5735,7 +5827,7 @@ L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), L1TechTriggerSeeding = cms.bool( False ) ) -hltPreAK8PFHT850TrimR0p1PT0p03Mass50 = cms.EDFilter( "HLTPrescaler", +hltPreAK8PFHT700TrimR0p1PT0p03Mass50 = cms.EDFilter( "HLTPrescaler", L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) @@ -6873,6 +6965,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -6898,6 +6991,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -7860,6 +7954,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -7921,6 +8016,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -8121,6 +8217,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -8230,6 +8327,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -8576,9 +8674,11 @@ ) hltSiPixelDigisReg = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltL2TausForPixelIsolation' ), @@ -14995,6 +15095,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -15102,6 +15203,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -15254,6 +15356,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -15482,6 +15585,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -16361,6 +16465,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -16595,6 +16700,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -16901,6 +17007,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17102,6 +17209,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17330,6 +17438,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17780,6 +17889,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18171,6 +18281,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18322,6 +18433,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18479,6 +18591,7 @@ pMaxHPDEMF = cms.double( 0.02 ), minRecHitE = cms.double( 1.5 ), hlMaxHPDEMF = cms.double( -9999.0 ), + lRBXRecHitR45Cuts = cms.vdouble( 0.0, 1.0, 0.0, -0.5, 0.0, 0.0, 1.0, -0.5 ), maxCaloTowerIEta = cms.int32( 20 ), pMinEEMF = cms.double( 10.0 ), pMaxRatio = cms.double( 0.85 ), @@ -18487,9 +18600,13 @@ pMaxHighEHitTime = cms.double( 5.0 ), pMaxLowEHitTime = cms.double( 6.0 ), minHighHitE = cms.double( 25.0 ), + minR45HitE = cms.double( 5.0 ), + tRBXRecHitR45Cuts = cms.vdouble( 0.0, 1.0, 0.0, -0.2, 0.0, 0.0, 1.0, -0.2 ), + fillRecHits = cms.bool( True ), lMinZeros = cms.int32( 10 ), lMinRBXHits = cms.int32( 999 ), - fillRecHits = cms.bool( True ), + pMinRBXRechitR45Fraction = cms.double( 0.1 ), + pMinRBXRechitR45EnergyFraction = cms.double( 0.1 ), HcalRecHitFlagsToBeExcluded = cms.vint32( 11, 12, 13, 14, 15 ), calibdigiHFthreshold = cms.double( -999.0 ), minLowHitE = cms.double( 10.0 ), @@ -18516,6 +18633,7 @@ tMinRatio = cms.double( 0.73 ), TS4TS5UpperCut = cms.vdouble( 999.0, 999.0, 999.0, 999.0, 999.0 ), pMinLowEHitTime = cms.double( -6.0 ), + pMinRBXRechitR45Count = cms.int32( 1 ), pMinHPDHits = cms.int32( 10 ), lMinLowEHitTime = cms.double( -9999.0 ), recHitCollName = cms.string( "hltHbhereco" ), @@ -18542,6 +18660,7 @@ minRecHitE = cms.double( 1.5 ), severity = cms.int32( 1 ), minHighHitE = cms.double( 25.0 ), + minR45HitE = cms.double( 5.0 ), numRBXsToConsider = cms.int32( 2 ), minRatio = cms.double( -999.0 ), maxHighEHitTime = cms.double( 9999.0 ), @@ -25388,9 +25507,11 @@ ) hltSiPixelDigisRegForBTag = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltSelectorCentralJets20L1FastJeta' ), @@ -30484,6 +30605,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -30697,6 +30819,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -30895,6 +31018,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -31093,6 +31217,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -31806,6 +31931,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -31831,6 +31957,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -32183,6 +32310,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -32208,6 +32336,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -32233,6 +32362,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -32581,6 +32711,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -32851,6 +32982,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -33019,6 +33151,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -33209,6 +33342,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -33867,6 +34001,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -34420,6 +34555,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -34618,6 +34754,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -37209,6 +37346,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -37604,6 +37742,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -37805,6 +37944,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -38191,6 +38331,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -38537,6 +38678,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -38678,6 +38820,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -39138,7 +39281,7 @@ HLTriggerFirstPath = cms.Path( hltGetConditions + hltGetRaw + hltBoolFalse ) HLT_AK8PFJet360TrimMod_Mass30_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleJet176ORSingleJet200 + hltPreAK8PFJet360TrimModMass30 + HLTAK8CaloJetsSequence + hltAK8SingleCaloJet260 + HLTAK8PFJetsSequence + hltAK8PFJetsCorrectedMatchedToCaloJets260 + hltAK8TrimModJets + hltAK8SinglePFJet360TrimModMass30 + HLTEndSequence ) -HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v1 = cms.Path( HLTBeginSequence + hltL1sL1HTT150ORHTT175 + hltPreAK8PFHT850TrimR0p1PT0p03Mass50 + HLTAK8CaloJetsSequence + hltAK8HtMht + hltAK8Ht600 + HLTAK8PFJetsSequence + hltAK8PFHT + hltAK8PFJetsTrimR0p1PT0p03 + hlt1AK8PFJetsTrimR0p1PT0p03Mass50 + hltAK8PFHT700 + HLTEndSequence ) +HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v1 = cms.Path( HLTBeginSequence + hltL1sL1HTT150ORHTT175 + hltPreAK8PFHT700TrimR0p1PT0p03Mass50 + HLTAK8CaloJetsSequence + hltAK8HtMht + hltAK8Ht600 + HLTAK8PFJetsSequence + hltAK8PFHT + hltAK8PFJetsTrimR0p1PT0p03 + hlt1AK8PFJetsTrimR0p1PT0p03Mass50 + hltAK8PFHT700 + HLTEndSequence ) HLT_CaloJet500_NoJetID_v1 = cms.Path( HLTBeginSequence + hltL1sL1SingleJet200 + hltPreCaloJet500NoJetID + HLTAK4CaloJetsReconstructionNoIDSequence + HLTAK4CaloJetsCorrectionNoIDSequence + hltSingleCaloJet500 + HLTEndSequence ) HLT_Dimuon13_PsiPrime_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMu10MuOpenHighQ + hltPreDimuon13PsiPrime + hltL1fL1sL1DoubleMu10MuOpenHighQL1Filtered0 + HLTL2muonrecoSequence + hltL2fL1sL1DoubleMu10MuOpenHighQL1f0L2PreFiltered0 + HLTL3muonrecoSequence + hltDimuon13PsiPrimeL3Filtered + hltDisplacedmumuVtxProducerDimuon13PsiPrime + hltDisplacedmumuFilterDimuon13PsiPrime + HLTEndSequence ) HLT_Dimuon13_Upsilon_v1 = cms.Path( HLTBeginSequence + hltL1sL1DoubleMu10MuOpenHighQ + hltPreDimuon13Upsilon + hltL1fL1sL1DoubleMu10MuOpenHighQL1Filtered0 + HLTL2muonrecoSequence + hltL2fL1sL1DoubleMu10MuOpenHighQL1f0L2PreFiltered0 + HLTL3muonrecoSequence + hltDimuon13UpsilonL3Filtered + hltDisplacedmumuVtxProducerDimuon13Upsilon + hltDisplacedmumuFilterDimuon13Upsilon + HLTEndSequence ) diff --git a/HLTrigger/Configuration/python/HLT_HIon_cff.py b/HLTrigger/Configuration/python/HLT_HIon_cff.py index 674047cfc7329..57cf10b93ddec 100644 --- a/HLTrigger/Configuration/python/HLT_HIon_cff.py +++ b/HLTrigger/Configuration/python/HLT_HIon_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_3_0/HIon/V7 (CMSSW_7_2_3_HLT4) +# /dev/CMSSW_7_3_0/HIon/V9 (CMSSW_7_3_0) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_3_0/HIon/V7') + tableName = cms.string('/dev/CMSSW_7_3_0/HIon/V9') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1423,16 +1423,16 @@ hltEcalDigis = cms.EDProducer( "EcalRawToDigi", tccUnpacking = cms.bool( True ), FedLabel = cms.InputTag( "listfeds" ), - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), srpUnpacking = cms.bool( True ), syncCheck = cms.bool( True ), + feIdCheck = cms.bool( True ), silentMode = cms.untracked.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), + InputLabel = cms.InputTag( "rawDataCollector" ), orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), eventPut = cms.bool( True ), - InputLabel = cms.InputTag( "rawDataCollector" ), + numbTriggerTSamples = cms.int32( 1 ), numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), + orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), DoRegional = cms.bool( False ), feUnpacking = cms.bool( True ), @@ -1553,15 +1553,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -1569,13 +1571,29 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HBHE" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ignorelowest = cms.bool( True ), win_offset = cms.double( 0.0 ), @@ -1583,7 +1601,14 @@ win_gain = cms.double( 1.0 ), tfilterEnvelope = cms.vdouble( 4.0, 12.04, 13.0, 10.56, 23.5, 8.82, 37.0, 7.38, 56.0, 6.3, 81.0, 5.64, 114.5, 5.44, 175.5, 5.38, 350.5, 5.14 ) ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( nominalPedestal = cms.double( 3.0 ), hitMultiplicityThreshold = cms.int32( 17 ), @@ -1595,6 +1620,11 @@ cms.PSet( pulseShapeParameters = cms.vdouble( -1000000.0, 1000000.0, 45.0, 0.1, 1000000.0, 0.0 ) ) ) ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( slopeMax = cms.double( -0.6 ), r1Max = cms.double( 1.0 ), @@ -1628,6 +1658,7 @@ samplesToAdd = cms.int32( 2 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( hflongEthresh = cms.double( 40.0 ), @@ -1640,7 +1671,13 @@ digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 1 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( + HFdigiflagFirstSample = cms.int32( 1 ), + HFdigiflagMinEthreshold = cms.double( 40.0 ), + HFdigiflagSamplesToAdd = cms.int32( 3 ), + HFdigiflagExpectedPeak = cms.int32( 2 ), + HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) + ), hfTimingTrustParameters = cms.PSet( hfTimingTrustLevel2 = cms.int32( 4 ), hfTimingTrustLevel1 = cms.int32( 1 ) @@ -1657,13 +1694,8 @@ long_R = cms.vdouble( 0.98 ), HcalAcceptSeverityLevel = cms.int32( 9 ) ), - digistat = cms.PSet( - HFdigiflagFirstSample = cms.int32( 1 ), - HFdigiflagMinEthreshold = cms.double( 40.0 ), - HFdigiflagSamplesToAdd = cms.int32( 3 ), - HFdigiflagExpectedPeak = cms.int32( 2 ), - HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) - ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( @@ -1681,16 +1713,44 @@ correctForTimeslew = cms.bool( False ), setNoiseFlags = cms.bool( True ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HF" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 2 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) hltHoreco = cms.EDProducer( "HcalHitReconstructor", @@ -1702,15 +1762,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -1718,16 +1780,44 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HO" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) hltTowerMakerForAll = cms.EDProducer( "CaloTowersCreator", @@ -2500,9 +2590,11 @@ ) hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( ), Timing = cms.untracked.bool( False ), @@ -2678,6 +2770,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), diff --git a/HLTrigger/Configuration/python/HLT_PIon_cff.py b/HLTrigger/Configuration/python/HLT_PIon_cff.py index e4993aee5f09b..72940185ae4e2 100644 --- a/HLTrigger/Configuration/python/HLT_PIon_cff.py +++ b/HLTrigger/Configuration/python/HLT_PIon_cff.py @@ -1,10 +1,10 @@ -# /dev/CMSSW_7_3_0/PIon/V7 (CMSSW_7_2_3_HLT4) +# /dev/CMSSW_7_3_0/PIon/V9 (CMSSW_7_3_0) import FWCore.ParameterSet.Config as cms HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_3_0/PIon/V7') + tableName = cms.string('/dev/CMSSW_7_3_0/PIon/V9') ) HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1423,16 +1423,16 @@ hltEcalDigis = cms.EDProducer( "EcalRawToDigi", tccUnpacking = cms.bool( True ), FedLabel = cms.InputTag( "listfeds" ), - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), srpUnpacking = cms.bool( True ), syncCheck = cms.bool( True ), + feIdCheck = cms.bool( True ), silentMode = cms.untracked.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), + InputLabel = cms.InputTag( "rawDataCollector" ), orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), eventPut = cms.bool( True ), - InputLabel = cms.InputTag( "rawDataCollector" ), + numbTriggerTSamples = cms.int32( 1 ), numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), + orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), DoRegional = cms.bool( False ), feUnpacking = cms.bool( True ), @@ -1553,15 +1553,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -1569,13 +1571,29 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HBHE" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ignorelowest = cms.bool( True ), win_offset = cms.double( 0.0 ), @@ -1583,7 +1601,14 @@ win_gain = cms.double( 1.0 ), tfilterEnvelope = cms.vdouble( 4.0, 12.04, 13.0, 10.56, 23.5, 8.82, 37.0, 7.38, 56.0, 6.3, 81.0, 5.64, 114.5, 5.44, 175.5, 5.38, 350.5, 5.14 ) ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( nominalPedestal = cms.double( 3.0 ), hitMultiplicityThreshold = cms.int32( 17 ), @@ -1595,6 +1620,11 @@ cms.PSet( pulseShapeParameters = cms.vdouble( -1000000.0, 1000000.0, 45.0, 0.1, 1000000.0, 0.0 ) ) ) ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( slopeMax = cms.double( -0.6 ), r1Max = cms.double( 1.0 ), @@ -1628,6 +1658,7 @@ samplesToAdd = cms.int32( 2 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( hflongEthresh = cms.double( 40.0 ), @@ -1640,7 +1671,13 @@ digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 1 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( + HFdigiflagFirstSample = cms.int32( 1 ), + HFdigiflagMinEthreshold = cms.double( 40.0 ), + HFdigiflagSamplesToAdd = cms.int32( 3 ), + HFdigiflagExpectedPeak = cms.int32( 2 ), + HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) + ), hfTimingTrustParameters = cms.PSet( hfTimingTrustLevel2 = cms.int32( 4 ), hfTimingTrustLevel1 = cms.int32( 1 ) @@ -1657,13 +1694,8 @@ long_R = cms.vdouble( 0.98 ), HcalAcceptSeverityLevel = cms.int32( 9 ) ), - digistat = cms.PSet( - HFdigiflagFirstSample = cms.int32( 1 ), - HFdigiflagMinEthreshold = cms.double( 40.0 ), - HFdigiflagSamplesToAdd = cms.int32( 3 ), - HFdigiflagExpectedPeak = cms.int32( 2 ), - HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) - ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( @@ -1681,16 +1713,44 @@ correctForTimeslew = cms.bool( False ), setNoiseFlags = cms.bool( True ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HF" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 2 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) hltHoreco = cms.EDProducer( "HcalHitReconstructor", @@ -1702,15 +1762,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -1718,16 +1780,44 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HO" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) hltTowerMakerForAll = cms.EDProducer( "CaloTowersCreator", @@ -2500,9 +2590,11 @@ ) hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( ), Timing = cms.untracked.bool( False ), @@ -2678,6 +2770,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), diff --git a/HLTrigger/Configuration/test/OnData_HLT_FULL.py b/HLTrigger/Configuration/test/OnData_HLT_FULL.py index 6658e852fa05e..9cc396d55cd54 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_FULL.py +++ b/HLTrigger/Configuration/test/OnData_HLT_FULL.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_3_0/HLT/V17 (CMSSW_7_2_3_HLT4) +# /dev/CMSSW_7_3_0/HLT/V19 (CMSSW_7_3_0) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTFULL" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_3_0/HLT/V17') + tableName = cms.string('/dev/CMSSW_7_3_0/HLT/V19') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2222,16 +2222,16 @@ process.hltEcalDigis = cms.EDProducer( "EcalRawToDigi", tccUnpacking = cms.bool( True ), FedLabel = cms.InputTag( "listfeds" ), - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), srpUnpacking = cms.bool( True ), syncCheck = cms.bool( True ), + feIdCheck = cms.bool( True ), silentMode = cms.untracked.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), + InputLabel = cms.InputTag( "rawDataCollector" ), orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), eventPut = cms.bool( True ), - InputLabel = cms.InputTag( "rawDataCollector" ), + numbTriggerTSamples = cms.int32( 1 ), numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), + orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), DoRegional = cms.bool( False ), feUnpacking = cms.bool( True ), @@ -2352,15 +2352,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -2368,13 +2370,29 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HBHE" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ignorelowest = cms.bool( True ), win_offset = cms.double( 0.0 ), @@ -2382,7 +2400,14 @@ win_gain = cms.double( 1.0 ), tfilterEnvelope = cms.vdouble( 4.0, 12.04, 13.0, 10.56, 23.5, 8.82, 37.0, 7.38, 56.0, 6.3, 81.0, 5.64, 114.5, 5.44, 175.5, 5.38, 350.5, 5.14 ) ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( nominalPedestal = cms.double( 3.0 ), hitMultiplicityThreshold = cms.int32( 17 ), @@ -2394,6 +2419,11 @@ cms.PSet( pulseShapeParameters = cms.vdouble( -1000000.0, 1000000.0, 45.0, 0.1, 1000000.0, 0.0 ) ) ) ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( slopeMax = cms.double( -0.6 ), r1Max = cms.double( 1.0 ), @@ -2427,6 +2457,7 @@ samplesToAdd = cms.int32( 2 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( hflongEthresh = cms.double( 40.0 ), @@ -2439,7 +2470,13 @@ digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 1 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( + HFdigiflagFirstSample = cms.int32( 1 ), + HFdigiflagMinEthreshold = cms.double( 40.0 ), + HFdigiflagSamplesToAdd = cms.int32( 3 ), + HFdigiflagExpectedPeak = cms.int32( 2 ), + HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) + ), hfTimingTrustParameters = cms.PSet( hfTimingTrustLevel2 = cms.int32( 4 ), hfTimingTrustLevel1 = cms.int32( 1 ) @@ -2456,13 +2493,8 @@ long_R = cms.vdouble( 0.98 ), HcalAcceptSeverityLevel = cms.int32( 9 ) ), - digistat = cms.PSet( - HFdigiflagFirstSample = cms.int32( 1 ), - HFdigiflagMinEthreshold = cms.double( 40.0 ), - HFdigiflagSamplesToAdd = cms.int32( 3 ), - HFdigiflagExpectedPeak = cms.int32( 2 ), - HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) - ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( @@ -2480,16 +2512,44 @@ correctForTimeslew = cms.bool( False ), setNoiseFlags = cms.bool( True ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HF" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 2 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) process.hltHoreco = cms.EDProducer( "HcalHitReconstructor", @@ -2501,15 +2561,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -2517,16 +2579,44 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HO" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) process.hltTowerMakerForAll = cms.EDProducer( "CaloTowersCreator", @@ -3380,9 +3470,11 @@ ) process.hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( ), Timing = cms.untracked.bool( False ), @@ -6273,7 +6365,7 @@ L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), L1TechTriggerSeeding = cms.bool( False ) ) -process.hltPreAK8PFHT850TrimR0p1PT0p03Mass50 = cms.EDFilter( "HLTPrescaler", +process.hltPreAK8PFHT700TrimR0p1PT0p03Mass50 = cms.EDFilter( "HLTPrescaler", L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) @@ -6493,9 +6585,11 @@ ) process.hltSiPixelDigisRegForBTag = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltSelectorCentralJets20L1FastJeta' ), @@ -8478,6 +8572,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -8503,6 +8598,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9465,6 +9561,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9526,6 +9623,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9726,6 +9824,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9835,6 +9934,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -10181,9 +10281,11 @@ ) process.hltSiPixelDigisReg = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltL2TausForPixelIsolation' ), @@ -17318,6 +17420,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17343,6 +17446,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17368,6 +17472,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17750,6 +17855,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17775,6 +17881,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18021,6 +18128,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18128,6 +18236,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18280,6 +18389,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18508,6 +18618,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -19063,6 +19174,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -19088,6 +19200,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -19343,6 +19456,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -19577,6 +19691,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -19883,6 +19998,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -20084,6 +20200,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -20312,6 +20429,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -20819,6 +20937,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -21201,6 +21320,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -21352,6 +21472,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -21546,6 +21667,7 @@ pMaxHPDEMF = cms.double( 0.02 ), minRecHitE = cms.double( 1.5 ), hlMaxHPDEMF = cms.double( -9999.0 ), + lRBXRecHitR45Cuts = cms.vdouble( 0.0, 1.0, 0.0, -0.5, 0.0, 0.0, 1.0, -0.5 ), maxCaloTowerIEta = cms.int32( 20 ), pMinEEMF = cms.double( 10.0 ), pMaxRatio = cms.double( 0.85 ), @@ -21554,9 +21676,13 @@ pMaxHighEHitTime = cms.double( 5.0 ), pMaxLowEHitTime = cms.double( 6.0 ), minHighHitE = cms.double( 25.0 ), + minR45HitE = cms.double( 5.0 ), + tRBXRecHitR45Cuts = cms.vdouble( 0.0, 1.0, 0.0, -0.2, 0.0, 0.0, 1.0, -0.2 ), + fillRecHits = cms.bool( True ), lMinZeros = cms.int32( 10 ), lMinRBXHits = cms.int32( 999 ), - fillRecHits = cms.bool( True ), + pMinRBXRechitR45Fraction = cms.double( 0.1 ), + pMinRBXRechitR45EnergyFraction = cms.double( 0.1 ), HcalRecHitFlagsToBeExcluded = cms.vint32( 11, 12, 13, 14, 15 ), calibdigiHFthreshold = cms.double( -999.0 ), minLowHitE = cms.double( 10.0 ), @@ -21583,6 +21709,7 @@ tMinRatio = cms.double( 0.73 ), TS4TS5UpperCut = cms.vdouble( 999.0, 999.0, 999.0, 999.0, 999.0 ), pMinLowEHitTime = cms.double( -6.0 ), + pMinRBXRechitR45Count = cms.int32( 1 ), pMinHPDHits = cms.int32( 10 ), lMinLowEHitTime = cms.double( -9999.0 ), recHitCollName = cms.string( "hltHbhereco" ), @@ -21609,6 +21736,7 @@ minRecHitE = cms.double( 1.5 ), severity = cms.int32( 1 ), minHighHitE = cms.double( 25.0 ), + minR45HitE = cms.double( 5.0 ), numRBXsToConsider = cms.int32( 2 ), minRatio = cms.double( -999.0 ), maxHighEHitTime = cms.double( 9999.0 ), @@ -28052,6 +28180,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -29027,6 +29156,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -34578,6 +34708,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -34791,6 +34922,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -34989,6 +35121,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -35187,6 +35320,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -35900,6 +36034,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -35925,6 +36060,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -36277,6 +36413,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -36302,6 +36439,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -36327,6 +36465,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -36675,6 +36814,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -36933,6 +37073,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -37101,6 +37242,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -37291,6 +37433,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -37949,6 +38092,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -38502,6 +38646,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -38700,6 +38845,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -41316,6 +41462,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -41711,6 +41858,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -41912,6 +42060,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -42298,6 +42447,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -42644,6 +42794,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -42785,6 +42936,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -43810,7 +43962,7 @@ process.HLTriggerFirstPath = cms.Path( process.hltGetConditions + process.hltGetRaw + process.hltBoolFalse ) process.HLT_AK8PFJet360TrimMod_Mass30_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleJet176ORSingleJet200 + process.hltPreAK8PFJet360TrimModMass30 + process.HLTAK8CaloJetsSequence + process.hltAK8SingleCaloJet260 + process.HLTAK8PFJetsSequence + process.hltAK8PFJetsCorrectedMatchedToCaloJets260 + process.hltAK8TrimModJets + process.hltAK8SinglePFJet360TrimModMass30 + process.HLTEndSequence ) -process.HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1HTT150ORHTT175 + process.hltPreAK8PFHT850TrimR0p1PT0p03Mass50 + process.HLTAK8CaloJetsSequence + process.hltAK8HtMht + process.hltAK8Ht600 + process.HLTAK8PFJetsSequence + process.hltAK8PFHT + process.hltAK8PFJetsTrimR0p1PT0p03 + process.hlt1AK8PFJetsTrimR0p1PT0p03Mass50 + process.hltAK8PFHT700 + process.HLTEndSequence ) +process.HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1HTT150ORHTT175 + process.hltPreAK8PFHT700TrimR0p1PT0p03Mass50 + process.HLTAK8CaloJetsSequence + process.hltAK8HtMht + process.hltAK8Ht600 + process.HLTAK8PFJetsSequence + process.hltAK8PFHT + process.hltAK8PFJetsTrimR0p1PT0p03 + process.hlt1AK8PFJetsTrimR0p1PT0p03Mass50 + process.hltAK8PFHT700 + process.HLTEndSequence ) process.HLT_BTagCSV07_v1 = cms.Path( process.HLTBeginSequence + process.hltPreBTagCSV07 + process.HLTAK4CaloJetsSequence + process.HLTFastPrimaryVertexSequence + process.hltFastPVPixelVertexSelector + process.HLTBtagCSVSequenceL3 + process.hltBLifetimeL3FilterCSV + process.HLTEndSequence ) process.HLT_CaloJet260_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleJet200 + process.hltPreCaloJet260 + process.HLTAK4CaloJetsSequence + process.hltSingleCaloJet260 + process.HLTEndSequence ) process.HLT_CaloJet500_NoJetID_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleJet200 + process.hltPreCaloJet500NoJetID + process.HLTAK4CaloJetsReconstructionNoIDSequence + process.HLTAK4CaloJetsCorrectionNoIDSequence + process.hltSingleCaloJet500 + process.HLTEndSequence ) diff --git a/HLTrigger/Configuration/test/OnData_HLT_Fake.py b/HLTrigger/Configuration/test/OnData_HLT_Fake.py index dc35ea7612384..973de2e536350 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_Fake.py +++ b/HLTrigger/Configuration/test/OnData_HLT_Fake.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_3_0/Fake/V3 (CMSSW_7_2_3_HLT4) +# /dev/CMSSW_7_3_0/Fake/V4 (CMSSW_7_3_0) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTFake" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_3_0/Fake/V3') + tableName = cms.string('/dev/CMSSW_7_3_0/Fake/V4') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2774,9 +2774,11 @@ ) process.hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( ), Timing = cms.untracked.bool( False ), @@ -4592,16 +4594,16 @@ process.hltEcalDigis = cms.EDProducer( "EcalRawToDigi", tccUnpacking = cms.bool( True ), FedLabel = cms.InputTag( "listfeds" ), - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), srpUnpacking = cms.bool( True ), syncCheck = cms.bool( True ), + feIdCheck = cms.bool( True ), silentMode = cms.untracked.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), + InputLabel = cms.InputTag( "rawDataCollector" ), orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), eventPut = cms.bool( True ), - InputLabel = cms.InputTag( "rawDataCollector" ), + numbTriggerTSamples = cms.int32( 1 ), numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), + orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), DoRegional = cms.bool( False ), feUnpacking = cms.bool( True ), @@ -4735,15 +4737,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -4751,13 +4755,29 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HBHE" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ignorelowest = cms.bool( True ), win_offset = cms.double( 0.0 ), @@ -4765,7 +4785,14 @@ win_gain = cms.double( 1.0 ), tfilterEnvelope = cms.vdouble( 4.0, 12.04, 13.0, 10.56, 23.5, 8.82, 37.0, 7.38, 56.0, 6.3, 81.0, 5.64, 114.5, 5.44, 175.5, 5.38, 350.5, 5.14 ) ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( nominalPedestal = cms.double( 3.0 ), hitMultiplicityThreshold = cms.int32( 17 ), @@ -4777,6 +4804,11 @@ cms.PSet( pulseShapeParameters = cms.vdouble( -1000000.0, 1000000.0, 45.0, 0.1, 1000000.0, 0.0 ) ) ) ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( slopeMax = cms.double( -0.6 ), r1Max = cms.double( 1.0 ), @@ -4810,6 +4842,7 @@ samplesToAdd = cms.int32( 2 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( hflongEthresh = cms.double( 40.0 ), @@ -4822,7 +4855,13 @@ digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 1 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( + HFdigiflagFirstSample = cms.int32( 1 ), + HFdigiflagMinEthreshold = cms.double( 40.0 ), + HFdigiflagSamplesToAdd = cms.int32( 3 ), + HFdigiflagExpectedPeak = cms.int32( 2 ), + HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) + ), hfTimingTrustParameters = cms.PSet( hfTimingTrustLevel2 = cms.int32( 4 ), hfTimingTrustLevel1 = cms.int32( 1 ) @@ -4839,13 +4878,8 @@ long_R = cms.vdouble( 0.98 ), HcalAcceptSeverityLevel = cms.int32( 9 ) ), - digistat = cms.PSet( - HFdigiflagFirstSample = cms.int32( 1 ), - HFdigiflagMinEthreshold = cms.double( 40.0 ), - HFdigiflagSamplesToAdd = cms.int32( 3 ), - HFdigiflagExpectedPeak = cms.int32( 2 ), - HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) - ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( @@ -4863,16 +4897,44 @@ correctForTimeslew = cms.bool( False ), setNoiseFlags = cms.bool( True ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HF" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 2 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) process.hltHoreco = cms.EDProducer( "HcalHitReconstructor", @@ -4884,15 +4946,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -4900,16 +4964,44 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HO" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) process.hltTowerMakerForAll = cms.EDProducer( "CaloTowersCreator", @@ -13090,6 +13182,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -14080,6 +14173,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -14105,6 +14199,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -14315,6 +14410,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -14740,6 +14836,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -19887,6 +19984,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -20635,9 +20733,11 @@ ) process.hltSiPixelDigisReg = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltL2TausForPixelIsolation' ), @@ -22797,6 +22897,7 @@ pMaxHPDEMF = cms.double( 0.02 ), minRecHitE = cms.double( 1.5 ), hlMaxHPDEMF = cms.double( -9999.0 ), + lRBXRecHitR45Cuts = cms.vdouble( 0.0, 1.0, 0.0, -0.5, 0.0, 0.0, 1.0, -0.5 ), maxCaloTowerIEta = cms.int32( 20 ), pMinEEMF = cms.double( 10.0 ), pMaxRatio = cms.double( 0.85 ), @@ -22805,9 +22906,13 @@ pMaxHighEHitTime = cms.double( 5.0 ), pMaxLowEHitTime = cms.double( 6.0 ), minHighHitE = cms.double( 25.0 ), + minR45HitE = cms.double( 5.0 ), + tRBXRecHitR45Cuts = cms.vdouble( 0.0, 1.0, 0.0, -0.2, 0.0, 0.0, 1.0, -0.2 ), + fillRecHits = cms.bool( True ), lMinZeros = cms.int32( 10 ), lMinRBXHits = cms.int32( 999 ), - fillRecHits = cms.bool( True ), + pMinRBXRechitR45Fraction = cms.double( 0.1 ), + pMinRBXRechitR45EnergyFraction = cms.double( 0.1 ), HcalRecHitFlagsToBeExcluded = cms.vint32( 11, 12, 13, 14, 15 ), calibdigiHFthreshold = cms.double( -999.0 ), minLowHitE = cms.double( 10.0 ), @@ -22834,6 +22939,7 @@ tMinRatio = cms.double( 0.73 ), TS4TS5UpperCut = cms.vdouble( 999.0, 999.0, 999.0, 999.0, 999.0 ), pMinLowEHitTime = cms.double( -6.0 ), + pMinRBXRechitR45Count = cms.int32( 1 ), pMinHPDHits = cms.int32( 10 ), lMinLowEHitTime = cms.double( -9999.0 ), recHitCollName = cms.string( "hltHbhereco" ), @@ -22860,6 +22966,7 @@ minRecHitE = cms.double( 1.5 ), severity = cms.int32( 1 ), minHighHitE = cms.double( 25.0 ), + minR45HitE = cms.double( 5.0 ), numRBXsToConsider = cms.int32( 2 ), minRatio = cms.double( -999.0 ), maxHighEHitTime = cms.double( 9999.0 ), @@ -23146,9 +23253,11 @@ ) process.hltSiPixelDigisRegForBTag = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltSelector4CentralJetsL1FastJet' ), @@ -25342,6 +25451,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -25604,6 +25714,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -25629,6 +25740,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -25967,6 +26079,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -25992,6 +26105,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -26017,6 +26131,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -26377,6 +26492,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -26629,6 +26745,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -27651,6 +27768,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -27676,6 +27794,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -27751,6 +27870,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -28071,6 +28191,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -28178,6 +28299,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -28303,6 +28425,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -28729,9 +28852,11 @@ ) process.hltSiPixelDigisRegForNoPU = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltSelectorJets20L1FastJetForNoPU' ), diff --git a/HLTrigger/Configuration/test/OnData_HLT_GRun.py b/HLTrigger/Configuration/test/OnData_HLT_GRun.py index 4f749263f4fce..3afdf13601b5b 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_GRun.py +++ b/HLTrigger/Configuration/test/OnData_HLT_GRun.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_3_0/GRun/V7 (CMSSW_7_2_3_HLT4) +# /dev/CMSSW_7_3_0/GRun/V9 (CMSSW_7_3_0) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTGRun" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_3_0/GRun/V7') + tableName = cms.string('/dev/CMSSW_7_3_0/GRun/V9') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2181,16 +2181,16 @@ process.hltEcalDigis = cms.EDProducer( "EcalRawToDigi", tccUnpacking = cms.bool( True ), FedLabel = cms.InputTag( "listfeds" ), - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), srpUnpacking = cms.bool( True ), syncCheck = cms.bool( True ), + feIdCheck = cms.bool( True ), silentMode = cms.untracked.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), + InputLabel = cms.InputTag( "rawDataCollector" ), orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), eventPut = cms.bool( True ), - InputLabel = cms.InputTag( "rawDataCollector" ), + numbTriggerTSamples = cms.int32( 1 ), numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), + orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), DoRegional = cms.bool( False ), feUnpacking = cms.bool( True ), @@ -2311,15 +2311,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -2327,13 +2329,29 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HBHE" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ignorelowest = cms.bool( True ), win_offset = cms.double( 0.0 ), @@ -2341,7 +2359,14 @@ win_gain = cms.double( 1.0 ), tfilterEnvelope = cms.vdouble( 4.0, 12.04, 13.0, 10.56, 23.5, 8.82, 37.0, 7.38, 56.0, 6.3, 81.0, 5.64, 114.5, 5.44, 175.5, 5.38, 350.5, 5.14 ) ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( nominalPedestal = cms.double( 3.0 ), hitMultiplicityThreshold = cms.int32( 17 ), @@ -2353,6 +2378,11 @@ cms.PSet( pulseShapeParameters = cms.vdouble( -1000000.0, 1000000.0, 45.0, 0.1, 1000000.0, 0.0 ) ) ) ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( slopeMax = cms.double( -0.6 ), r1Max = cms.double( 1.0 ), @@ -2386,6 +2416,7 @@ samplesToAdd = cms.int32( 2 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( hflongEthresh = cms.double( 40.0 ), @@ -2398,7 +2429,13 @@ digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 1 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( + HFdigiflagFirstSample = cms.int32( 1 ), + HFdigiflagMinEthreshold = cms.double( 40.0 ), + HFdigiflagSamplesToAdd = cms.int32( 3 ), + HFdigiflagExpectedPeak = cms.int32( 2 ), + HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) + ), hfTimingTrustParameters = cms.PSet( hfTimingTrustLevel2 = cms.int32( 4 ), hfTimingTrustLevel1 = cms.int32( 1 ) @@ -2415,13 +2452,8 @@ long_R = cms.vdouble( 0.98 ), HcalAcceptSeverityLevel = cms.int32( 9 ) ), - digistat = cms.PSet( - HFdigiflagFirstSample = cms.int32( 1 ), - HFdigiflagMinEthreshold = cms.double( 40.0 ), - HFdigiflagSamplesToAdd = cms.int32( 3 ), - HFdigiflagExpectedPeak = cms.int32( 2 ), - HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) - ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( @@ -2439,16 +2471,44 @@ correctForTimeslew = cms.bool( False ), setNoiseFlags = cms.bool( True ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HF" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 2 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) process.hltHoreco = cms.EDProducer( "HcalHitReconstructor", @@ -2460,15 +2520,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -2476,16 +2538,44 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HO" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) process.hltTowerMakerForAll = cms.EDProducer( "CaloTowersCreator", @@ -3339,9 +3429,11 @@ ) process.hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( ), Timing = cms.untracked.bool( False ), @@ -6232,7 +6324,7 @@ L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), L1TechTriggerSeeding = cms.bool( False ) ) -process.hltPreAK8PFHT850TrimR0p1PT0p03Mass50 = cms.EDFilter( "HLTPrescaler", +process.hltPreAK8PFHT700TrimR0p1PT0p03Mass50 = cms.EDFilter( "HLTPrescaler", L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) @@ -7370,6 +7462,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -7395,6 +7488,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -8357,6 +8451,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -8418,6 +8513,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -8618,6 +8714,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -8727,6 +8824,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9073,9 +9171,11 @@ ) process.hltSiPixelDigisReg = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltL2TausForPixelIsolation' ), @@ -15492,6 +15592,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -15599,6 +15700,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -15751,6 +15853,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -15979,6 +16082,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -16858,6 +16962,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17092,6 +17197,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17398,6 +17504,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17599,6 +17706,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17827,6 +17935,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18277,6 +18386,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18668,6 +18778,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18819,6 +18930,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18976,6 +19088,7 @@ pMaxHPDEMF = cms.double( 0.02 ), minRecHitE = cms.double( 1.5 ), hlMaxHPDEMF = cms.double( -9999.0 ), + lRBXRecHitR45Cuts = cms.vdouble( 0.0, 1.0, 0.0, -0.5, 0.0, 0.0, 1.0, -0.5 ), maxCaloTowerIEta = cms.int32( 20 ), pMinEEMF = cms.double( 10.0 ), pMaxRatio = cms.double( 0.85 ), @@ -18984,9 +19097,13 @@ pMaxHighEHitTime = cms.double( 5.0 ), pMaxLowEHitTime = cms.double( 6.0 ), minHighHitE = cms.double( 25.0 ), + minR45HitE = cms.double( 5.0 ), + tRBXRecHitR45Cuts = cms.vdouble( 0.0, 1.0, 0.0, -0.2, 0.0, 0.0, 1.0, -0.2 ), + fillRecHits = cms.bool( True ), lMinZeros = cms.int32( 10 ), lMinRBXHits = cms.int32( 999 ), - fillRecHits = cms.bool( True ), + pMinRBXRechitR45Fraction = cms.double( 0.1 ), + pMinRBXRechitR45EnergyFraction = cms.double( 0.1 ), HcalRecHitFlagsToBeExcluded = cms.vint32( 11, 12, 13, 14, 15 ), calibdigiHFthreshold = cms.double( -999.0 ), minLowHitE = cms.double( 10.0 ), @@ -19013,6 +19130,7 @@ tMinRatio = cms.double( 0.73 ), TS4TS5UpperCut = cms.vdouble( 999.0, 999.0, 999.0, 999.0, 999.0 ), pMinLowEHitTime = cms.double( -6.0 ), + pMinRBXRechitR45Count = cms.int32( 1 ), pMinHPDHits = cms.int32( 10 ), lMinLowEHitTime = cms.double( -9999.0 ), recHitCollName = cms.string( "hltHbhereco" ), @@ -19039,6 +19157,7 @@ minRecHitE = cms.double( 1.5 ), severity = cms.int32( 1 ), minHighHitE = cms.double( 25.0 ), + minR45HitE = cms.double( 5.0 ), numRBXsToConsider = cms.int32( 2 ), minRatio = cms.double( -999.0 ), maxHighEHitTime = cms.double( 9999.0 ), @@ -25885,9 +26004,11 @@ ) process.hltSiPixelDigisRegForBTag = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltSelectorCentralJets20L1FastJeta' ), @@ -30981,6 +31102,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -31194,6 +31316,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -31392,6 +31515,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -31590,6 +31714,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -32303,6 +32428,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -32328,6 +32454,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -32680,6 +32807,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -32705,6 +32833,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -32730,6 +32859,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -33078,6 +33208,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -33348,6 +33479,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -33516,6 +33648,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -33706,6 +33839,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -34364,6 +34498,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -34917,6 +35052,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -35115,6 +35251,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -37706,6 +37843,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -38101,6 +38239,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -38302,6 +38441,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -38688,6 +38828,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -39034,6 +39175,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -39175,6 +39317,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -39921,7 +40064,7 @@ process.HLTriggerFirstPath = cms.Path( process.hltGetConditions + process.hltGetRaw + process.hltBoolFalse ) process.HLT_AK8PFJet360TrimMod_Mass30_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleJet176ORSingleJet200 + process.hltPreAK8PFJet360TrimModMass30 + process.HLTAK8CaloJetsSequence + process.hltAK8SingleCaloJet260 + process.HLTAK8PFJetsSequence + process.hltAK8PFJetsCorrectedMatchedToCaloJets260 + process.hltAK8TrimModJets + process.hltAK8SinglePFJet360TrimModMass30 + process.HLTEndSequence ) -process.HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1HTT150ORHTT175 + process.hltPreAK8PFHT850TrimR0p1PT0p03Mass50 + process.HLTAK8CaloJetsSequence + process.hltAK8HtMht + process.hltAK8Ht600 + process.HLTAK8PFJetsSequence + process.hltAK8PFHT + process.hltAK8PFJetsTrimR0p1PT0p03 + process.hlt1AK8PFJetsTrimR0p1PT0p03Mass50 + process.hltAK8PFHT700 + process.HLTEndSequence ) +process.HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1HTT150ORHTT175 + process.hltPreAK8PFHT700TrimR0p1PT0p03Mass50 + process.HLTAK8CaloJetsSequence + process.hltAK8HtMht + process.hltAK8Ht600 + process.HLTAK8PFJetsSequence + process.hltAK8PFHT + process.hltAK8PFJetsTrimR0p1PT0p03 + process.hlt1AK8PFJetsTrimR0p1PT0p03Mass50 + process.hltAK8PFHT700 + process.HLTEndSequence ) process.HLT_CaloJet500_NoJetID_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleJet200 + process.hltPreCaloJet500NoJetID + process.HLTAK4CaloJetsReconstructionNoIDSequence + process.HLTAK4CaloJetsCorrectionNoIDSequence + process.hltSingleCaloJet500 + process.HLTEndSequence ) process.HLT_Dimuon13_PsiPrime_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMu10MuOpenHighQ + process.hltPreDimuon13PsiPrime + process.hltL1fL1sL1DoubleMu10MuOpenHighQL1Filtered0 + process.HLTL2muonrecoSequence + process.hltL2fL1sL1DoubleMu10MuOpenHighQL1f0L2PreFiltered0 + process.HLTL3muonrecoSequence + process.hltDimuon13PsiPrimeL3Filtered + process.hltDisplacedmumuVtxProducerDimuon13PsiPrime + process.hltDisplacedmumuFilterDimuon13PsiPrime + process.HLTEndSequence ) process.HLT_Dimuon13_Upsilon_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMu10MuOpenHighQ + process.hltPreDimuon13Upsilon + process.hltL1fL1sL1DoubleMu10MuOpenHighQL1Filtered0 + process.HLTL2muonrecoSequence + process.hltL2fL1sL1DoubleMu10MuOpenHighQL1f0L2PreFiltered0 + process.HLTL3muonrecoSequence + process.hltDimuon13UpsilonL3Filtered + process.hltDisplacedmumuVtxProducerDimuon13Upsilon + process.hltDisplacedmumuFilterDimuon13Upsilon + process.HLTEndSequence ) diff --git a/HLTrigger/Configuration/test/OnData_HLT_HIon.py b/HLTrigger/Configuration/test/OnData_HLT_HIon.py index b3678c500ee73..870cae7baadd0 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_HIon.py +++ b/HLTrigger/Configuration/test/OnData_HLT_HIon.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_3_0/HIon/V7 (CMSSW_7_2_3_HLT4) +# /dev/CMSSW_7_3_0/HIon/V9 (CMSSW_7_3_0) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTHIon" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_3_0/HIon/V7') + tableName = cms.string('/dev/CMSSW_7_3_0/HIon/V9') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1920,16 +1920,16 @@ process.hltEcalDigis = cms.EDProducer( "EcalRawToDigi", tccUnpacking = cms.bool( True ), FedLabel = cms.InputTag( "listfeds" ), - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), srpUnpacking = cms.bool( True ), syncCheck = cms.bool( True ), + feIdCheck = cms.bool( True ), silentMode = cms.untracked.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), + InputLabel = cms.InputTag( "rawDataRepacker" ), orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), eventPut = cms.bool( True ), - InputLabel = cms.InputTag( "rawDataRepacker" ), + numbTriggerTSamples = cms.int32( 1 ), numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), + orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), DoRegional = cms.bool( False ), feUnpacking = cms.bool( True ), @@ -2050,15 +2050,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -2066,13 +2068,29 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HBHE" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ignorelowest = cms.bool( True ), win_offset = cms.double( 0.0 ), @@ -2080,7 +2098,14 @@ win_gain = cms.double( 1.0 ), tfilterEnvelope = cms.vdouble( 4.0, 12.04, 13.0, 10.56, 23.5, 8.82, 37.0, 7.38, 56.0, 6.3, 81.0, 5.64, 114.5, 5.44, 175.5, 5.38, 350.5, 5.14 ) ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( nominalPedestal = cms.double( 3.0 ), hitMultiplicityThreshold = cms.int32( 17 ), @@ -2092,6 +2117,11 @@ cms.PSet( pulseShapeParameters = cms.vdouble( -1000000.0, 1000000.0, 45.0, 0.1, 1000000.0, 0.0 ) ) ) ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( slopeMax = cms.double( -0.6 ), r1Max = cms.double( 1.0 ), @@ -2125,6 +2155,7 @@ samplesToAdd = cms.int32( 2 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( hflongEthresh = cms.double( 40.0 ), @@ -2137,7 +2168,13 @@ digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 1 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( + HFdigiflagFirstSample = cms.int32( 1 ), + HFdigiflagMinEthreshold = cms.double( 40.0 ), + HFdigiflagSamplesToAdd = cms.int32( 3 ), + HFdigiflagExpectedPeak = cms.int32( 2 ), + HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) + ), hfTimingTrustParameters = cms.PSet( hfTimingTrustLevel2 = cms.int32( 4 ), hfTimingTrustLevel1 = cms.int32( 1 ) @@ -2154,13 +2191,8 @@ long_R = cms.vdouble( 0.98 ), HcalAcceptSeverityLevel = cms.int32( 9 ) ), - digistat = cms.PSet( - HFdigiflagFirstSample = cms.int32( 1 ), - HFdigiflagMinEthreshold = cms.double( 40.0 ), - HFdigiflagSamplesToAdd = cms.int32( 3 ), - HFdigiflagExpectedPeak = cms.int32( 2 ), - HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) - ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( @@ -2178,16 +2210,44 @@ correctForTimeslew = cms.bool( False ), setNoiseFlags = cms.bool( True ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HF" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 2 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) process.hltHoreco = cms.EDProducer( "HcalHitReconstructor", @@ -2199,15 +2259,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -2215,16 +2277,44 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HO" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) process.hltTowerMakerForAll = cms.EDProducer( "CaloTowersCreator", @@ -2997,9 +3087,11 @@ ) process.hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataRepacker" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( ), Timing = cms.untracked.bool( False ), @@ -3175,6 +3267,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), diff --git a/HLTrigger/Configuration/test/OnData_HLT_PIon.py b/HLTrigger/Configuration/test/OnData_HLT_PIon.py index 75587547886e2..0c9564a62434b 100644 --- a/HLTrigger/Configuration/test/OnData_HLT_PIon.py +++ b/HLTrigger/Configuration/test/OnData_HLT_PIon.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_3_0/PIon/V7 (CMSSW_7_2_3_HLT4) +# /dev/CMSSW_7_3_0/PIon/V9 (CMSSW_7_3_0) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTPIon" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_3_0/PIon/V7') + tableName = cms.string('/dev/CMSSW_7_3_0/PIon/V9') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1920,16 +1920,16 @@ process.hltEcalDigis = cms.EDProducer( "EcalRawToDigi", tccUnpacking = cms.bool( True ), FedLabel = cms.InputTag( "listfeds" ), - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), srpUnpacking = cms.bool( True ), syncCheck = cms.bool( True ), + feIdCheck = cms.bool( True ), silentMode = cms.untracked.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), + InputLabel = cms.InputTag( "rawDataCollector" ), orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), eventPut = cms.bool( True ), - InputLabel = cms.InputTag( "rawDataCollector" ), + numbTriggerTSamples = cms.int32( 1 ), numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), + orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), DoRegional = cms.bool( False ), feUnpacking = cms.bool( True ), @@ -2050,15 +2050,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -2066,13 +2068,29 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HBHE" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ignorelowest = cms.bool( True ), win_offset = cms.double( 0.0 ), @@ -2080,7 +2098,14 @@ win_gain = cms.double( 1.0 ), tfilterEnvelope = cms.vdouble( 4.0, 12.04, 13.0, 10.56, 23.5, 8.82, 37.0, 7.38, 56.0, 6.3, 81.0, 5.64, 114.5, 5.44, 175.5, 5.38, 350.5, 5.14 ) ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( nominalPedestal = cms.double( 3.0 ), hitMultiplicityThreshold = cms.int32( 17 ), @@ -2092,6 +2117,11 @@ cms.PSet( pulseShapeParameters = cms.vdouble( -1000000.0, 1000000.0, 45.0, 0.1, 1000000.0, 0.0 ) ) ) ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( slopeMax = cms.double( -0.6 ), r1Max = cms.double( 1.0 ), @@ -2125,6 +2155,7 @@ samplesToAdd = cms.int32( 2 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( hflongEthresh = cms.double( 40.0 ), @@ -2137,7 +2168,13 @@ digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 1 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( + HFdigiflagFirstSample = cms.int32( 1 ), + HFdigiflagMinEthreshold = cms.double( 40.0 ), + HFdigiflagSamplesToAdd = cms.int32( 3 ), + HFdigiflagExpectedPeak = cms.int32( 2 ), + HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) + ), hfTimingTrustParameters = cms.PSet( hfTimingTrustLevel2 = cms.int32( 4 ), hfTimingTrustLevel1 = cms.int32( 1 ) @@ -2154,13 +2191,8 @@ long_R = cms.vdouble( 0.98 ), HcalAcceptSeverityLevel = cms.int32( 9 ) ), - digistat = cms.PSet( - HFdigiflagFirstSample = cms.int32( 1 ), - HFdigiflagMinEthreshold = cms.double( 40.0 ), - HFdigiflagSamplesToAdd = cms.int32( 3 ), - HFdigiflagExpectedPeak = cms.int32( 2 ), - HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) - ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( @@ -2178,16 +2210,44 @@ correctForTimeslew = cms.bool( False ), setNoiseFlags = cms.bool( True ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HF" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 2 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) process.hltHoreco = cms.EDProducer( "HcalHitReconstructor", @@ -2199,15 +2259,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -2215,16 +2277,44 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HO" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) process.hltTowerMakerForAll = cms.EDProducer( "CaloTowersCreator", @@ -2997,9 +3087,11 @@ ) process.hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( ), Timing = cms.untracked.bool( False ), @@ -3175,6 +3267,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), diff --git a/HLTrigger/Configuration/test/OnMc_HLT_FULL.py b/HLTrigger/Configuration/test/OnMc_HLT_FULL.py index 08e86950171e1..089073ff9de49 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_FULL.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_FULL.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_3_0/HLT/V17 (CMSSW_7_2_3_HLT4) +# /dev/CMSSW_7_3_0/HLT/V19 (CMSSW_7_3_0) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTFULL" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_3_0/HLT/V17') + tableName = cms.string('/dev/CMSSW_7_3_0/HLT/V19') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2222,16 +2222,16 @@ process.hltEcalDigis = cms.EDProducer( "EcalRawToDigi", tccUnpacking = cms.bool( True ), FedLabel = cms.InputTag( "listfeds" ), - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), srpUnpacking = cms.bool( True ), syncCheck = cms.bool( True ), + feIdCheck = cms.bool( True ), silentMode = cms.untracked.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), + InputLabel = cms.InputTag( "rawDataCollector" ), orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), eventPut = cms.bool( True ), - InputLabel = cms.InputTag( "rawDataCollector" ), + numbTriggerTSamples = cms.int32( 1 ), numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), + orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), DoRegional = cms.bool( False ), feUnpacking = cms.bool( True ), @@ -2352,15 +2352,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -2368,13 +2370,29 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HBHE" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ignorelowest = cms.bool( True ), win_offset = cms.double( 0.0 ), @@ -2382,7 +2400,14 @@ win_gain = cms.double( 1.0 ), tfilterEnvelope = cms.vdouble( 4.0, 12.04, 13.0, 10.56, 23.5, 8.82, 37.0, 7.38, 56.0, 6.3, 81.0, 5.64, 114.5, 5.44, 175.5, 5.38, 350.5, 5.14 ) ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( nominalPedestal = cms.double( 3.0 ), hitMultiplicityThreshold = cms.int32( 17 ), @@ -2394,6 +2419,11 @@ cms.PSet( pulseShapeParameters = cms.vdouble( -1000000.0, 1000000.0, 45.0, 0.1, 1000000.0, 0.0 ) ) ) ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( slopeMax = cms.double( -0.6 ), r1Max = cms.double( 1.0 ), @@ -2427,6 +2457,7 @@ samplesToAdd = cms.int32( 2 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( hflongEthresh = cms.double( 40.0 ), @@ -2439,7 +2470,13 @@ digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 1 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( + HFdigiflagFirstSample = cms.int32( 1 ), + HFdigiflagMinEthreshold = cms.double( 40.0 ), + HFdigiflagSamplesToAdd = cms.int32( 3 ), + HFdigiflagExpectedPeak = cms.int32( 2 ), + HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) + ), hfTimingTrustParameters = cms.PSet( hfTimingTrustLevel2 = cms.int32( 4 ), hfTimingTrustLevel1 = cms.int32( 1 ) @@ -2456,13 +2493,8 @@ long_R = cms.vdouble( 0.98 ), HcalAcceptSeverityLevel = cms.int32( 9 ) ), - digistat = cms.PSet( - HFdigiflagFirstSample = cms.int32( 1 ), - HFdigiflagMinEthreshold = cms.double( 40.0 ), - HFdigiflagSamplesToAdd = cms.int32( 3 ), - HFdigiflagExpectedPeak = cms.int32( 2 ), - HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) - ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( @@ -2480,16 +2512,44 @@ correctForTimeslew = cms.bool( False ), setNoiseFlags = cms.bool( True ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HF" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 2 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) process.hltHoreco = cms.EDProducer( "HcalHitReconstructor", @@ -2501,15 +2561,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -2517,16 +2579,44 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HO" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) process.hltTowerMakerForAll = cms.EDProducer( "CaloTowersCreator", @@ -3380,9 +3470,11 @@ ) process.hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( ), Timing = cms.untracked.bool( False ), @@ -6273,7 +6365,7 @@ L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), L1TechTriggerSeeding = cms.bool( False ) ) -process.hltPreAK8PFHT850TrimR0p1PT0p03Mass50 = cms.EDFilter( "HLTPrescaler", +process.hltPreAK8PFHT700TrimR0p1PT0p03Mass50 = cms.EDFilter( "HLTPrescaler", L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) @@ -6493,9 +6585,11 @@ ) process.hltSiPixelDigisRegForBTag = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltSelectorCentralJets20L1FastJeta' ), @@ -8478,6 +8572,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -8503,6 +8598,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9465,6 +9561,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9526,6 +9623,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9726,6 +9824,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9835,6 +9934,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -10181,9 +10281,11 @@ ) process.hltSiPixelDigisReg = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltL2TausForPixelIsolation' ), @@ -17318,6 +17420,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17343,6 +17446,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17368,6 +17472,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17750,6 +17855,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17775,6 +17881,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18021,6 +18128,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18128,6 +18236,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18280,6 +18389,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18508,6 +18618,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -19063,6 +19174,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -19088,6 +19200,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -19343,6 +19456,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -19577,6 +19691,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -19883,6 +19998,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -20084,6 +20200,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -20312,6 +20429,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -20819,6 +20937,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -21201,6 +21320,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -21352,6 +21472,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -21546,6 +21667,7 @@ pMaxHPDEMF = cms.double( 0.02 ), minRecHitE = cms.double( 1.5 ), hlMaxHPDEMF = cms.double( -9999.0 ), + lRBXRecHitR45Cuts = cms.vdouble( 0.0, 1.0, 0.0, -0.5, 0.0, 0.0, 1.0, -0.5 ), maxCaloTowerIEta = cms.int32( 20 ), pMinEEMF = cms.double( 10.0 ), pMaxRatio = cms.double( 0.85 ), @@ -21554,9 +21676,13 @@ pMaxHighEHitTime = cms.double( 5.0 ), pMaxLowEHitTime = cms.double( 6.0 ), minHighHitE = cms.double( 25.0 ), + minR45HitE = cms.double( 5.0 ), + tRBXRecHitR45Cuts = cms.vdouble( 0.0, 1.0, 0.0, -0.2, 0.0, 0.0, 1.0, -0.2 ), + fillRecHits = cms.bool( True ), lMinZeros = cms.int32( 10 ), lMinRBXHits = cms.int32( 999 ), - fillRecHits = cms.bool( True ), + pMinRBXRechitR45Fraction = cms.double( 0.1 ), + pMinRBXRechitR45EnergyFraction = cms.double( 0.1 ), HcalRecHitFlagsToBeExcluded = cms.vint32( 11, 12, 13, 14, 15 ), calibdigiHFthreshold = cms.double( -999.0 ), minLowHitE = cms.double( 10.0 ), @@ -21583,6 +21709,7 @@ tMinRatio = cms.double( 0.73 ), TS4TS5UpperCut = cms.vdouble( 999.0, 999.0, 999.0, 999.0, 999.0 ), pMinLowEHitTime = cms.double( -6.0 ), + pMinRBXRechitR45Count = cms.int32( 1 ), pMinHPDHits = cms.int32( 10 ), lMinLowEHitTime = cms.double( -9999.0 ), recHitCollName = cms.string( "hltHbhereco" ), @@ -21609,6 +21736,7 @@ minRecHitE = cms.double( 1.5 ), severity = cms.int32( 1 ), minHighHitE = cms.double( 25.0 ), + minR45HitE = cms.double( 5.0 ), numRBXsToConsider = cms.int32( 2 ), minRatio = cms.double( -999.0 ), maxHighEHitTime = cms.double( 9999.0 ), @@ -28052,6 +28180,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -29027,6 +29156,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -34578,6 +34708,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -34791,6 +34922,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -34989,6 +35121,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -35187,6 +35320,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -35900,6 +36034,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -35925,6 +36060,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -36277,6 +36413,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -36302,6 +36439,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -36327,6 +36465,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -36675,6 +36814,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -36933,6 +37073,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -37101,6 +37242,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -37291,6 +37433,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -37949,6 +38092,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -38502,6 +38646,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -38700,6 +38845,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -41316,6 +41462,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -41711,6 +41858,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -41912,6 +42060,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -42298,6 +42447,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -42644,6 +42794,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -42785,6 +42936,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -43810,7 +43962,7 @@ process.HLTriggerFirstPath = cms.Path( process.hltGetConditions + process.hltGetRaw + process.hltBoolFalse ) process.HLT_AK8PFJet360TrimMod_Mass30_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleJet176ORSingleJet200 + process.hltPreAK8PFJet360TrimModMass30 + process.HLTAK8CaloJetsSequence + process.hltAK8SingleCaloJet260 + process.HLTAK8PFJetsSequence + process.hltAK8PFJetsCorrectedMatchedToCaloJets260 + process.hltAK8TrimModJets + process.hltAK8SinglePFJet360TrimModMass30 + process.HLTEndSequence ) -process.HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1HTT150ORHTT175 + process.hltPreAK8PFHT850TrimR0p1PT0p03Mass50 + process.HLTAK8CaloJetsSequence + process.hltAK8HtMht + process.hltAK8Ht600 + process.HLTAK8PFJetsSequence + process.hltAK8PFHT + process.hltAK8PFJetsTrimR0p1PT0p03 + process.hlt1AK8PFJetsTrimR0p1PT0p03Mass50 + process.hltAK8PFHT700 + process.HLTEndSequence ) +process.HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1HTT150ORHTT175 + process.hltPreAK8PFHT700TrimR0p1PT0p03Mass50 + process.HLTAK8CaloJetsSequence + process.hltAK8HtMht + process.hltAK8Ht600 + process.HLTAK8PFJetsSequence + process.hltAK8PFHT + process.hltAK8PFJetsTrimR0p1PT0p03 + process.hlt1AK8PFJetsTrimR0p1PT0p03Mass50 + process.hltAK8PFHT700 + process.HLTEndSequence ) process.HLT_BTagCSV07_v1 = cms.Path( process.HLTBeginSequence + process.hltPreBTagCSV07 + process.HLTAK4CaloJetsSequence + process.HLTFastPrimaryVertexSequence + process.hltFastPVPixelVertexSelector + process.HLTBtagCSVSequenceL3 + process.hltBLifetimeL3FilterCSV + process.HLTEndSequence ) process.HLT_CaloJet260_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleJet200 + process.hltPreCaloJet260 + process.HLTAK4CaloJetsSequence + process.hltSingleCaloJet260 + process.HLTEndSequence ) process.HLT_CaloJet500_NoJetID_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleJet200 + process.hltPreCaloJet500NoJetID + process.HLTAK4CaloJetsReconstructionNoIDSequence + process.HLTAK4CaloJetsCorrectionNoIDSequence + process.hltSingleCaloJet500 + process.HLTEndSequence ) diff --git a/HLTrigger/Configuration/test/OnMc_HLT_Fake.py b/HLTrigger/Configuration/test/OnMc_HLT_Fake.py index db8259a110a77..c2d15c900096a 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_Fake.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_Fake.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_3_0/Fake/V3 (CMSSW_7_2_3_HLT4) +# /dev/CMSSW_7_3_0/Fake/V4 (CMSSW_7_3_0) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTFake" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_3_0/Fake/V3') + tableName = cms.string('/dev/CMSSW_7_3_0/Fake/V4') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2774,9 +2774,11 @@ ) process.hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( ), Timing = cms.untracked.bool( False ), @@ -4592,16 +4594,16 @@ process.hltEcalDigis = cms.EDProducer( "EcalRawToDigi", tccUnpacking = cms.bool( True ), FedLabel = cms.InputTag( "listfeds" ), - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), srpUnpacking = cms.bool( True ), syncCheck = cms.bool( True ), + feIdCheck = cms.bool( True ), silentMode = cms.untracked.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), + InputLabel = cms.InputTag( "rawDataCollector" ), orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), eventPut = cms.bool( True ), - InputLabel = cms.InputTag( "rawDataCollector" ), + numbTriggerTSamples = cms.int32( 1 ), numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), + orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), DoRegional = cms.bool( False ), feUnpacking = cms.bool( True ), @@ -4735,15 +4737,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -4751,13 +4755,29 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HBHE" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ignorelowest = cms.bool( True ), win_offset = cms.double( 0.0 ), @@ -4765,7 +4785,14 @@ win_gain = cms.double( 1.0 ), tfilterEnvelope = cms.vdouble( 4.0, 12.04, 13.0, 10.56, 23.5, 8.82, 37.0, 7.38, 56.0, 6.3, 81.0, 5.64, 114.5, 5.44, 175.5, 5.38, 350.5, 5.14 ) ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( nominalPedestal = cms.double( 3.0 ), hitMultiplicityThreshold = cms.int32( 17 ), @@ -4777,6 +4804,11 @@ cms.PSet( pulseShapeParameters = cms.vdouble( -1000000.0, 1000000.0, 45.0, 0.1, 1000000.0, 0.0 ) ) ) ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( slopeMax = cms.double( -0.6 ), r1Max = cms.double( 1.0 ), @@ -4810,6 +4842,7 @@ samplesToAdd = cms.int32( 2 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( hflongEthresh = cms.double( 40.0 ), @@ -4822,7 +4855,13 @@ digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 1 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( + HFdigiflagFirstSample = cms.int32( 1 ), + HFdigiflagMinEthreshold = cms.double( 40.0 ), + HFdigiflagSamplesToAdd = cms.int32( 3 ), + HFdigiflagExpectedPeak = cms.int32( 2 ), + HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) + ), hfTimingTrustParameters = cms.PSet( hfTimingTrustLevel2 = cms.int32( 4 ), hfTimingTrustLevel1 = cms.int32( 1 ) @@ -4839,13 +4878,8 @@ long_R = cms.vdouble( 0.98 ), HcalAcceptSeverityLevel = cms.int32( 9 ) ), - digistat = cms.PSet( - HFdigiflagFirstSample = cms.int32( 1 ), - HFdigiflagMinEthreshold = cms.double( 40.0 ), - HFdigiflagSamplesToAdd = cms.int32( 3 ), - HFdigiflagExpectedPeak = cms.int32( 2 ), - HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) - ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( @@ -4863,16 +4897,44 @@ correctForTimeslew = cms.bool( False ), setNoiseFlags = cms.bool( True ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HF" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 2 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) process.hltHoreco = cms.EDProducer( "HcalHitReconstructor", @@ -4884,15 +4946,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -4900,16 +4964,44 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HO" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) process.hltTowerMakerForAll = cms.EDProducer( "CaloTowersCreator", @@ -13090,6 +13182,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -14080,6 +14173,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -14105,6 +14199,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -14315,6 +14410,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -14740,6 +14836,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -19887,6 +19984,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -20635,9 +20733,11 @@ ) process.hltSiPixelDigisReg = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltL2TausForPixelIsolation' ), @@ -22797,6 +22897,7 @@ pMaxHPDEMF = cms.double( 0.02 ), minRecHitE = cms.double( 1.5 ), hlMaxHPDEMF = cms.double( -9999.0 ), + lRBXRecHitR45Cuts = cms.vdouble( 0.0, 1.0, 0.0, -0.5, 0.0, 0.0, 1.0, -0.5 ), maxCaloTowerIEta = cms.int32( 20 ), pMinEEMF = cms.double( 10.0 ), pMaxRatio = cms.double( 0.85 ), @@ -22805,9 +22906,13 @@ pMaxHighEHitTime = cms.double( 5.0 ), pMaxLowEHitTime = cms.double( 6.0 ), minHighHitE = cms.double( 25.0 ), + minR45HitE = cms.double( 5.0 ), + tRBXRecHitR45Cuts = cms.vdouble( 0.0, 1.0, 0.0, -0.2, 0.0, 0.0, 1.0, -0.2 ), + fillRecHits = cms.bool( True ), lMinZeros = cms.int32( 10 ), lMinRBXHits = cms.int32( 999 ), - fillRecHits = cms.bool( True ), + pMinRBXRechitR45Fraction = cms.double( 0.1 ), + pMinRBXRechitR45EnergyFraction = cms.double( 0.1 ), HcalRecHitFlagsToBeExcluded = cms.vint32( 11, 12, 13, 14, 15 ), calibdigiHFthreshold = cms.double( -999.0 ), minLowHitE = cms.double( 10.0 ), @@ -22834,6 +22939,7 @@ tMinRatio = cms.double( 0.73 ), TS4TS5UpperCut = cms.vdouble( 999.0, 999.0, 999.0, 999.0, 999.0 ), pMinLowEHitTime = cms.double( -6.0 ), + pMinRBXRechitR45Count = cms.int32( 1 ), pMinHPDHits = cms.int32( 10 ), lMinLowEHitTime = cms.double( -9999.0 ), recHitCollName = cms.string( "hltHbhereco" ), @@ -22860,6 +22966,7 @@ minRecHitE = cms.double( 1.5 ), severity = cms.int32( 1 ), minHighHitE = cms.double( 25.0 ), + minR45HitE = cms.double( 5.0 ), numRBXsToConsider = cms.int32( 2 ), minRatio = cms.double( -999.0 ), maxHighEHitTime = cms.double( 9999.0 ), @@ -23146,9 +23253,11 @@ ) process.hltSiPixelDigisRegForBTag = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltSelector4CentralJetsL1FastJet' ), @@ -25342,6 +25451,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -25604,6 +25714,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -25629,6 +25740,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -25967,6 +26079,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -25992,6 +26105,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -26017,6 +26131,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -26377,6 +26492,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -26629,6 +26745,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -27651,6 +27768,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -27676,6 +27794,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -27751,6 +27870,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -28071,6 +28191,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -28178,6 +28299,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -28303,6 +28425,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -28729,9 +28852,11 @@ ) process.hltSiPixelDigisRegForNoPU = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltSelectorJets20L1FastJetForNoPU' ), diff --git a/HLTrigger/Configuration/test/OnMc_HLT_GRun.py b/HLTrigger/Configuration/test/OnMc_HLT_GRun.py index 96ef9da37de2d..fbeb69a1ccd5d 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_GRun.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_GRun.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_3_0/GRun/V7 (CMSSW_7_2_3_HLT4) +# /dev/CMSSW_7_3_0/GRun/V9 (CMSSW_7_3_0) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTGRun" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_3_0/GRun/V7') + tableName = cms.string('/dev/CMSSW_7_3_0/GRun/V9') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -2181,16 +2181,16 @@ process.hltEcalDigis = cms.EDProducer( "EcalRawToDigi", tccUnpacking = cms.bool( True ), FedLabel = cms.InputTag( "listfeds" ), - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), srpUnpacking = cms.bool( True ), syncCheck = cms.bool( True ), + feIdCheck = cms.bool( True ), silentMode = cms.untracked.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), + InputLabel = cms.InputTag( "rawDataCollector" ), orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), eventPut = cms.bool( True ), - InputLabel = cms.InputTag( "rawDataCollector" ), + numbTriggerTSamples = cms.int32( 1 ), numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), + orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), DoRegional = cms.bool( False ), feUnpacking = cms.bool( True ), @@ -2311,15 +2311,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -2327,13 +2329,29 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HBHE" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ignorelowest = cms.bool( True ), win_offset = cms.double( 0.0 ), @@ -2341,7 +2359,14 @@ win_gain = cms.double( 1.0 ), tfilterEnvelope = cms.vdouble( 4.0, 12.04, 13.0, 10.56, 23.5, 8.82, 37.0, 7.38, 56.0, 6.3, 81.0, 5.64, 114.5, 5.44, 175.5, 5.38, 350.5, 5.14 ) ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( nominalPedestal = cms.double( 3.0 ), hitMultiplicityThreshold = cms.int32( 17 ), @@ -2353,6 +2378,11 @@ cms.PSet( pulseShapeParameters = cms.vdouble( -1000000.0, 1000000.0, 45.0, 0.1, 1000000.0, 0.0 ) ) ) ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( slopeMax = cms.double( -0.6 ), r1Max = cms.double( 1.0 ), @@ -2386,6 +2416,7 @@ samplesToAdd = cms.int32( 2 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( hflongEthresh = cms.double( 40.0 ), @@ -2398,7 +2429,13 @@ digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 1 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( + HFdigiflagFirstSample = cms.int32( 1 ), + HFdigiflagMinEthreshold = cms.double( 40.0 ), + HFdigiflagSamplesToAdd = cms.int32( 3 ), + HFdigiflagExpectedPeak = cms.int32( 2 ), + HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) + ), hfTimingTrustParameters = cms.PSet( hfTimingTrustLevel2 = cms.int32( 4 ), hfTimingTrustLevel1 = cms.int32( 1 ) @@ -2415,13 +2452,8 @@ long_R = cms.vdouble( 0.98 ), HcalAcceptSeverityLevel = cms.int32( 9 ) ), - digistat = cms.PSet( - HFdigiflagFirstSample = cms.int32( 1 ), - HFdigiflagMinEthreshold = cms.double( 40.0 ), - HFdigiflagSamplesToAdd = cms.int32( 3 ), - HFdigiflagExpectedPeak = cms.int32( 2 ), - HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) - ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( @@ -2439,16 +2471,44 @@ correctForTimeslew = cms.bool( False ), setNoiseFlags = cms.bool( True ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HF" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 2 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) process.hltHoreco = cms.EDProducer( "HcalHitReconstructor", @@ -2460,15 +2520,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -2476,16 +2538,44 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HO" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) process.hltTowerMakerForAll = cms.EDProducer( "CaloTowersCreator", @@ -3339,9 +3429,11 @@ ) process.hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( ), Timing = cms.untracked.bool( False ), @@ -6232,7 +6324,7 @@ L1GtObjectMapTag = cms.InputTag( "hltL1GtObjectMap" ), L1TechTriggerSeeding = cms.bool( False ) ) -process.hltPreAK8PFHT850TrimR0p1PT0p03Mass50 = cms.EDFilter( "HLTPrescaler", +process.hltPreAK8PFHT700TrimR0p1PT0p03Mass50 = cms.EDFilter( "HLTPrescaler", L1GtReadoutRecordTag = cms.InputTag( "hltGtDigis" ), offset = cms.uint32( 0 ) ) @@ -7370,6 +7462,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -7395,6 +7488,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -8357,6 +8451,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -8418,6 +8513,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -8618,6 +8714,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -8727,6 +8824,7 @@ s2_threshold = cms.double( 20.6 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -9073,9 +9171,11 @@ ) process.hltSiPixelDigisReg = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltL2TausForPixelIsolation' ), @@ -15492,6 +15592,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -15599,6 +15700,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -15751,6 +15853,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -15979,6 +16082,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -16858,6 +16962,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17092,6 +17197,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17398,6 +17504,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17599,6 +17706,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -17827,6 +17935,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18277,6 +18386,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18668,6 +18778,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18819,6 +18930,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -18976,6 +19088,7 @@ pMaxHPDEMF = cms.double( 0.02 ), minRecHitE = cms.double( 1.5 ), hlMaxHPDEMF = cms.double( -9999.0 ), + lRBXRecHitR45Cuts = cms.vdouble( 0.0, 1.0, 0.0, -0.5, 0.0, 0.0, 1.0, -0.5 ), maxCaloTowerIEta = cms.int32( 20 ), pMinEEMF = cms.double( 10.0 ), pMaxRatio = cms.double( 0.85 ), @@ -18984,9 +19097,13 @@ pMaxHighEHitTime = cms.double( 5.0 ), pMaxLowEHitTime = cms.double( 6.0 ), minHighHitE = cms.double( 25.0 ), + minR45HitE = cms.double( 5.0 ), + tRBXRecHitR45Cuts = cms.vdouble( 0.0, 1.0, 0.0, -0.2, 0.0, 0.0, 1.0, -0.2 ), + fillRecHits = cms.bool( True ), lMinZeros = cms.int32( 10 ), lMinRBXHits = cms.int32( 999 ), - fillRecHits = cms.bool( True ), + pMinRBXRechitR45Fraction = cms.double( 0.1 ), + pMinRBXRechitR45EnergyFraction = cms.double( 0.1 ), HcalRecHitFlagsToBeExcluded = cms.vint32( 11, 12, 13, 14, 15 ), calibdigiHFthreshold = cms.double( -999.0 ), minLowHitE = cms.double( 10.0 ), @@ -19013,6 +19130,7 @@ tMinRatio = cms.double( 0.73 ), TS4TS5UpperCut = cms.vdouble( 999.0, 999.0, 999.0, 999.0, 999.0 ), pMinLowEHitTime = cms.double( -6.0 ), + pMinRBXRechitR45Count = cms.int32( 1 ), pMinHPDHits = cms.int32( 10 ), lMinLowEHitTime = cms.double( -9999.0 ), recHitCollName = cms.string( "hltHbhereco" ), @@ -19039,6 +19157,7 @@ minRecHitE = cms.double( 1.5 ), severity = cms.int32( 1 ), minHighHitE = cms.double( 25.0 ), + minR45HitE = cms.double( 5.0 ), numRBXsToConsider = cms.int32( 2 ), minRatio = cms.double( -999.0 ), maxHighEHitTime = cms.double( 9999.0 ), @@ -25885,9 +26004,11 @@ ) process.hltSiPixelDigisRegForBTag = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( inputs = cms.VInputTag( 'hltSelectorCentralJets20L1FastJeta' ), @@ -30981,6 +31102,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -31194,6 +31316,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -31392,6 +31515,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -31590,6 +31714,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -32303,6 +32428,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -32328,6 +32454,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -32680,6 +32807,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -32705,6 +32833,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -32730,6 +32859,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -33078,6 +33208,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -33348,6 +33479,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -33516,6 +33648,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -33706,6 +33839,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -34364,6 +34498,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -34917,6 +35052,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -35115,6 +35251,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -37706,6 +37843,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -38101,6 +38239,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -38302,6 +38441,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -38688,6 +38828,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -39034,6 +39175,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -39175,6 +39317,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), @@ -39921,7 +40064,7 @@ process.HLTriggerFirstPath = cms.Path( process.hltGetConditions + process.hltGetRaw + process.hltBoolFalse ) process.HLT_AK8PFJet360TrimMod_Mass30_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleJet176ORSingleJet200 + process.hltPreAK8PFJet360TrimModMass30 + process.HLTAK8CaloJetsSequence + process.hltAK8SingleCaloJet260 + process.HLTAK8PFJetsSequence + process.hltAK8PFJetsCorrectedMatchedToCaloJets260 + process.hltAK8TrimModJets + process.hltAK8SinglePFJet360TrimModMass30 + process.HLTEndSequence ) -process.HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1HTT150ORHTT175 + process.hltPreAK8PFHT850TrimR0p1PT0p03Mass50 + process.HLTAK8CaloJetsSequence + process.hltAK8HtMht + process.hltAK8Ht600 + process.HLTAK8PFJetsSequence + process.hltAK8PFHT + process.hltAK8PFJetsTrimR0p1PT0p03 + process.hlt1AK8PFJetsTrimR0p1PT0p03Mass50 + process.hltAK8PFHT700 + process.HLTEndSequence ) +process.HLT_AK8PFHT700_TrimR0p1PT0p03Mass50_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1HTT150ORHTT175 + process.hltPreAK8PFHT700TrimR0p1PT0p03Mass50 + process.HLTAK8CaloJetsSequence + process.hltAK8HtMht + process.hltAK8Ht600 + process.HLTAK8PFJetsSequence + process.hltAK8PFHT + process.hltAK8PFJetsTrimR0p1PT0p03 + process.hlt1AK8PFJetsTrimR0p1PT0p03Mass50 + process.hltAK8PFHT700 + process.HLTEndSequence ) process.HLT_CaloJet500_NoJetID_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1SingleJet200 + process.hltPreCaloJet500NoJetID + process.HLTAK4CaloJetsReconstructionNoIDSequence + process.HLTAK4CaloJetsCorrectionNoIDSequence + process.hltSingleCaloJet500 + process.HLTEndSequence ) process.HLT_Dimuon13_PsiPrime_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMu10MuOpenHighQ + process.hltPreDimuon13PsiPrime + process.hltL1fL1sL1DoubleMu10MuOpenHighQL1Filtered0 + process.HLTL2muonrecoSequence + process.hltL2fL1sL1DoubleMu10MuOpenHighQL1f0L2PreFiltered0 + process.HLTL3muonrecoSequence + process.hltDimuon13PsiPrimeL3Filtered + process.hltDisplacedmumuVtxProducerDimuon13PsiPrime + process.hltDisplacedmumuFilterDimuon13PsiPrime + process.HLTEndSequence ) process.HLT_Dimuon13_Upsilon_v1 = cms.Path( process.HLTBeginSequence + process.hltL1sL1DoubleMu10MuOpenHighQ + process.hltPreDimuon13Upsilon + process.hltL1fL1sL1DoubleMu10MuOpenHighQL1Filtered0 + process.HLTL2muonrecoSequence + process.hltL2fL1sL1DoubleMu10MuOpenHighQL1f0L2PreFiltered0 + process.HLTL3muonrecoSequence + process.hltDimuon13UpsilonL3Filtered + process.hltDisplacedmumuVtxProducerDimuon13Upsilon + process.hltDisplacedmumuFilterDimuon13Upsilon + process.HLTEndSequence ) diff --git a/HLTrigger/Configuration/test/OnMc_HLT_HIon.py b/HLTrigger/Configuration/test/OnMc_HLT_HIon.py index c8c2d6ddfeb17..7f1c13aba1c4f 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_HIon.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_HIon.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_3_0/HIon/V7 (CMSSW_7_2_3_HLT4) +# /dev/CMSSW_7_3_0/HIon/V9 (CMSSW_7_3_0) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTHIon" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_3_0/HIon/V7') + tableName = cms.string('/dev/CMSSW_7_3_0/HIon/V9') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1920,16 +1920,16 @@ process.hltEcalDigis = cms.EDProducer( "EcalRawToDigi", tccUnpacking = cms.bool( True ), FedLabel = cms.InputTag( "listfeds" ), - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), srpUnpacking = cms.bool( True ), syncCheck = cms.bool( True ), + feIdCheck = cms.bool( True ), silentMode = cms.untracked.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), + InputLabel = cms.InputTag( "rawDataCollector" ), orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), eventPut = cms.bool( True ), - InputLabel = cms.InputTag( "rawDataCollector" ), + numbTriggerTSamples = cms.int32( 1 ), numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), + orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), DoRegional = cms.bool( False ), feUnpacking = cms.bool( True ), @@ -2050,15 +2050,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -2066,13 +2068,29 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HBHE" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ignorelowest = cms.bool( True ), win_offset = cms.double( 0.0 ), @@ -2080,7 +2098,14 @@ win_gain = cms.double( 1.0 ), tfilterEnvelope = cms.vdouble( 4.0, 12.04, 13.0, 10.56, 23.5, 8.82, 37.0, 7.38, 56.0, 6.3, 81.0, 5.64, 114.5, 5.44, 175.5, 5.38, 350.5, 5.14 ) ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( nominalPedestal = cms.double( 3.0 ), hitMultiplicityThreshold = cms.int32( 17 ), @@ -2092,6 +2117,11 @@ cms.PSet( pulseShapeParameters = cms.vdouble( -1000000.0, 1000000.0, 45.0, 0.1, 1000000.0, 0.0 ) ) ) ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( slopeMax = cms.double( -0.6 ), r1Max = cms.double( 1.0 ), @@ -2125,6 +2155,7 @@ samplesToAdd = cms.int32( 2 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( hflongEthresh = cms.double( 40.0 ), @@ -2137,7 +2168,13 @@ digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 1 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( + HFdigiflagFirstSample = cms.int32( 1 ), + HFdigiflagMinEthreshold = cms.double( 40.0 ), + HFdigiflagSamplesToAdd = cms.int32( 3 ), + HFdigiflagExpectedPeak = cms.int32( 2 ), + HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) + ), hfTimingTrustParameters = cms.PSet( hfTimingTrustLevel2 = cms.int32( 4 ), hfTimingTrustLevel1 = cms.int32( 1 ) @@ -2154,13 +2191,8 @@ long_R = cms.vdouble( 0.98 ), HcalAcceptSeverityLevel = cms.int32( 9 ) ), - digistat = cms.PSet( - HFdigiflagFirstSample = cms.int32( 1 ), - HFdigiflagMinEthreshold = cms.double( 40.0 ), - HFdigiflagSamplesToAdd = cms.int32( 3 ), - HFdigiflagExpectedPeak = cms.int32( 2 ), - HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) - ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( @@ -2178,16 +2210,44 @@ correctForTimeslew = cms.bool( False ), setNoiseFlags = cms.bool( True ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HF" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 2 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) process.hltHoreco = cms.EDProducer( "HcalHitReconstructor", @@ -2199,15 +2259,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -2215,16 +2277,44 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HO" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) process.hltTowerMakerForAll = cms.EDProducer( "CaloTowersCreator", @@ -2997,9 +3087,11 @@ ) process.hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( ), Timing = cms.untracked.bool( False ), @@ -3175,6 +3267,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), diff --git a/HLTrigger/Configuration/test/OnMc_HLT_PIon.py b/HLTrigger/Configuration/test/OnMc_HLT_PIon.py index d0c8b55844be0..efbdae8ca97a1 100644 --- a/HLTrigger/Configuration/test/OnMc_HLT_PIon.py +++ b/HLTrigger/Configuration/test/OnMc_HLT_PIon.py @@ -1,11 +1,11 @@ -# /dev/CMSSW_7_3_0/PIon/V7 (CMSSW_7_2_3_HLT4) +# /dev/CMSSW_7_3_0/PIon/V9 (CMSSW_7_3_0) import FWCore.ParameterSet.Config as cms process = cms.Process( "HLTPIon" ) process.HLTConfigVersion = cms.PSet( - tableName = cms.string('/dev/CMSSW_7_3_0/PIon/V7') + tableName = cms.string('/dev/CMSSW_7_3_0/PIon/V9') ) process.HLTIter4PSetTrajectoryFilterIT = cms.PSet( @@ -1920,16 +1920,16 @@ process.hltEcalDigis = cms.EDProducer( "EcalRawToDigi", tccUnpacking = cms.bool( True ), FedLabel = cms.InputTag( "listfeds" ), - orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), srpUnpacking = cms.bool( True ), syncCheck = cms.bool( True ), + feIdCheck = cms.bool( True ), silentMode = cms.untracked.bool( True ), - numbTriggerTSamples = cms.int32( 1 ), + InputLabel = cms.InputTag( "rawDataCollector" ), orderedFedList = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), eventPut = cms.bool( True ), - InputLabel = cms.InputTag( "rawDataCollector" ), + numbTriggerTSamples = cms.int32( 1 ), numbXtalTSamples = cms.int32( 10 ), - feIdCheck = cms.bool( True ), + orderedDCCIdList = cms.vint32( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54 ), FEDs = cms.vint32( 601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624, 625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640, 641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654 ), DoRegional = cms.bool( False ), feUnpacking = cms.bool( True ), @@ -2050,15 +2050,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -2066,13 +2068,29 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HBHE" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ignorelowest = cms.bool( True ), win_offset = cms.double( 0.0 ), @@ -2080,7 +2098,14 @@ win_gain = cms.double( 1.0 ), tfilterEnvelope = cms.vdouble( 4.0, 12.04, 13.0, 10.56, 23.5, 8.82, 37.0, 7.38, 56.0, 6.3, 81.0, 5.64, 114.5, 5.44, 175.5, 5.38, 350.5, 5.14 ) ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( nominalPedestal = cms.double( 3.0 ), hitMultiplicityThreshold = cms.int32( 17 ), @@ -2092,6 +2117,11 @@ cms.PSet( pulseShapeParameters = cms.vdouble( -1000000.0, 1000000.0, 45.0, 0.1, 1000000.0, 0.0 ) ) ) ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( slopeMax = cms.double( -0.6 ), r1Max = cms.double( 1.0 ), @@ -2125,6 +2155,7 @@ samplesToAdd = cms.int32( 2 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( hflongEthresh = cms.double( 40.0 ), @@ -2137,7 +2168,13 @@ digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 1 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( + HFdigiflagFirstSample = cms.int32( 1 ), + HFdigiflagMinEthreshold = cms.double( 40.0 ), + HFdigiflagSamplesToAdd = cms.int32( 3 ), + HFdigiflagExpectedPeak = cms.int32( 2 ), + HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) + ), hfTimingTrustParameters = cms.PSet( hfTimingTrustLevel2 = cms.int32( 4 ), hfTimingTrustLevel1 = cms.int32( 1 ) @@ -2154,13 +2191,8 @@ long_R = cms.vdouble( 0.98 ), HcalAcceptSeverityLevel = cms.int32( 9 ) ), - digistat = cms.PSet( - HFdigiflagFirstSample = cms.int32( 1 ), - HFdigiflagMinEthreshold = cms.double( 40.0 ), - HFdigiflagSamplesToAdd = cms.int32( 3 ), - HFdigiflagExpectedPeak = cms.int32( 2 ), - HFdigiflagCoef = cms.vdouble( 0.93, -0.012667, -0.38275 ) - ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( @@ -2178,16 +2210,44 @@ correctForTimeslew = cms.bool( False ), setNoiseFlags = cms.bool( True ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HF" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 2 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) process.hltHoreco = cms.EDProducer( "HcalHitReconstructor", @@ -2199,15 +2259,17 @@ samplesToAdd = cms.int32( 4 ), mcOOTCorrectionCategory = cms.string( "MC" ), dataOOTCorrectionName = cms.string( "" ), + puCorrMethod = cms.int32( 0 ), correctionPhaseNS = cms.double( 13.0 ), HFInWindowStat = cms.PSet( ), digiLabel = cms.InputTag( "hltHcalDigis" ), setHSCPFlags = cms.bool( False ), firstAuxTS = cms.int32( 4 ), - setSaturationFlags = cms.bool( False ), + digistat = cms.PSet( ), hfTimingTrustParameters = cms.PSet( ), PETstat = cms.PSet( ), - digistat = cms.PSet( ), + setSaturationFlags = cms.bool( False ), + setNegativeFlags = cms.bool( False ), useLeakCorrection = cms.bool( False ), setTimingTrustFlags = cms.bool( False ), S8S1stat = cms.PSet( ), @@ -2215,16 +2277,44 @@ correctForTimeslew = cms.bool( True ), setNoiseFlags = cms.bool( False ), correctTiming = cms.bool( False ), - recoParamsFromDB = cms.bool( True ), + setPulseShapeFlags = cms.bool( False ), Subdetector = cms.string( "HO" ), dataOOTCorrectionCategory = cms.string( "Data" ), dropZSmarkedPassed = cms.bool( True ), - setPulseShapeFlags = cms.bool( False ), + recoParamsFromDB = cms.bool( True ), firstSample = cms.int32( 4 ), setTimingShapedCutsFlags = cms.bool( False ), + pulseJitter = cms.double( 1.0 ), + chargeMax = cms.double( 6.0 ), + negativeParameters = cms.PSet( + TS4TS5ChargeThreshold = cms.double( 70.0 ), + Cut = cms.vdouble( -50.0, -100.0, -100.0, -100.0, -100.0, -100.0 ), + Last = cms.int32( 6 ), + MinimumChargeThreshold = cms.double( 20.0 ), + Threshold = cms.vdouble( 100.0, 120.0, 160.0, 200.0, 300.0, 500.0 ), + First = cms.int32( 4 ) + ), + timeMin = cms.double( -15.0 ), + ts4chi2 = cms.double( 15.0 ), + ts345chi2 = cms.double( 100.0 ), + applyTimeSlew = cms.bool( True ), + applyTimeConstraint = cms.bool( True ), + applyPulseJitter = cms.bool( False ), timingshapedcutsParameters = cms.PSet( ), + ts3chi2 = cms.double( 5.0 ), + ts4Min = cms.double( 5.0 ), pulseShapeParameters = cms.PSet( ), + noise = cms.double( 1.0 ), + applyPedConstraint = cms.bool( True ), + applyUnconstrainedFit = cms.bool( False ), + ts4Max = cms.double( 500.0 ), + meanTime = cms.double( -2.5 ), flagParameters = cms.PSet( ), + fitTimes = cms.int32( 1 ), + timeMax = cms.double( 10.0 ), + timeSigma = cms.double( 5.0 ), + pedSigma = cms.double( 0.5 ), + meanPed = cms.double( 0.0 ), hscpParameters = cms.PSet( ) ) process.hltTowerMakerForAll = cms.EDProducer( "CaloTowersCreator", @@ -2997,9 +3087,11 @@ ) process.hltSiPixelDigis = cms.EDProducer( "SiPixelRawToDigi", UseQualityInfo = cms.bool( False ), + UsePilotBlade = cms.bool( False ), + UsePhase1 = cms.bool( False ), CheckPixelOrder = cms.bool( False ), - IncludeErrors = cms.bool( False ), InputLabel = cms.InputTag( "rawDataCollector" ), + IncludeErrors = cms.bool( False ), ErrorList = cms.vint32( ), Regions = cms.PSet( ), Timing = cms.untracked.bool( False ), @@ -3175,6 +3267,7 @@ s2_threshold = cms.double( 0.4 ), npixelmatchcut = cms.double( 1.0 ), tanhSO10InterThres = cms.double( 1.0 ), + pixelVeto = cms.bool( False ), doIsolated = cms.bool( True ), s_a_phi1B = cms.double( 0.0069 ), s_a_phi1F = cms.double( 0.0076 ), From ffdaed53df8f9d9e53370c147ded8bf59b9e5f4b Mon Sep 17 00:00:00 2001 From: Chris Jones Date: Thu, 11 Dec 2014 10:05:33 -0600 Subject: [PATCH 18/28] Sort entries when doing dumpPython In order to make it easier to compare different configurations, we now sort the named items used in the configuration. --- FWCore/ParameterSet/python/Config.py | 2 +- FWCore/ParameterSet/python/Mixins.py | 4 ++-- FWCore/ParameterSet/python/Modules.py | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/FWCore/ParameterSet/python/Config.py b/FWCore/ParameterSet/python/Config.py index 9af1d3f137d02..542b3a017f818 100644 --- a/FWCore/ParameterSet/python/Config.py +++ b/FWCore/ParameterSet/python/Config.py @@ -688,7 +688,7 @@ def _sequencesInDependencyOrder(self): return returnValue def _dumpPython(self, d, options): result = '' - for name, value in d.iteritems(): + for name, value in sorted(d.iteritems()): result += value.dumpPythonAs(name,options)+'\n' return result def dumpPython(self, options=PrintOptions()): diff --git a/FWCore/ParameterSet/python/Mixins.py b/FWCore/ParameterSet/python/Mixins.py index 39a3c7ca82438..bc867f2a56969 100644 --- a/FWCore/ParameterSet/python/Mixins.py +++ b/FWCore/ParameterSet/python/Mixins.py @@ -231,7 +231,7 @@ def __raiseBadSetAttr(name): def dumpPython(self, options=PrintOptions()): others = [] usings = [] - for name in self.parameterNames_(): + for name in sorted(self.parameterNames_()): param = self.__dict__[name] # we don't want minuses in names name2 = name.replace('-','_') @@ -376,7 +376,7 @@ def dumpPython(self, options=PrintOptions()): def dumpPythonAttributes(self, myname, options): """ dumps the object with all attributes declared after the constructor""" result = "" - for name in self.parameterNames_(): + for name in sorted(self.parameterNames_()): param = self.__dict__[name] result += options.indentation() + myname + "." + name + " = " + param.dumpPython(options) + "\n" return result diff --git a/FWCore/ParameterSet/python/Modules.py b/FWCore/ParameterSet/python/Modules.py index 4e10cec0cb5a1..0abc9d8b85d9c 100644 --- a/FWCore/ParameterSet/python/Modules.py +++ b/FWCore/ParameterSet/python/Modules.py @@ -254,7 +254,7 @@ def testService(self): self.assertEqual(withParam.foo.value(), 1) self.assertEqual(withParam.bar.value(), "it") self.assertEqual(empty.dumpPython(), "cms.Service(\"Empty\")\n") - self.assertEqual(withParam.dumpPython(), "cms.Service(\"Parameterized\",\n foo = cms.untracked.int32(1),\n bar = cms.untracked.string(\'it\')\n)\n") + self.assertEqual(withParam.dumpPython(), "cms.Service(\"Parameterized\",\n bar = cms.untracked.string(\'it\'),\n foo = cms.untracked.int32(1)\n)\n") def testSequences(self): m = EDProducer("MProducer") n = EDProducer("NProducer") From ccd803c06a2d7b0b8e3f33f44676aeb0295571c2 Mon Sep 17 00:00:00 2001 From: inugent Date: Thu, 11 Dec 2014 18:54:06 +0100 Subject: [PATCH 19/28] Adding patch for failed relval sequences with pythia8 --- ...sToMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi.py | 4 +- ...tarMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi.py | 4 +- ...arPsi2S_forSTEAM_13TeV_TuneCUETP8M1_cfi.py | 71 +++++++++++++++++++ ...TeV_MLM_5f_max4j_LHE_pythia8_EvtGen_cff.py | 30 +++++--- .../python/JpsiMM_13TeV_TuneCUETP8M1_cfi.py | 16 ++++- .../python/JpsiMM_8TeV_TuneCUETP8M1_cfi.py | 20 +++++- .../JpsiMM_Pt_20_inf_8TeV_TuneCUETP8M1_cfi.py | 16 ++++- ...MinBias_13TeV_pythia8_TuneCUETP8M1_cfi.py} | 16 ++--- ...JpsiK_TuneZ2star_13TeV_TuneCUETP8M1_cfi.py | 4 +- ...QCD_Pt_3000_3500_13TeV_TuneCUETP8M1_cfi.py | 1 - .../python/QQH120Inv_8TeV_TuneCUETP8M1_cfi.py | 19 +++-- .../python/SingleTaupt_50_pythia8_cfi.py | 2 + ...SToMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi.py | 17 ++++- ...ZpTT_1500_13TeV_Tauola_TuneCUETP8M1_cfi.py | 2 +- .../python/relval_steps.py | 8 +-- 15 files changed, 181 insertions(+), 49 deletions(-) create mode 100644 Configuration/Generator/python/BuToKstarPsi2S_forSTEAM_13TeV_TuneCUETP8M1_cfi.py rename Configuration/Generator/python/{MinBias_13TeV_pythia8_TuneCUETP8M1_cff.py => MinBias_13TeV_pythia8_TuneCUETP8M1_cfi.py} (67%) diff --git a/Configuration/Generator/python/BsToMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi.py b/Configuration/Generator/python/BsToMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi.py index 876debe501835..058e0948b7d06 100644 --- a/Configuration/Generator/python/BsToMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi.py +++ b/Configuration/Generator/python/BsToMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi.py @@ -14,8 +14,8 @@ EvtGen130 = cms.untracked.PSet( decay_table = cms.string('GeneratorInterface/EvtGenInterface/data/DECAY_2010.DEC'), particle_property_file = cms.FileInPath('GeneratorInterface/EvtGenInterface/data/evt.pdl'), - use_default_decay = cms.untracked.bool(False), - user_decay_file = cms.vstring('GeneratorInterface/ExternalDecays/data/Bs_mumu.dec'), + user_decay_file = cms.untracked.bool(True), + user_decay_files = cms.vstring('GeneratorInterface/ExternalDecays/data/Bs_mumu.dec'), list_forced_decays = cms.vstring('MyB_s0','Myanti-B_s0'), operates_on_particles = cms.vint32() ), diff --git a/Configuration/Generator/python/BuToKstarMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi.py b/Configuration/Generator/python/BuToKstarMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi.py index d8a3f84c6aac0..9308f0278d610 100644 --- a/Configuration/Generator/python/BuToKstarMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi.py +++ b/Configuration/Generator/python/BuToKstarMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi.py @@ -23,8 +23,8 @@ EvtGen130 = cms.untracked.PSet( decay_table = cms.string('GeneratorInterface/EvtGenInterface/data/DECAY_2010.DEC'), particle_property_file = cms.FileInPath('GeneratorInterface/EvtGenInterface/data/evt.pdl'), - use_default_decay = cms.untracked.bool(False), - user_decay_file = cms.vstring('GeneratorInterface/ExternalDecays/data/Bu_Kstarmumu_Kspi.dec'), + user_decay_file = cms.untracked.bool(True), + user_decay_files = cms.vstring('GeneratorInterface/ExternalDecays/data/Bu_Kstarmumu_Kspi.dec'), list_forced_decays = cms.vstring('MyB+','MyB-'), operates_on_particles = cms.vint32() ), diff --git a/Configuration/Generator/python/BuToKstarPsi2S_forSTEAM_13TeV_TuneCUETP8M1_cfi.py b/Configuration/Generator/python/BuToKstarPsi2S_forSTEAM_13TeV_TuneCUETP8M1_cfi.py new file mode 100644 index 0000000000000..9fea6a9156abf --- /dev/null +++ b/Configuration/Generator/python/BuToKstarPsi2S_forSTEAM_13TeV_TuneCUETP8M1_cfi.py @@ -0,0 +1,71 @@ +import FWCore.ParameterSet.Config as cms +from Configuration.Generator.Pythia8CommonSettings_cfi import * +from Configuration.Generator.Pythia8CUEP8M1Settings_cfi import * +from GeneratorInterface.EvtGenInterface.EvtGenSetting_cff import * +source = cms.Source("EmptySource") +generator = cms.EDFilter("Pythia8GeneratorFilter", + pythiaPylistVerbosity = cms.untracked.int32(0), + pythiaHepMCVerbosity = cms.untracked.bool(False), + comEnergy = cms.double(13000.0), + crossSection = cms.untracked.double(54000000000), # Given by PYTHIA after running + filterEfficiency = cms.untracked.double(0.004), # Given by PYTHIA after running + maxEventsToPrint = cms.untracked.int32(0), + #ExternalDecays = cms.PSet( + #EvtGen = cms.untracked.PSet( + #operates_on_particles = cms.vint32(0), + #use_default_decay = cms.untracked.bool(False), + #decay_table = cms.FileInPath('GeneratorInterface/ExternalDecays/data/DECAY.DEC'), + #particle_property_file = cms.FileInPath('GeneratorInterface/ExternalDecays/data/evt.pdl'), + #user_decay_file = cms.FileInPath('GeneratorInterface/ExternalDecays/data/Bu_Kstarmumu_Kspi.dec'), + #list_forced_decays = cms.vstring('MyB+','MyB-')), + #parameterSets = cms.vstring('EvtGen')), + ExternalDecays = cms.PSet( + EvtGen130 = cms.untracked.PSet( + decay_table = cms.string('GeneratorInterface/EvtGenInterface/data/DECAY_2010.DEC'), + particle_property_file = cms.FileInPath('GeneratorInterface/EvtGenInterface/data/evt.pdl'), + user_decay_file = cms.untracked.bool(True), + user_decay_files = cms.vstring('GeneratorInterface/ExternalDecays/data/Bu_Psi2SKstar.dec'), + list_forced_decays = cms.vstring('MyB+','MyB-'), + operates_on_particles = cms.vint32() + ), + parameterSets = cms.vstring('EvtGen130') + ), + PythiaParameters = cms.PSet( + pythia8CommonSettingsBlock, + pythia8CUEP8M1SettingsBlock, + processParameters = cms.vstring('HardQCD:all = on'), + parameterSets = cms.vstring('pythia8CommonSettings', + 'pythia8CUEP8M1Settings', + 'processParameters', + ) + ) + ) + +generator.PythiaParameters.processParameters.extend(EvtGenExtraParticles) + + + +configurationMetadata = cms.untracked.PSet( + version = cms.untracked.string('$Revision: 1.1 $'), + name = cms.untracked.string('$Source: Configuration/Generator/python/BuToKstarMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi.py $'), + annotation = cms.untracked.string('Summer14: Pythia8+EvtGen130 generation of Bu --> K* Mu+Mu-, 13TeV, Tune CUETP8M1') + ) + +########### +# Filters # +########### +# Filter only pp events which produce a B+: +bufilter = cms.EDFilter("PythiaFilter", ParticleID = cms.untracked.int32(521)) + +# Filter on final state muons +mumugenfilter = cms.EDFilter("MCParticlePairFilter", + Status = cms.untracked.vint32(1, 1), + MinPt = cms.untracked.vdouble(2.8, 2.8), + MaxEta = cms.untracked.vdouble(2.3, 2.3), + MinEta = cms.untracked.vdouble(-2.3, -2.3), + ParticleCharge = cms.untracked.int32(-1), + ParticleID1 = cms.untracked.vint32(13), + ParticleID2 = cms.untracked.vint32(13) + ) + +ProductionFilterSequence = cms.Sequence(generator*bufilter*mumugenfilter) diff --git a/Configuration/Generator/python/Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_EvtGen_cff.py b/Configuration/Generator/python/Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_EvtGen_cff.py index cd2e7cdd9eeb1..d370fe228f795 100644 --- a/Configuration/Generator/python/Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_EvtGen_cff.py +++ b/Configuration/Generator/python/Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_EvtGen_cff.py @@ -6,16 +6,26 @@ generator = cms.EDFilter("Pythia8HadronizerFilter", ExternalDecays = cms.PSet( - EvtGen = cms.untracked.PSet( - use_default_decay = cms.untracked.bool(True), - decay_table = cms.FileInPath('GeneratorInterface/ExternalDecays/data/DECAY_NOLONGLIFE.DEC'), - particle_property_file = cms.FileInPath('GeneratorInterface/ExternalDecays/data/evt.pdl'), - user_decay_file = cms.FileInPath('GeneratorInterface/ExternalDecays/data/Validation.dec'), - list_forced_decays = cms.vstring(), - operates_on_particles = cms.vint32(0) - ), - parameterSets = cms.vstring('EvtGen') - ), + #EvtGen = cms.untracked.PSet( + #use_default_decay = cms.untracked.bool(True), + #decay_table = cms.FileInPath('GeneratorInterface/ExternalDecays/data/DECAY_NOLONGLIFE.DEC'), + #particle_property_file = cms.FileInPath('GeneratorInterface/ExternalDecays/data/evt.pdl'), + #user_decay_file = cms.FileInPath('GeneratorInterface/ExternalDecays/data/Validation.dec'), + #list_forced_decays = cms.vstring(), + #operates_on_particles = cms.vint32(0) + #), + #parameterSets = cms.vstring('EvtGen') + #), + EvtGen130 = cms.untracked.PSet( + decay_table = cms.string('GeneratorInterface/EvtGenInterface/data/DECAY_2010.DEC'), + particle_property_file = cms.FileInPath('GeneratorInterface/EvtGenInterface/data/evt.pdl'), + user_decay_file = cms.untracked.bool(False), + user_decay_files = cms.vstring(), + list_forced_decays = cms.vstring(), + operates_on_particles = cms.vint32() + ), + parameterSets = cms.vstring('EvtGen130') + ), UseExternalGenerators = cms.untracked.bool(True), maxEventsToPrint = cms.untracked.int32(1), pythiaPylistVerbosity = cms.untracked.int32(1), diff --git a/Configuration/Generator/python/JpsiMM_13TeV_TuneCUETP8M1_cfi.py b/Configuration/Generator/python/JpsiMM_13TeV_TuneCUETP8M1_cfi.py index 3a5d58330ca16..3c80e30ce64ff 100644 --- a/Configuration/Generator/python/JpsiMM_13TeV_TuneCUETP8M1_cfi.py +++ b/Configuration/Generator/python/JpsiMM_13TeV_TuneCUETP8M1_cfi.py @@ -13,7 +13,21 @@ pythia8CommonSettingsBlock, pythia8CUEP8M1SettingsBlock, processParameters = cms.vstring( - 'Charmonium:states(3S1) = 443' # filter on 443 and prevents other onium states decaying to 443, so we should turn the others off + 'Charmonium:states(3S1) = 443', # filter on 443 and prevents other onium states decaying to 443, so we should turn the others off + 'Charmonium:O(3S1)[3S1(1)] = 1.16', + 'Charmonium:O(3S1)[3S1(8)] = 0.0119', + 'Charmonium:O(3S1)[1S0(8)] = 0.01', + 'Charmonium:O(3S1)[3P0(8)] = 0.01', + 'Charmonium:gg2ccbar(3S1)[3S1(1)]g = on', + 'Charmonium:gg2ccbar(3S1)[3S1(8)]g = on', + 'Charmonium:qg2ccbar(3S1)[3S1(8)]q = on', + 'Charmonium:qqbar2ccbar(3S1)[3S1(8)]g = on', + 'Charmonium:gg2ccbar(3S1)[1S0(8)]g = on', + 'Charmonium:qg2ccbar(3S1)[1S0(8)]q = on', + 'Charmonium:qqbar2ccbar(3S1)[1S0(8)]g = on', + 'Charmonium:gg2ccbar(3S1)[3PJ(8)]g = on', + 'Charmonium:qg2ccbar(3S1)[3PJ(8)]q = on', + 'Charmonium:qqbar2ccbar(3S1)[3PJ(8)]g = on', '443:onMode = off', # ignore cross-section re-weighting (CSAMODE=6) since selecting wanted decay mode '443:onIfAny = 13', 'PhaseSpace:pTHatMin = 10.', diff --git a/Configuration/Generator/python/JpsiMM_8TeV_TuneCUETP8M1_cfi.py b/Configuration/Generator/python/JpsiMM_8TeV_TuneCUETP8M1_cfi.py index edf3e370b44e0..34872568a2695 100644 --- a/Configuration/Generator/python/JpsiMM_8TeV_TuneCUETP8M1_cfi.py +++ b/Configuration/Generator/python/JpsiMM_8TeV_TuneCUETP8M1_cfi.py @@ -13,14 +13,28 @@ pythia8CommonSettingsBlock, pythia8CUEP8M1SettingsBlock, processParameters = cms.vstring( - 'Charmonium:states(3S1) = 443' # filter on 443 and prevents other onium states decaying to 443, so we should turn the others off + 'Charmonium:states(3S1) = 443 ', # filter on 443 and prevents other onium states decaying to 443, so we should turn the others off + 'Charmonium:O(3S1)[3S1(1)] = 1.16', + 'Charmonium:O(3S1)[3S1(8)] = 0.0119', + 'Charmonium:O(3S1)[1S0(8)] = 0.01', + 'Charmonium:O(3S1)[3P0(8)] = 0.01', + 'Charmonium:gg2ccbar(3S1)[3S1(1)]g = on', + 'Charmonium:gg2ccbar(3S1)[3S1(8)]g = on', + 'Charmonium:qg2ccbar(3S1)[3S1(8)]q = on', + 'Charmonium:qqbar2ccbar(3S1)[3S1(8)]g = on', + 'Charmonium:gg2ccbar(3S1)[1S0(8)]g = on', + 'Charmonium:qg2ccbar(3S1)[1S0(8)]q = on', + 'Charmonium:qqbar2ccbar(3S1)[1S0(8)]g = on', + 'Charmonium:gg2ccbar(3S1)[3PJ(8)]g = on', + 'Charmonium:qg2ccbar(3S1)[3PJ(8)]q = on', + 'Charmonium:qqbar2ccbar(3S1)[3PJ(8)]g = on', '443:onMode = off', # ignore cross-section re-weighting (CSAMODE=6) since selecting wanted decay mode '443:onIfAny = 13', 'PhaseSpace:pTHatMin = 10.', ), - parameterSets = cms.vstring('pythia8CommonSettings', + parameterSets = cms.vstring('processParameters', + 'pythia8CommonSettings', 'pythia8CUEP8M1Settings', - 'processParameters', ) ) ) diff --git a/Configuration/Generator/python/JpsiMM_Pt_20_inf_8TeV_TuneCUETP8M1_cfi.py b/Configuration/Generator/python/JpsiMM_Pt_20_inf_8TeV_TuneCUETP8M1_cfi.py index e1f9fe8000c15..3d826f9151266 100644 --- a/Configuration/Generator/python/JpsiMM_Pt_20_inf_8TeV_TuneCUETP8M1_cfi.py +++ b/Configuration/Generator/python/JpsiMM_Pt_20_inf_8TeV_TuneCUETP8M1_cfi.py @@ -13,7 +13,21 @@ pythia8CommonSettingsBlock, pythia8CUEP8M1SettingsBlock, processParameters = cms.vstring( - 'Charmonium:states(3S1) = 443' # filter on 443 and prevents other onium states decaying to 443, so we should turn the others off + 'Charmonium:states(3S1) = 443', # filter on 443 and prevents other onium states decaying to 443, so we should turn the others off + 'Charmonium:O(3S1)[3S1(1)] = 1.16', + 'Charmonium:O(3S1)[3S1(8)] = 0.0119', + 'Charmonium:O(3S1)[1S0(8)] = 0.01', + 'Charmonium:O(3S1)[3P0(8)] = 0.01', + 'Charmonium:gg2ccbar(3S1)[3S1(1)]g = on', + 'Charmonium:gg2ccbar(3S1)[3S1(8)]g = on', + 'Charmonium:qg2ccbar(3S1)[3S1(8)]q = on', + 'Charmonium:qqbar2ccbar(3S1)[3S1(8)]g = on', + 'Charmonium:gg2ccbar(3S1)[1S0(8)]g = on', + 'Charmonium:qg2ccbar(3S1)[1S0(8)]q = on', + 'Charmonium:qqbar2ccbar(3S1)[1S0(8)]g = on', + 'Charmonium:gg2ccbar(3S1)[3PJ(8)]g = on', + 'Charmonium:qg2ccbar(3S1)[3PJ(8)]q = on', + 'Charmonium:qqbar2ccbar(3S1)[3PJ(8)]g = on', '443:onMode = off', # ignore cross-section re-weighting (CSAMODE=6) since selecting wanted decay mode '443:onIfAny = 13', 'PhaseSpace:pTHatMin = 20.', diff --git a/Configuration/Generator/python/MinBias_13TeV_pythia8_TuneCUETP8M1_cff.py b/Configuration/Generator/python/MinBias_13TeV_pythia8_TuneCUETP8M1_cfi.py similarity index 67% rename from Configuration/Generator/python/MinBias_13TeV_pythia8_TuneCUETP8M1_cff.py rename to Configuration/Generator/python/MinBias_13TeV_pythia8_TuneCUETP8M1_cfi.py index c6f16eadfcd3f..388abdd4a405a 100644 --- a/Configuration/Generator/python/MinBias_13TeV_pythia8_TuneCUETP8M1_cff.py +++ b/Configuration/Generator/python/MinBias_13TeV_pythia8_TuneCUETP8M1_cfi.py @@ -1,17 +1,14 @@ import FWCore.ParameterSet.Config as cms - from Configuration.Generator.Pythia8CommonSettings_cfi import * from Configuration.Generator.Pythia8CUEP8M1Settings_cfi import * - source = cms.Source("EmptySource") - generator = cms.EDFilter("Pythia8GeneratorFilter", - crossSection = cms.untracked.double(71.39e+09), - maxEventsToPrint = cms.untracked.int32(0), - pythiaPylistVerbosity = cms.untracked.int32(1), - filterEfficiency = cms.untracked.double(1.0), - pythiaHepMCVerbosity = cms.untracked.bool(False), - comEnergy = cms.double(13000.0), + crossSection = cms.untracked.double(71.39e+09), + maxEventsToPrint = cms.untracked.int32(0), + pythiaPylistVerbosity = cms.untracked.int32(1), + filterEfficiency = cms.untracked.double(1.0), + pythiaHepMCVerbosity = cms.untracked.bool(False), + comEnergy = cms.double(13000.0), PythiaParameters = cms.PSet( pythia8CommonSettingsBlock, pythia8CUEP8M1SettingsBlock, @@ -27,4 +24,3 @@ ) ProductionFilterSequence = cms.Sequence(generator) - diff --git a/Configuration/Generator/python/Pythia8_BuJpsiK_TuneZ2star_13TeV_TuneCUETP8M1_cfi.py b/Configuration/Generator/python/Pythia8_BuJpsiK_TuneZ2star_13TeV_TuneCUETP8M1_cfi.py index be5be8aad55c7..62db6a74b1ee0 100644 --- a/Configuration/Generator/python/Pythia8_BuJpsiK_TuneZ2star_13TeV_TuneCUETP8M1_cfi.py +++ b/Configuration/Generator/python/Pythia8_BuJpsiK_TuneZ2star_13TeV_TuneCUETP8M1_cfi.py @@ -14,8 +14,8 @@ EvtGen130 = cms.untracked.PSet( decay_table = cms.string('GeneratorInterface/EvtGenInterface/data/DECAY_2010.DEC'), particle_property_file = cms.FileInPath('GeneratorInterface/EvtGenInterface/data/evt.pdl'), - use_default_decay = cms.untracked.bool(False), - user_decay_file = cms.vstring('GeneratorInterface/ExternalDecays/data/Bu_JpsiK.dec'), + user_decay_file = cms.untracked.bool(True), + user_decay_files = cms.vstring('GeneratorInterface/ExternalDecays/data/Bu_JpsiK.dec'), list_forced_decays = cms.vstring('MyB+','MyB-'), operates_on_particles = cms.vint32() ), diff --git a/Configuration/Generator/python/QCD_Pt_3000_3500_13TeV_TuneCUETP8M1_cfi.py b/Configuration/Generator/python/QCD_Pt_3000_3500_13TeV_TuneCUETP8M1_cfi.py index f9b4b3392b4ac..a7e7d86d094f9 100644 --- a/Configuration/Generator/python/QCD_Pt_3000_3500_13TeV_TuneCUETP8M1_cfi.py +++ b/Configuration/Generator/python/QCD_Pt_3000_3500_13TeV_TuneCUETP8M1_cfi.py @@ -24,4 +24,3 @@ ) ) -k diff --git a/Configuration/Generator/python/QQH120Inv_8TeV_TuneCUETP8M1_cfi.py b/Configuration/Generator/python/QQH120Inv_8TeV_TuneCUETP8M1_cfi.py index 6fca9bf54df70..af44fd49ad985 100644 --- a/Configuration/Generator/python/QQH120Inv_8TeV_TuneCUETP8M1_cfi.py +++ b/Configuration/Generator/python/QQH120Inv_8TeV_TuneCUETP8M1_cfi.py @@ -13,16 +13,15 @@ PythiaParameters = cms.PSet( pythia8CommonSettingsBlock, pythia8CUEP8M1SettingsBlock, - processParameters = cms.vstring( - #'HiggsSM:gg2H = on', - 'HiggsSM:ff2Hff(t:WW) = on', - 'HiggsSM:ff2Hff(t:ZZ) = on ', - '25:m0 = 120' - '25:onMode = off', - '25:onIfAny = 23 23', - '23:onMode = off', - '23:onMode = 12', - ), + processParameters = cms.vstring( 'HiggsSM:ff2Hff(t:WW) = on', + 'HiggsSM:ff2Hff(t:ZZ) = on ', + 'HiggsSM:NLOWidths = on ', + '25:m0 = 120', + '25:onMode = off', + '25:onIfAny = 23', + '23:onMode = off', + '23:onIfAny = 12' + ), parameterSets = cms.vstring('pythia8CommonSettings', 'pythia8CUEP8M1Settings', 'processParameters', diff --git a/Configuration/Generator/python/SingleTaupt_50_pythia8_cfi.py b/Configuration/Generator/python/SingleTaupt_50_pythia8_cfi.py index 5704d5c23cd6a..4845c39397ef1 100644 --- a/Configuration/Generator/python/SingleTaupt_50_pythia8_cfi.py +++ b/Configuration/Generator/python/SingleTaupt_50_pythia8_cfi.py @@ -1,4 +1,6 @@ import FWCore.ParameterSet.Config as cms +from Configuration.Generator.Pythia8CommonSettings_cfi import * +from Configuration.Generator.Pythia8CUEP8M1Settings_cfi import * generator = cms.EDFilter("Pythia8PtGun", pythia8CommonSettingsBlock, pythia8CUEP8M1SettingsBlock, diff --git a/Configuration/Generator/python/Upsilon1SToMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi.py b/Configuration/Generator/python/Upsilon1SToMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi.py index d42f5899fab71..eaeffad1236fe 100644 --- a/Configuration/Generator/python/Upsilon1SToMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi.py +++ b/Configuration/Generator/python/Upsilon1SToMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi.py @@ -13,7 +13,21 @@ pythia8CommonSettingsBlock, pythia8CUEP8M1SettingsBlock, processParameters = cms.vstring( - 'Bottomonium:states(3S1) = 553' # filter on 553 and prevents other onium states decaying to 553, so we should turn the others off + 'Bottomonium:states(3S1) = 553', # filter on 553 and prevents other onium states decaying to 553, so we should turn the others off + 'Bottomonium:O(3S1)[3S1(1)] = 9.28', + 'Bottomonium:O(3S1)[3S1(8)] = 0.15', + 'Bottomonium:O(3S1)[1S0(8)] = 0.02', + 'Bottomonium:O(3S1)[3P0(8)] = 0.02', + 'Bottomonium:gg2bbbar(3S1)[3S1(1)]g = on', + 'Bottomonium:gg2bbbar(3S1)[3S1(8)]g = on', + 'Bottomonium:qg2bbbar(3S1)[3S1(8)]q = on', + 'Bottomonium:qqbar2bbbar(3S1)[3S1(8)]g = on', + 'Bottomonium:gg2bbbar(3S1)[1S0(8)]g = on', + 'Bottomonium:qg2bbbar(3S1)[1S0(8)]q = on', + 'Bottomonium:qqbar2bbbar(3S1)[1S0(8)]g = on', + 'Bottomonium:gg2bbbar(3S1)[3PJ(8)]g = on', + 'Bottomonium:qg2bbbar(3S1)[3PJ(8)]q = on', + 'Bottomonium:qqbar2bbbar(3S1)[3PJ(8)]g = on', '553:onMode = off', # ignore cross-section re-weighting (CSAMODE=6) since selecting wanted decay mode '553:onIfAny = 13', 'PhaseSpace:pTHatMin = 20.', @@ -47,4 +61,3 @@ ) ProductionFilterSequence = cms.Sequence(generator*oniafilter*mumugenfilter) - diff --git a/Configuration/Generator/python/ZpTT_1500_13TeV_Tauola_TuneCUETP8M1_cfi.py b/Configuration/Generator/python/ZpTT_1500_13TeV_Tauola_TuneCUETP8M1_cfi.py index 1fc4398be27c7..ccd2cbc97ab7a 100644 --- a/Configuration/Generator/python/ZpTT_1500_13TeV_Tauola_TuneCUETP8M1_cfi.py +++ b/Configuration/Generator/python/ZpTT_1500_13TeV_Tauola_TuneCUETP8M1_cfi.py @@ -1,9 +1,9 @@ import FWCore.ParameterSet.Config as cms from Configuration.Generator.Pythia8CommonSettings_cfi import * from Configuration.Generator.Pythia8CUEP8M1Settings_cfi import * +from GeneratorInterface.ExternalDecays.TauolaSettings_cff import * source = cms.Source("EmptySource") generator = cms.EDFilter("Pythia8GeneratorFilter", - #pythiaHepMCVerbosity = cms.untracked.bool(False), comEnergy = cms.double(13000.0), maxEventsToPrint = cms.untracked.int32(0), pythiaPylistVerbosity = cms.untracked.int32(1), diff --git a/Configuration/PyReleaseValidation/python/relval_steps.py b/Configuration/PyReleaseValidation/python/relval_steps.py index fb50924634067..d5b5bbcbafafb 100644 --- a/Configuration/PyReleaseValidation/python/relval_steps.py +++ b/Configuration/PyReleaseValidation/python/relval_steps.py @@ -450,10 +450,10 @@ def genS(fragment,howMuch): steps['ZMM']=genS('ZMM_8TeV_TuneCUETP8M1_cfi',Kby(18,300)) steps['ZpMM']=genS('ZpMM_8TeV_TuneCUETP8M1_cfi',Kby(9,200)) steps['Higgs200ChargedTaus_13']=gen2015('H200ChargedTaus_Tauola_13TeV_cfi',Kby(9,100)) -steps['Upsilon1SToMuMu_13']=gen2015('Upsilon1SToMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi',Kby(17,190)) +steps['Upsilon1SToMuMu_13']=gen2015('Upsilon1SToMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi',Kby(17,190)) steps['BuToKstarMuMu_13']=gen2015('BuToKstarMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi',Kby(2250,25000)) steps['BsToMuMu_13']=gen2015('BsToMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi',Kby(30000,333333)) -steps['JpsiMuMu_Pt-15']=gen2015('JpsiMuMu_Pt-15_forSTEAM_13TeV_TuneCUETP8M1_cfi',Kby(11000,122000)) +steps['JpsiMuMu_Pt-15']=gen2015('JpsiMuMu_Pt-15_forSTEAM_13TeV_cfi',Kby(11000,122000)) steps['BuToKstarPsi2S_13']=gen2015('BuToKstarPsi2S_forSTEAM_13TeV_TuneCUETP8M1_cfi',Kby(16000,176000)) steps['WE_13']=gen2015('WE_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['WM_13']=gen2015('WM_13TeV_TuneCUETP8M1_cfi',Kby(9,200)) @@ -473,7 +473,7 @@ def genS(fragment,howMuch): steps['ADDMonoJet_d3MD3']=genS('ADDMonoJet_8TeV_d3MD3_TuneCUETP8M1_cfi',Kby(9,100)) steps['ADDMonoJet_d3MD3_13']=gen2015('ADDMonoJet_13TeV_d3MD3_TuneCUETP8M1_cfi',Kby(9,100)) steps['RSKKGluon_m3000GeV_13']=gen2015('RSKKGluon_m3000GeV_13TeV_TuneCUETP8M1_cff',Kby(9,100)) -steps['Pythia6_BuJpsiK_TuneZ2star_13']=gen2015('Pythia6_BuJpsiK_TuneZ2star_13TeV_TuneCUETP8M1_cfi',Kby(36000,400000)) +steps['Pythia6_BuJpsiK_TuneZ2star_13']=gen2015('Pythia6_BuJpsiK_TuneZ2star_13TeV_cfi',Kby(36000,400000)) steps['MinBias2INPUT']={'INPUT':InputInfo(dataSet='/RelValMinBias/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} steps['Higgs200ChargedTausINPUT']={'INPUT':InputInfo(dataSet='/RelValHiggs200ChargedTaus/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} @@ -515,7 +515,7 @@ def genS(fragment,howMuch): steps['QCD_Pt_120_170']=genS('QCD_Pt_120_170_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) steps['H165WW2L']=genS('H165WW2L_Tauola_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) steps['UpsMM']=genS('UpsMM_8TeV_TuneCUETP8M1_cfi',Kby(56250,225)) -steps['RSGrav']=genS('RS750_quarks_and_leptons_TuneCUETP8M1_8TeV_cff',Kby(25,100)) +steps['RSGrav']=genS('RS750_quarks_and_leptons_8TeV_TuneCUETP8M1_cff',Kby(25,100)) steps['QCD_Pt_80_120_2HS']=merge([Kby(25,100),steps['QCD_Pt_80_120']]) steps['bJpsiX']=genS('bJpsiX_8TeV_TuneCUETP8M1_cfi',Mby(325,1300000)) steps['QCD_Pt_30_50']=genS('QCD_Pt_30_50_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) From dbc7fce4d5d24a4d18e7881c8bf3e409803390af Mon Sep 17 00:00:00 2001 From: wmtan Date: Thu, 11 Dec 2014 19:04:40 +0100 Subject: [PATCH 20/28] Anonymous namespace here can cause build warnings --- FWCore/Framework/test/stubs/TestStreamAnalyzers.cc | 8 ++++---- FWCore/Framework/test/stubs/TestStreamFilters.cc | 9 +++++---- FWCore/Framework/test/stubs/TestStreamProducers.cc | 7 +++++-- 3 files changed, 14 insertions(+), 10 deletions(-) diff --git a/FWCore/Framework/test/stubs/TestStreamAnalyzers.cc b/FWCore/Framework/test/stubs/TestStreamAnalyzers.cc index 3f193c43e08fa..2afb722016c50 100644 --- a/FWCore/Framework/test/stubs/TestStreamAnalyzers.cc +++ b/FWCore/Framework/test/stubs/TestStreamAnalyzers.cc @@ -27,7 +27,8 @@ for testing purposes only. namespace edmtest { namespace stream { -namespace { +// anonymous namespace here causes build warnings +namespace cache { struct Cache { Cache():value(0),run(0),lumi(0) {} //Using mutable since we want to update the value. @@ -35,10 +36,9 @@ struct Cache { mutable std::atomic run; mutable std::atomic lumi; }; -} //end anonymous namespace - - +} //end cache namespace + using Cache = cache::Cache; class GlobalIntAnalyzer : public edm::stream::EDAnalyzer> { public: diff --git a/FWCore/Framework/test/stubs/TestStreamFilters.cc b/FWCore/Framework/test/stubs/TestStreamFilters.cc index b493057165d3e..ca2e9a991a97d 100644 --- a/FWCore/Framework/test/stubs/TestStreamFilters.cc +++ b/FWCore/Framework/test/stubs/TestStreamFilters.cc @@ -27,8 +27,9 @@ for testing purposes only. namespace edmtest { namespace stream { -namespace { -struct Cache { +// anonymous namespace here causes build warnings +namespace cache { +struct Cache { Cache():value(0),run(0),lumi(0) {} //Using mutable since we want to update the value. mutable std::atomic value; @@ -36,9 +37,9 @@ struct Cache { mutable std::atomic lumi; }; -} //end anonymous namespace - +} //end cache namespace + using Cache = cache::Cache; class GlobalIntFilter : public edm::stream::EDFilter> { public: diff --git a/FWCore/Framework/test/stubs/TestStreamProducers.cc b/FWCore/Framework/test/stubs/TestStreamProducers.cc index f14a8c7cbc2ec..b6640a3928377 100644 --- a/FWCore/Framework/test/stubs/TestStreamProducers.cc +++ b/FWCore/Framework/test/stubs/TestStreamProducers.cc @@ -27,7 +27,8 @@ for testing purposes only. namespace edmtest { namespace stream { -namespace { +// anonymous namespace here causes build warnings +namespace cache { struct Cache { Cache():value(0),run(0),lumi(0) {} //Using mutable since we want to update the value. @@ -43,8 +44,10 @@ struct UnsafeCache { unsigned int lumi; }; -} //end anonymous namespace +} //end cache namespace + using Cache = cache::Cache; + using UnsafeCache = cache::UnsafeCache; class GlobalIntProducer : public edm::stream::EDProducer> { public: From 595e3d389320e0ac773b7672d3ed57f367087b67 Mon Sep 17 00:00:00 2001 From: inugent Date: Fri, 12 Dec 2014 00:03:21 +0100 Subject: [PATCH 21/28] Removing Tauola from ZpMM* and ZpEE* at Joshes request. Will rename workflows later --- .../python/ZpEE_2250_13TeV_Tauola_TuneCUETP8M1_cfi.py | 7 ------- .../python/ZpEE_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py | 8 -------- .../python/ZpMM_2250_13TeV_Tauola_TuneCUETP8M1_cfi.py | 7 ------- .../python/ZpMM_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py | 8 -------- 4 files changed, 30 deletions(-) diff --git a/Configuration/Generator/python/ZpEE_2250_13TeV_Tauola_TuneCUETP8M1_cfi.py b/Configuration/Generator/python/ZpEE_2250_13TeV_Tauola_TuneCUETP8M1_cfi.py index 40991f2eb6ffa..d3ec8fe19c71f 100644 --- a/Configuration/Generator/python/ZpEE_2250_13TeV_Tauola_TuneCUETP8M1_cfi.py +++ b/Configuration/Generator/python/ZpEE_2250_13TeV_Tauola_TuneCUETP8M1_cfi.py @@ -9,13 +9,6 @@ pythiaPylistVerbosity = cms.untracked.int32(1), filterEfficiency = cms.untracked.double(1.0), crossSection = cms.untracked.double(0.00002497), - ExternalDecays = cms.PSet( - Tauola = cms.untracked.PSet( - TauolaPolar, - TauolaDefaultInputCards - ), - parameterSets = cms.vstring('Tauola') - ), PythiaParameters = cms.PSet( pythia8CommonSettingsBlock, pythia8CUEP8M1SettingsBlock, diff --git a/Configuration/Generator/python/ZpEE_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py b/Configuration/Generator/python/ZpEE_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py index cc344b38d0a42..e0106a4f2ec0e 100644 --- a/Configuration/Generator/python/ZpEE_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py +++ b/Configuration/Generator/python/ZpEE_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py @@ -1,7 +1,6 @@ import FWCore.ParameterSet.Config as cms from Configuration.Generator.Pythia8CommonSettings_cfi import * from Configuration.Generator.Pythia8CUEP8M1Settings_cfi import * -from GeneratorInterface.ExternalDecays.TauolaSettings_cff import * source = cms.Source("EmptySource") generator = cms.EDFilter("Pythia8GeneratorFilter", #pythiaHepMCVerbosity = cms.untracked.bool(False), @@ -10,13 +9,6 @@ pythiaPylistVerbosity = cms.untracked.int32(1), filterEfficiency = cms.untracked.double(1.0), crossSection = cms.untracked.double(0.00002497), - ExternalDecays = cms.PSet( - Tauola = cms.untracked.PSet( - TauolaPolar, - TauolaDefaultInputCards - ), - parameterSets = cms.vstring('Tauola') - ), PythiaParameters = cms.PSet( pythia8CommonSettingsBlock, pythia8CUEP8M1SettingsBlock, diff --git a/Configuration/Generator/python/ZpMM_2250_13TeV_Tauola_TuneCUETP8M1_cfi.py b/Configuration/Generator/python/ZpMM_2250_13TeV_Tauola_TuneCUETP8M1_cfi.py index 2cf84468901fc..607dbb31f5019 100644 --- a/Configuration/Generator/python/ZpMM_2250_13TeV_Tauola_TuneCUETP8M1_cfi.py +++ b/Configuration/Generator/python/ZpMM_2250_13TeV_Tauola_TuneCUETP8M1_cfi.py @@ -9,13 +9,6 @@ pythiaPylistVerbosity = cms.untracked.int32(1), filterEfficiency = cms.untracked.double(1.0), crossSection = cms.untracked.double(0.00002497), - ExternalDecays = cms.PSet( - Tauola = cms.untracked.PSet( - TauolaPolar, - TauolaDefaultInputCards - ), - parameterSets = cms.vstring('Tauola') - ), PythiaParameters = cms.PSet( pythia8CommonSettingsBlock, pythia8CUEP8M1SettingsBlock, diff --git a/Configuration/Generator/python/ZpMM_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py b/Configuration/Generator/python/ZpMM_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py index 88b03e7e12dd6..0360bb86f651a 100644 --- a/Configuration/Generator/python/ZpMM_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py +++ b/Configuration/Generator/python/ZpMM_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py @@ -1,7 +1,6 @@ import FWCore.ParameterSet.Config as cms from Configuration.Generator.Pythia8CommonSettings_cfi import * from Configuration.Generator.Pythia8CUEP8M1Settings_cfi import * -from GeneratorInterface.ExternalDecays.TauolaSettings_cff import * source = cms.Source("EmptySource") generator = cms.EDFilter("Pythia8GeneratorFilter", #pythiaHepMCVerbosity = cms.untracked.bool(False), @@ -10,13 +9,6 @@ pythiaPylistVerbosity = cms.untracked.int32(1), filterEfficiency = cms.untracked.double(1.0), crossSection = cms.untracked.double(0.00002497), - ExternalDecays = cms.PSet( - Tauola = cms.untracked.PSet( - TauolaPolar, - TauolaDefaultInputCards - ), - parameterSets = cms.vstring('Tauola') - ), PythiaParameters = cms.PSet( pythia8CommonSettingsBlock, pythia8CUEP8M1SettingsBlock, From bcc4e0b877c17a202359b7ff456a6d0952e9f17e Mon Sep 17 00:00:00 2001 From: Josh Bendavid Date: Fri, 12 Dec 2014 03:12:22 +0100 Subject: [PATCH 22/28] migrate fullsim relvals from pythia8+tauola to pythia8 tau decays --- .../python/relval_pileup.py | 6 +- .../python/relval_premix.py | 4 +- .../python/relval_standard.py | 16 ++-- .../python/relval_steps.py | 86 +++++++++---------- 4 files changed, 56 insertions(+), 56 deletions(-) diff --git a/Configuration/PyReleaseValidation/python/relval_pileup.py b/Configuration/PyReleaseValidation/python/relval_pileup.py index 9e13603b996b8..d0c3b2bbaefc8 100644 --- a/Configuration/PyReleaseValidation/python/relval_pileup.py +++ b/Configuration/PyReleaseValidation/python/relval_pileup.py @@ -14,7 +14,7 @@ #workflows[201]=['',['ZmumuJets_Pt_20_300','DIGIPU2','RECOPU2','HARVEST']] workflows[202]=['',['TTbar','DIGIPU1','RECOPU1','HARVEST']] workflows[203]=['',['H130GGgluonfusion','DIGIPU1','RECOPU1','HARVEST']] -workflows[204]=['',['QQH1352T_Tauola','DIGIPU1','RECOPU1','HARVEST']] +workflows[204]=['',['QQH1352T','DIGIPU1','RECOPU1','HARVEST']] workflows[205]=['',['ZTT','DIGIPU1','RECOPU1','HARVEST']] #heavy ions tests @@ -33,7 +33,7 @@ workflows[50200]=['',['ZEE_13','DIGIUP15_PU50','RECOUP15_PU50','HARVESTUP15','MINIAODMCUP1550']] workflows[50202]=['',['TTbar_13','DIGIUP15_PU50','RECOUP15_PU50','HARVESTUP15','MINIAODMCUP1550']] workflows[50203]=['',['H130GGgluonfusion_13','DIGIUP15_PU50','RECOUP15_PU50','HARVESTUP15','MINIAODMCUP1550']] -workflows[50204]=['',['QQH1352T_Tauola_13','DIGIUP15_PU50','RECOUP15_PU50','HARVESTUP15','MINIAODMCUP1550']] +workflows[50204]=['',['QQH1352T_13','DIGIUP15_PU50','RECOUP15_PU50','HARVESTUP15','MINIAODMCUP1550']] workflows[50205]=['',['ZTT_13','DIGIUP15_PU50','RECOUP15_PU50','HARVESTUP15','MINIAODMCUP1550']] workflows[50206]=['',['ZMM_13','DIGIUP15_PU50','RECOUP15_PU50','HARVESTUP15','MINIAODMCUP1550']] @@ -42,7 +42,7 @@ # workflows[25202]=['',['TTbar_13','DIGIUP15_PU25','RECOUP15_PU25','HARVESTUP15','MINIAODMCUP15']] workflows[25203]=['',['H130GGgluonfusion_13','DIGIUP15_PU25','RECOUP15_PU25','HARVESTUP15','MINIAODMCUP15']] -workflows[25204]=['',['QQH1352T_Tauola_13','DIGIUP15_PU25','RECOUP15_PU25','HARVESTUP15','MINIAODMCUP15']] +workflows[25204]=['',['QQH1352T_13','DIGIUP15_PU25','RECOUP15_PU25','HARVESTUP15','MINIAODMCUP15']] workflows[25205]=['',['ZTT_13','DIGIUP15_PU25','RECOUP15_PU25','HARVESTUP15','MINIAODMCUP15']] workflows[25206]=['',['ZMM_13','DIGIUP15_PU25','RECOUP15_PU25','HARVESTUP15','MINIAODMCUP15']] diff --git a/Configuration/PyReleaseValidation/python/relval_premix.py b/Configuration/PyReleaseValidation/python/relval_premix.py index dd376a17d799e..7d48e7ef2cfb4 100644 --- a/Configuration/PyReleaseValidation/python/relval_premix.py +++ b/Configuration/PyReleaseValidation/python/relval_premix.py @@ -18,7 +18,7 @@ workflows[250200]=['',['ZEE_13','DIGIPRMXUP15_PU25','RECOPRMXUP15_PU25','HARVEST']] workflows[250202]=['',['TTbar_13','DIGIPRMXUP15_PU25','RECOPRMXUP15_PU25','HARVEST']] workflows[250203]=['',['H130GGgluonfusion_13','DIGIPRMXUP15_PU25','RECOPRMXUP15_PU25','HARVEST']] -workflows[250204]=['',['QQH1352T_Tauola_13','DIGIPRMXUP15_PU25','RECOPRMXUP15_PU25','HARVEST']] +workflows[250204]=['',['QQH1352T_13','DIGIPRMXUP15_PU25','RECOPRMXUP15_PU25','HARVEST']] workflows[250205]=['',['ZTT_13','DIGIPRMXUP15_PU25','RECOPRMXUP15_PU25','HARVEST']] @@ -26,7 +26,7 @@ workflows[500200]=['',['ZEE_13','DIGIPRMXUP15_PU50','RECOPRMXUP15_PU50','HARVEST']] workflows[500202]=['',['TTbar_13','DIGIPRMXUP15_PU50','RECOPRMXUP15_PU50','HARVEST']] workflows[500203]=['',['H130GGgluonfusion_13','DIGIPRMXUP15_PU50','RECOPRMXUP15_PU50','HARVEST']] -workflows[500204]=['',['QQH1352T_Tauola_13','DIGIPRMXUP15_PU50','RECOPRMXUP15_PU50','HARVEST']] +workflows[500204]=['',['QQH1352T_13','DIGIPRMXUP15_PU50','RECOPRMXUP15_PU50','HARVEST']] workflows[500205]=['',['ZTT_13','DIGIPRMXUP15_PU50','RECOPRMXUP15_PU50','HARVEST']] # develop pile up overlay using premix prod-like! diff --git a/Configuration/PyReleaseValidation/python/relval_standard.py b/Configuration/PyReleaseValidation/python/relval_standard.py index 0cf40c638ffba..bd53058d8e0e8 100644 --- a/Configuration/PyReleaseValidation/python/relval_standard.py +++ b/Configuration/PyReleaseValidation/python/relval_standard.py @@ -162,7 +162,7 @@ workflows[31] = ['', ['ZTT','DIGI','RECO','HARVEST']] workflows[32] = ['', ['H130GGgluonfusion','DIGI','RECO','HARVEST']] workflows[33] = ['', ['PhotonJets_Pt_10','DIGI','RECO','HARVEST']] -workflows[34] = ['', ['QQH1352T_Tauola','DIGI','RECO','HARVEST']] +workflows[34] = ['', ['QQH1352T','DIGI','RECO','HARVEST']] #workflows[46] = ['', ['ZmumuJets_Pt_20_300']] workflows[7] = ['', ['Cosmics','DIGICOS','RECOCOS','ALCACOS','HARVESTCOS']] @@ -176,9 +176,9 @@ workflows[12] = ['', ['ZpMM','DIGI','RECO','HARVEST']] workflows[14] = ['', ['WpM','DIGI','RECO','HARVEST']] -workflows[43] = ['', ['ZpMM_2250_8TeV_Tauola','DIGI','RECO','HARVEST']] -workflows[44] = ['', ['ZpEE_2250_8TeV_Tauola','DIGI','RECO','HARVEST']] -workflows[45] = ['', ['ZpTT_1500_8TeV_Tauola','DIGI','RECO','HARVEST']] +workflows[43] = ['', ['ZpMM_2250_8TeV','DIGI','RECO','HARVEST']] +workflows[44] = ['', ['ZpEE_2250_8TeV','DIGI','RECO','HARVEST']] +workflows[45] = ['', ['ZpTT_1500_8TeV','DIGI','RECO','HARVEST']] ## 13 TeV and postLS1 geometry workflows[1324] = ['', ['TTbarLepton_13','DIGIUP15','RECOUP15','HARVESTUP15','MINIAODMCUP15']] @@ -203,7 +203,7 @@ workflows[1331] = ['', ['ZTT_13','DIGIUP15','RECOUP15','HARVESTUP15','MINIAODMCUP15']] workflows[1332] = ['', ['H130GGgluonfusion_13','DIGIUP15','RECOUP15','HARVESTUP15','MINIAODMCUP15']] workflows[1333] = ['', ['PhotonJets_Pt_10_13','DIGIUP15','RECOUP15','HARVESTUP15','MINIAODMCUP15']] -workflows[1334] = ['', ['QQH1352T_Tauola_13','DIGIUP15','RECOUP15','HARVESTUP15','MINIAODMCUP15']] +workflows[1334] = ['', ['QQH1352T_13','DIGIUP15','RECOUP15','HARVESTUP15','MINIAODMCUP15']] workflows[1307] = ['', ['Cosmics_UP15','DIGIHAL','RECOHAL','ALCAHAL','HARVESTHAL']] workflows[1308] = ['', ['BeamHalo_13','DIGIHAL','RECOHAL','ALCAHAL','HARVESTHAL']] @@ -219,9 +219,9 @@ workflows[1340] = ['', ['Pythia6_BuJpsiK_TuneZ2star_13','DIGIUP15','RECOUP15','HARVESTUP15','MINIAODMCUP15']] workflows[1341] = ['', ['RSKKGluon_m3000GeV_13','DIGIUP15','RECOUP15','HARVESTUP15','MINIAODMCUP15']] -workflows[1343] = ['', ['ZpMM_2250_13TeV_Tauola','DIGIUP15','RECOUP15','HARVESTUP15','MINIAODMCUP15']] -workflows[1344] = ['', ['ZpEE_2250_13TeV_Tauola','DIGIUP15','RECOUP15','HARVESTUP15','MINIAODMCUP15']] -workflows[1345] = ['', ['ZpTT_1500_13TeV_Tauola','DIGIUP15','RECOUP15','HARVESTUP15','MINIAODMCUP15']] +workflows[1343] = ['', ['ZpMM_2250_13TeV','DIGIUP15','RECOUP15','HARVESTUP15','MINIAODMCUP15']] +workflows[1344] = ['', ['ZpEE_2250_13TeV','DIGIUP15','RECOUP15','HARVESTUP15','MINIAODMCUP15']] +workflows[1345] = ['', ['ZpTT_1500_13TeV','DIGIUP15','RECOUP15','HARVESTUP15','MINIAODMCUP15']] ### HI test ### workflows[140] = ['',['HydjetQ_MinBias_2760GeV','DIGIHI','RECOHI','HARVESTHI']] diff --git a/Configuration/PyReleaseValidation/python/relval_steps.py b/Configuration/PyReleaseValidation/python/relval_steps.py index d5b5bbcbafafb..9637b80d4e2be 100644 --- a/Configuration/PyReleaseValidation/python/relval_steps.py +++ b/Configuration/PyReleaseValidation/python/relval_steps.py @@ -125,7 +125,7 @@ def merge(dictlist,TELL=False): #### Production test section #### steps['ProdMinBias']=merge([{'cfg':'MinBias_8TeV_pythia8_TuneCUETP8M1_cff','--relval':'9000,300'},step1Defaults]) -steps['ProdTTbar']=merge([{'cfg':'TTbar_Tauola_8TeV_TuneCUETP8M1_cfi','--relval':'9000,100'},step1Defaults]) +steps['ProdTTbar']=merge([{'cfg':'TTbar_8TeV_TuneCUETP8M1_cfi','--relval':'9000,100'},step1Defaults]) steps['ProdQCD_Pt_3000_3500']=merge([{'cfg':'QCD_Pt_3000_3500_8TeV_TuneCUETP8M1_cfi','--relval':'9000,50'},step1Defaults]) #### data #### @@ -250,7 +250,7 @@ def gen2015(fragment,howMuch): ### Production test: 13 TeV equivalents steps['ProdMinBias_13']=gen2015('MinBias_13TeV_pythia8_TuneCUETP8M1_cfi',Kby(9,100)) -steps['ProdTTbar_13']=gen2015('TTbar_Tauola_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ProdTTbar_13']=gen2015('TTbar_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['ProdZEE_13']=gen2015('ZEE_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['ProdQCD_Pt_3000_3500_13']=gen2015('QCD_Pt_3000_3500_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) @@ -285,16 +285,16 @@ def gen2015(fragment,howMuch): steps['SingleMuPt10_UP15']=gen2015('SingleMuPt10_pythia8_cfi',Kby(25,500)) steps['SingleMuPt100_UP15']=gen2015('SingleMuPt100_pythia8_cfi',Kby(9,500)) steps['SingleMuPt1000_UP15']=gen2015('SingleMuPt1000_pythia8_cfi',Kby(9,500)) -steps['TTbar']=gen('TTbar_Tauola_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) -steps['TTbarLepton']=gen('TTbarLepton_Tauola_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['TTbar']=gen('TTbar_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['TTbarLepton']=gen('TTbarLepton_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['ZEE']=gen('ZEE_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['Wjet_Pt_80_120']=gen('Wjet_Pt_80_120_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['Wjet_Pt_3000_3500']=gen('Wjet_Pt_3000_3500_8TeV_TuneCUETP8M1_cfi',Kby(9,50)) steps['LM1_sfts']=gen('LM1_sfts_8TeV_cfi',Kby(9,100)) steps['QCD_FlatPt_15_3000']=gen('QCDForPF_8TeV_TuneCUETP8M1_cfi',Kby(5,100)) steps['QCD_FlatPt_15_3000HS']=gen('QCDForPF_8TeV_TuneCUETP8M1_cfi',Kby(50,100)) -steps['TTbar_13']=gen2015('TTbar_Tauola_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) -steps['TTbarLepton_13']=gen2015('TTbarLepton_Tauola_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['TTbar_13']=gen2015('TTbar_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['TTbarLepton_13']=gen2015('TTbarLepton_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['ZEE_13']=gen2015('ZEE_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['Wjet_Pt_80_120_13']=gen2015('Wjet_Pt_80_120_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['Wjet_Pt_3000_3500_13']=gen2015('Wjet_Pt_3000_3500_13TeV_TuneCUETP8M1_cfi',Kby(9,50)) @@ -302,12 +302,12 @@ def gen2015(fragment,howMuch): steps['QCD_FlatPt_15_3000_13']=gen2015('QCDForPF_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['QCD_FlatPt_15_3000HS_13']=gen2015('QCDForPF_13TeV_TuneCUETP8M1_cfi',Kby(50,100)) -steps['ZpMM_2250_8TeV_Tauola']=gen('ZpMM_2250_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) -steps['ZpEE_2250_8TeV_Tauola']=gen('ZpEE_2250_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) -steps['ZpTT_1500_8TeV_Tauola']=gen('ZpTT_1500_8TeV_Tauola_TuneCUETP8M1_cfi',Kby(9,100)) -steps['ZpMM_2250_13TeV_Tauola']=gen2015('ZpMM_2250_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) -steps['ZpEE_2250_13TeV_Tauola']=gen2015('ZpEE_2250_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) -steps['ZpTT_1500_13TeV_Tauola']=gen2015('ZpTT_1500_13TeV_Tauola_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ZpMM_2250_8TeV']=gen('ZpMM_2250_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ZpEE_2250_8TeV']=gen('ZpEE_2250_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ZpTT_1500_8TeV']=gen('ZpTT_1500_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ZpMM_2250_13TeV']=gen2015('ZpMM_2250_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ZpEE_2250_13TeV']=gen2015('ZpEE_2250_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) +steps['ZpTT_1500_13TeV']=gen2015('ZpTT_1500_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) def identitySim(wf): return merge([{'--restoreRND':'SIM','--process':'SIM2', '--inputCommands':'"keep *","drop *TagInfo*_*_*_*"' },wf]) @@ -370,9 +370,9 @@ def identitySim(wf): steps['LM1_sfts_13INPUT']={'INPUT':InputInfo(dataSet='/RelValLM1_sfts_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} steps['QCD_FlatPt_15_3000_13INPUT']={'INPUT':InputInfo(dataSet='/RelValQCD_FlatPt_15_3000_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} steps['QCD_FlatPt_15_3000HS_13INPUT']={'INPUT':InputInfo(dataSet='/RelValQCD_FlatPt_15_3000HS_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} -steps['ZpMM_2250_13TeV_TauolaINPUT']={'INPUT':InputInfo(dataSet='/RelValZpMM_2250_13TeV_Tauola/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} -steps['ZpEE_2250_13TeV_TauolaINPUT']={'INPUT':InputInfo(dataSet='/RelValZpEE_2250_13TeV_Tauola/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} -steps['ZpTT_1500_13TeV_TauolaINPUT']={'INPUT':InputInfo(dataSet='/RelValZpTT_1500_13TeV_Tauola/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} +steps['ZpMM_2250_13TeVINPUT']={'INPUT':InputInfo(dataSet='/RelValZpMM_2250_13TeV_Tauola/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} +steps['ZpEE_2250_13TeVINPUT']={'INPUT':InputInfo(dataSet='/RelValZpEE_2250_13TeV_Tauola/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} +steps['ZpTT_1500_13TeVINPUT']={'INPUT':InputInfo(dataSet='/RelValZpTT_1500_13TeV_Tauola/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} steps['MinBiasHS_13INPUT']={'INPUT':InputInfo(dataSet='/RelValMinBiasHS_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} steps['Higgs200ChargedTaus_13INPUT']={'INPUT':InputInfo(dataSet='/RelValHiggs200ChargedTaus_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} @@ -392,7 +392,7 @@ def identitySim(wf): steps['H130GGgluonfusion_13INPUT']={'INPUT':InputInfo(dataSet='/RelValH130GGgluonfusion_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} steps['PhotonJets_Pt_10_13INPUT']={'INPUT':InputInfo(dataSet='/RelValPhotonJets_Pt_10_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} steps['PhotonJets_Pt_10_13_HIINPUT']={'INPUT':InputInfo(dataSet='/RelValPhotonJets_Pt_10_13_HI/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} -steps['QQH1352T_Tauola_13INPUT']={'INPUT':InputInfo(dataSet='/RelValQQH1352T_Tauola_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} +steps['QQH1352T_13INPUT']={'INPUT':InputInfo(dataSet='/RelValQQH1352T_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} steps['ADDMonoJet_d3MD3_13INPUT']={'INPUT':InputInfo(dataSet='/RelValADDMonoJet_d3MD3_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} steps['RSKKGluon_m3000GeV_13INPUT']={'INPUT':InputInfo(dataSet='/RelValRSKKGluon_m3000GeV_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} steps['Pythia6_BuJpsiK_TuneZ2star_13INPUT']={'INPUT':InputInfo(dataSet='/RelValPythia6_BuJpsiK_TuneZ2star_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} @@ -442,14 +442,14 @@ def genS(fragment,howMuch): global step1Defaults,stCond return merge([{'cfg':fragment},stCond,howMuch,step1Defaults]) -steps['Higgs200ChargedTaus']=genS('H200ChargedTaus_Tauola_8TeV_cfi',Kby(9,100)) +steps['Higgs200ChargedTaus']=genS('H200ChargedTaus_8TeV_cfi',Kby(9,100)) steps['JpsiMM']=genS('JpsiMM_8TeV_TuneCUETP8M1_cfi',Kby(66,1000)) steps['WE']=genS('WE_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['WM']=genS('WM_8TeV_TuneCUETP8M1_cfi',Kby(9,200)) steps['WpM']=genS('WpM_8TeV_TuneCUETP8M1_cfi',Kby(9,200)) steps['ZMM']=genS('ZMM_8TeV_TuneCUETP8M1_cfi',Kby(18,300)) steps['ZpMM']=genS('ZpMM_8TeV_TuneCUETP8M1_cfi',Kby(9,200)) -steps['Higgs200ChargedTaus_13']=gen2015('H200ChargedTaus_Tauola_13TeV_cfi',Kby(9,100)) +steps['Higgs200ChargedTaus_13']=gen2015('H200ChargedTaus_13TeV_cfi',Kby(9,100)) steps['Upsilon1SToMuMu_13']=gen2015('Upsilon1SToMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi',Kby(17,190)) steps['BuToKstarMuMu_13']=gen2015('BuToKstarMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi',Kby(2250,25000)) steps['BsToMuMu_13']=gen2015('BsToMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi',Kby(30000,333333)) @@ -461,14 +461,14 @@ def genS(fragment,howMuch): steps['ZMM_13']=gen2015('ZMM_13TeV_TuneCUETP8M1_cfi',Kby(18,300)) steps['ZpMM_13']=gen2015('ZpMM_13TeV_TuneCUETP8M1_cfi',Kby(9,200)) -steps['ZTT']=genS('ZTT_Tauola_All_hadronic_8TeV_TuneCUETP8M1_cfi',Kby(9,150)) +steps['ZTT']=genS('ZTT_All_hadronic_8TeV_TuneCUETP8M1_cfi',Kby(9,150)) steps['H130GGgluonfusion']=genS('H130GGgluonfusion_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['PhotonJets_Pt_10']=genS('PhotonJet_Pt_10_8TeV_TuneCUETP8M1_cfi',Kby(9,150)) -steps['QQH1352T_Tauola']=genS('QQH1352T_Tauola_8TeV_cfi',Kby(9,100)) -steps['ZTT_13']=gen2015('ZTT_Tauola_All_hadronic_13TeV_TuneCUETP8M1_cfi',Kby(9,150)) +steps['QQH1352T']=genS('QQH1352T_8TeV_cfi',Kby(9,100)) +steps['ZTT_13']=gen2015('ZTT_All_hadronic_13TeV_TuneCUETP8M1_cfi',Kby(9,150)) steps['H130GGgluonfusion_13']=gen2015('H130GGgluonfusion_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['PhotonJets_Pt_10_13']=gen2015('PhotonJet_Pt_10_13TeV_TuneCUETP8M1_cfi',Kby(9,150)) -steps['QQH1352T_Tauola_13']=gen2015('QQH1352T_Tauola_13TeV_cfi',Kby(9,100)) +steps['QQH1352T_13']=gen2015('QQH1352T_13TeV_cfi',Kby(9,100)) #steps['ZmumuJets_Pt_20_300']=gen('ZmumuJets_Pt_20_300_GEN_8TeV_TuneCUETP8M1_cfg',Kby(25,100)) steps['ADDMonoJet_d3MD3']=genS('ADDMonoJet_8TeV_d3MD3_TuneCUETP8M1_cfi',Kby(9,100)) steps['ADDMonoJet_d3MD3_13']=gen2015('ADDMonoJet_13TeV_d3MD3_TuneCUETP8M1_cfi',Kby(9,100)) @@ -488,13 +488,13 @@ def genS(fragment,howMuch): steps['ZTTINPUT']={'INPUT':InputInfo(dataSet='/RelValZTT/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} steps['H130GGgluonfusionINPUT']={'INPUT':InputInfo(dataSet='/RelValH130GGgluonfusion/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} steps['PhotonJets_Pt_10INPUT']={'INPUT':InputInfo(dataSet='/RelValPhotonJets_Pt_10/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} -steps['QQH1352T_TauolaINPUT']={'INPUT':InputInfo(dataSet='/RelValQQH1352T_Tauola/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} +steps['QQH1352TINPUT']={'INPUT':InputInfo(dataSet='/RelValQQH1352T_Tauola/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} steps['ADDMonoJet_d3MD3INPUT']={'INPUT':InputInfo(dataSet='/RelValADDMonoJet_d3MD3/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} steps['WpMINPUT']={'INPUT':InputInfo(dataSet='/RelValWpM/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} steps['ZpMMINPUT']={'INPUT':InputInfo(dataSet='/RelValZpMM/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} -steps['ZpMM_2250_8TeV_TauolaINPUT']={'INPUT':InputInfo(dataSet='/RelValZpMM_2250_8TeV_Tauola/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} -steps['ZpEE_2250_8TeV_TauolaINPUT']={'INPUT':InputInfo(dataSet='/RelValZpEE_2250_8TeV_Tauola/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} -steps['ZpTT_1500_8TeV_TauolaINPUT']={'INPUT':InputInfo(dataSet='/RelValZpTT_1500_8TeV_Tauola/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} +steps['ZpMM_2250_8TeVINPUT']={'INPUT':InputInfo(dataSet='/RelValZpMM_2250_8TeV_Tauola/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} +steps['ZpEE_2250_8TeVINPUT']={'INPUT':InputInfo(dataSet='/RelValZpEE_2250_8TeV_Tauola/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} +steps['ZpTT_1500_8TeVINPUT']={'INPUT':InputInfo(dataSet='/RelValZpTT_1500_8TeV_Tauola/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} steps['Cosmics']=merge([{'cfg':'UndergroundCosmicMu_cfi.py','--scenario':'cosmics'},Kby(666,100000),step1Defaults]) @@ -513,13 +513,13 @@ def genS(fragment,howMuch): steps['TTbar2HS']=merge([Kby(25,100),steps['TTbar']]) steps['JpsiMM_Pt_20_inf']=genS('JpsiMM_Pt_20_inf_8TeV_TuneCUETP8M1_cfi',Kby(70,280)) steps['QCD_Pt_120_170']=genS('QCD_Pt_120_170_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) -steps['H165WW2L']=genS('H165WW2L_Tauola_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) +steps['H165WW2L']=genS('H165WW2L_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) steps['UpsMM']=genS('UpsMM_8TeV_TuneCUETP8M1_cfi',Kby(56250,225)) steps['RSGrav']=genS('RS750_quarks_and_leptons_8TeV_TuneCUETP8M1_cff',Kby(25,100)) steps['QCD_Pt_80_120_2HS']=merge([Kby(25,100),steps['QCD_Pt_80_120']]) steps['bJpsiX']=genS('bJpsiX_8TeV_TuneCUETP8M1_cfi',Mby(325,1300000)) steps['QCD_Pt_30_50']=genS('QCD_Pt_30_50_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) -steps['H200ZZ4L']=genS('H200ZZ4L_Tauola_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) +steps['H200ZZ4L']=genS('H200ZZ4L_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) steps['LM9p']=genS('LM9p_8TeV_cff',Kby(25,100)) steps['QCD_Pt_20_30']=genS('QCD_Pt_20_30_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) steps['QCD_Pt_170_230']=genS('QCD_Pt_170_230_8TeV_TuneCUETP8M1_cfi',Kby(25,100)) @@ -598,7 +598,7 @@ def addForAll(steps,d): #step1FastDefaults -steps['TTbarFS']=merge([{'cfg':'TTbar_Tauola_8TeV_TuneCUETP8M1_cfi'},Kby(100,1000),step1FastDefaults]) +steps['TTbarFS']=merge([{'cfg':'TTbar_8TeV_TuneCUETP8M1_cfi'},Kby(100,1000),step1FastDefaults]) steps['SingleMuPt1FS']=merge([{'cfg':'SingleMuPt1_pythia8_cfi'},step1FastDefaults]) steps['SingleMuPt10FS']=merge([{'cfg':'SingleMuPt10_pythia8_cfi'},step1FastDefaults]) steps['SingleMuPt100FS']=merge([{'cfg':'SingleMuPt100_pythia8_cfi'},step1FastDefaults]) @@ -606,7 +606,7 @@ def addForAll(steps,d): steps['SinglePiPt10FS']=merge([{'cfg':'SinglePiPt10_pythia8_cfi'},step1FastDefaults]) steps['SinglePiPt100FS']=merge([{'cfg':'SinglePiPt100_pythia8_cfi'},step1FastDefaults]) steps['ZEEFS']=merge([{'cfg':'ZEE_8TeV_TuneCUETP8M1_cfi'},Kby(100,2000),step1FastDefaults]) -steps['ZTTFS']=merge([{'cfg':'ZTT_Tauola_OneLepton_OtherHadrons_8TeV_TuneCUETP8M1_cfi'},Kby(100,2000),step1FastDefaults]) +steps['ZTTFS']=merge([{'cfg':'ZTT_OneLepton_OtherHadrons_8TeV_TuneCUETP8M1_cfi'},Kby(100,2000),step1FastDefaults]) steps['QCDFlatPt153000FS']=merge([{'cfg':'QCDForPF_8TeV_TuneCUETP8M1_cfi'},Kby(27,2000),step1FastDefaults]) steps['QCD_Pt_80_120FS']=merge([{'cfg':'QCD_Pt_80_120_8TeV_TuneCUETP8M1_cfi'},Kby(100,500),stCond,step1FastDefaults]) steps['QCD_Pt_3000_3500FS']=merge([{'cfg':'QCD_Pt_3000_3500_8TeV_TuneCUETP8M1_cfi'},Kby(100,500),stCond,step1FastDefaults]) @@ -614,9 +614,9 @@ def addForAll(steps,d): steps['SingleGammaFlatPt10To10FS']=merge([{'cfg':'SingleGammaFlatPt10To100_pythia8_cfi'},Kby(100,500),step1FastDefaults]) #step1FastUpg2015Defaults -steps['TTbarFS_13']=merge([{'cfg':'TTbar_Tauola_13TeV_TuneCUETP8M1_cfi'},Kby(100,1000),step1FastUpg2015Defaults]) +steps['TTbarFS_13']=merge([{'cfg':'TTbar_13TeV_TuneCUETP8M1_cfi'},Kby(100,1000),step1FastUpg2015Defaults]) steps['ZEEFS_13']=merge([{'cfg':'ZEE_13TeV_TuneCUETP8M1_cfi'},Kby(100,2000),step1FastUpg2015Defaults]) -steps['ZTTFS_13']=merge([{'cfg':'ZTT_Tauola_OneLepton_OtherHadrons_13TeV_TuneCUETP8M1_cfi'},Kby(100,2000),step1FastUpg2015Defaults]) +steps['ZTTFS_13']=merge([{'cfg':'ZTT_OneLepton_OtherHadrons_13TeV_TuneCUETP8M1_cfi'},Kby(100,2000),step1FastUpg2015Defaults]) steps['QCDFlatPt153000FS_13']=merge([{'cfg':'QCDForPF_13TeV_TuneCUETP8M1_cfi'},Kby(27,2000),step1FastUpg2015Defaults]) steps['QCD_Pt_80_120FS_13']=merge([{'cfg':'QCD_Pt_80_120_13TeV_TuneCUETP8M1_cfi'},Kby(100,500),step1FastUpg2015Defaults]) steps['QCD_Pt_3000_3500FS_13']=merge([{'cfg':'QCD_Pt_3000_3500_13TeV_TuneCUETP8M1_cfi'},Kby(100,500),step1FastUpg2015Defaults]) @@ -627,14 +627,14 @@ def addForAll(steps,d): #step1FastPU steps['MinBiasFS_13_ForMixing']=merge([{'cfg':'MinBias_13TeV_pythia8_TuneCUETP8M1_cfi'},Kby(100,1000),step1FastPUNewMixing]) -steps['TTbarSFS']=merge([{'cfg':'TTbar_Tauola_8TeV_TuneCUETP8M1_cfi'}, +steps['TTbarSFS']=merge([{'cfg':'TTbar_8TeV_TuneCUETP8M1_cfi'}, {'-s':'GEN,SIM', '--eventcontent':'FEVTDEBUG', '--datatier':'GEN-SIM', '--fast':''}, step1Defaults]) -steps['TTbarSFSA']=merge([{'cfg':'TTbar_Tauola_8TeV_TuneCUETP8M1_cfi', +steps['TTbarSFSA']=merge([{'cfg':'TTbar_8TeV_TuneCUETP8M1_cfi', '-s':'GEN,SIM,RECO,EI,HLT:@fake,VALIDATION', '--fast':''}, step1FastDefaults]) @@ -711,17 +711,17 @@ def genvalid(fragment,d,suffix='all',fi='',dataSet=''): # Generator External Decays steps['TT_13TeV_pythia8-evtgen']=genvalid('Hadronizer_MgmMatchTuneCUETP8M1_13TeV_madgraph_pythia8_EvtGen_cff',step1GenDefaults,dataSet='/TTJets_MSDecaysCKM_central_13TeV-madgraph/Fall13wmLHE-START62_V1-v1/GEN') -steps['Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_Tauola']=genvalid('Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_Tauola_cff',step1GenDefaults) -steps['WToLNu_13TeV_pythia8-tauola']=genvalid('Hadronizer_MgmMatchTuneCUETP8M1_13TeV_madgraph_pythia8_Tauola_cff',step1GenDefaults,dataSet='/WJetsToLNu_13TeV-madgraph/Fall13wmLHE-START62_V1-v1/GEN') -steps['GGToH_13TeV_pythia8-tauola']=genvalid('GGToHtautau_13TeV_pythia8_Tauola_cff',step1GenDefaults) +steps['Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8']=genvalid('Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_cff',step1GenDefaults) +steps['WToLNu_13TeV_pythia8-tauola']=genvalid('Hadronizer_MgmMatchTuneCUETP8M1_13TeV_madgraph_pythia8_cff',step1GenDefaults,dataSet='/WJetsToLNu_13TeV-madgraph/Fall13wmLHE-START62_V1-v1/GEN') +steps['GGToH_13TeV_pythia8-tauola']=genvalid('GGToHtautau_13TeV_pythia8_cff',step1GenDefaults) -steps['WToLNutaupinu_13TeV_pythia8-tauola']=genvalid('Hadronizer_MgmMatchTuneCUETP8M1_13TeV_madgraph_pythia8_Tauola_taupinu_cff',step1GenDefaults,dataSet='/WJetsToLNu_13TeV-madgraph/Fall13wmLHE-START62_V1-v1/GEN') -steps['Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_Tauola_taupinu']=genvalid('Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_Tauola_taupinu_cff',step1GenDefaults) -steps['GGToHtaupinu_13TeV_pythia8-tauola']=genvalid('GGToHtautau_13TeV_pythia8_Tauola_taupinu_cff',step1GenDefaults) +steps['WToLNutaupinu_13TeV_pythia8-tauola']=genvalid('Hadronizer_MgmMatchTuneCUETP8M1_13TeV_madgraph_pythia8_taupinu_cff',step1GenDefaults,dataSet='/WJetsToLNu_13TeV-madgraph/Fall13wmLHE-START62_V1-v1/GEN') +steps['Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_taupinu']=genvalid('Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_taupinu_cff',step1GenDefaults) +steps['GGToHtaupinu_13TeV_pythia8-tauola']=genvalid('GGToHtautau_13TeV_pythia8_taupinu_cff',step1GenDefaults) -steps['WToLNutaurhonu_13TeV_pythia8-tauola']=genvalid('Hadronizer_MgmMatchTuneCUETP8M1_13TeV_madgraph_pythia8_Tauola_taurhonu_cff',step1GenDefaults,dataSet='/WJetsToLNu_13TeV-madgraph/Fall13wmLHE-START62_V1-v1/GEN') -steps['Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_Tauola_taurhonu']=genvalid('Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_Tauola_taurhonu_cff',step1GenDefaults) -steps['GGToHtaurhonu_13TeV_pythia8-tauola']=genvalid('GGToHtautau_13TeV_pythia8_Tauola_taurhonu_cff',step1GenDefaults) +steps['WToLNutaurhonu_13TeV_pythia8-tauola']=genvalid('Hadronizer_MgmMatchTuneCUETP8M1_13TeV_madgraph_pythia8_taurhonu_cff',step1GenDefaults,dataSet='/WJetsToLNu_13TeV-madgraph/Fall13wmLHE-START62_V1-v1/GEN') +steps['Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_taurhonu']=genvalid('Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_taurhonu_cff',step1GenDefaults) +steps['GGToHtaurhonu_13TeV_pythia8-tauola']=genvalid('GGToHtautau_13TeV_pythia8_taurhonu_cff',step1GenDefaults) # Heavy Ion steps['ReggeGribovPartonMC_EposLHC_5TeV_pPb']=genvalid('GeneratorInterface/ReggeGribovPartonMCInterface/ReggeGribovPartonMC_EposLHC_5TeV_pPb_cfi',step1GenDefaults) From 7f77aecdb83c26f80a32b39e10985243b635360a Mon Sep 17 00:00:00 2001 From: Josh Bendavid Date: Fri, 12 Dec 2014 03:30:33 +0100 Subject: [PATCH 23/28] add back tauola where it should not have been removed --- .../python/relval_steps.py | 32 +++++++++---------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/Configuration/PyReleaseValidation/python/relval_steps.py b/Configuration/PyReleaseValidation/python/relval_steps.py index 9637b80d4e2be..e1bec2477fa28 100644 --- a/Configuration/PyReleaseValidation/python/relval_steps.py +++ b/Configuration/PyReleaseValidation/python/relval_steps.py @@ -392,7 +392,7 @@ def identitySim(wf): steps['H130GGgluonfusion_13INPUT']={'INPUT':InputInfo(dataSet='/RelValH130GGgluonfusion_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} steps['PhotonJets_Pt_10_13INPUT']={'INPUT':InputInfo(dataSet='/RelValPhotonJets_Pt_10_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} steps['PhotonJets_Pt_10_13_HIINPUT']={'INPUT':InputInfo(dataSet='/RelValPhotonJets_Pt_10_13_HI/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} -steps['QQH1352T_13INPUT']={'INPUT':InputInfo(dataSet='/RelValQQH1352T_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} +steps['QQH1352T_13INPUT']={'INPUT':InputInfo(dataSet='/RelValQQH1352T_Tauola_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} steps['ADDMonoJet_d3MD3_13INPUT']={'INPUT':InputInfo(dataSet='/RelValADDMonoJet_d3MD3_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} steps['RSKKGluon_m3000GeV_13INPUT']={'INPUT':InputInfo(dataSet='/RelValRSKKGluon_m3000GeV_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} steps['Pythia6_BuJpsiK_TuneZ2star_13INPUT']={'INPUT':InputInfo(dataSet='/RelValPythia6_BuJpsiK_TuneZ2star_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} @@ -442,14 +442,14 @@ def genS(fragment,howMuch): global step1Defaults,stCond return merge([{'cfg':fragment},stCond,howMuch,step1Defaults]) -steps['Higgs200ChargedTaus']=genS('H200ChargedTaus_8TeV_cfi',Kby(9,100)) +steps['Higgs200ChargedTaus']=genS('H200ChargedTaus_Tauola_8TeV_cfi',Kby(9,100)) steps['JpsiMM']=genS('JpsiMM_8TeV_TuneCUETP8M1_cfi',Kby(66,1000)) steps['WE']=genS('WE_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['WM']=genS('WM_8TeV_TuneCUETP8M1_cfi',Kby(9,200)) steps['WpM']=genS('WpM_8TeV_TuneCUETP8M1_cfi',Kby(9,200)) steps['ZMM']=genS('ZMM_8TeV_TuneCUETP8M1_cfi',Kby(18,300)) steps['ZpMM']=genS('ZpMM_8TeV_TuneCUETP8M1_cfi',Kby(9,200)) -steps['Higgs200ChargedTaus_13']=gen2015('H200ChargedTaus_13TeV_cfi',Kby(9,100)) +steps['Higgs200ChargedTaus_13']=gen2015('H200ChargedTaus_Tauola_13TeV_cfi',Kby(9,100)) steps['Upsilon1SToMuMu_13']=gen2015('Upsilon1SToMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi',Kby(17,190)) steps['BuToKstarMuMu_13']=gen2015('BuToKstarMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi',Kby(2250,25000)) steps['BsToMuMu_13']=gen2015('BsToMuMu_forSTEAM_13TeV_TuneCUETP8M1_cfi',Kby(30000,333333)) @@ -464,11 +464,11 @@ def genS(fragment,howMuch): steps['ZTT']=genS('ZTT_All_hadronic_8TeV_TuneCUETP8M1_cfi',Kby(9,150)) steps['H130GGgluonfusion']=genS('H130GGgluonfusion_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['PhotonJets_Pt_10']=genS('PhotonJet_Pt_10_8TeV_TuneCUETP8M1_cfi',Kby(9,150)) -steps['QQH1352T']=genS('QQH1352T_8TeV_cfi',Kby(9,100)) +steps['QQH1352T']=genS('QQH1352T_Tauola_8TeV_cfi',Kby(9,100)) steps['ZTT_13']=gen2015('ZTT_All_hadronic_13TeV_TuneCUETP8M1_cfi',Kby(9,150)) steps['H130GGgluonfusion_13']=gen2015('H130GGgluonfusion_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['PhotonJets_Pt_10_13']=gen2015('PhotonJet_Pt_10_13TeV_TuneCUETP8M1_cfi',Kby(9,150)) -steps['QQH1352T_13']=gen2015('QQH1352T_13TeV_cfi',Kby(9,100)) +steps['QQH1352T_13']=gen2015('QQH1352T_Tauola_13TeV_cfi',Kby(9,100)) #steps['ZmumuJets_Pt_20_300']=gen('ZmumuJets_Pt_20_300_GEN_8TeV_TuneCUETP8M1_cfg',Kby(25,100)) steps['ADDMonoJet_d3MD3']=genS('ADDMonoJet_8TeV_d3MD3_TuneCUETP8M1_cfi',Kby(9,100)) steps['ADDMonoJet_d3MD3_13']=gen2015('ADDMonoJet_13TeV_d3MD3_TuneCUETP8M1_cfi',Kby(9,100)) @@ -606,7 +606,7 @@ def addForAll(steps,d): steps['SinglePiPt10FS']=merge([{'cfg':'SinglePiPt10_pythia8_cfi'},step1FastDefaults]) steps['SinglePiPt100FS']=merge([{'cfg':'SinglePiPt100_pythia8_cfi'},step1FastDefaults]) steps['ZEEFS']=merge([{'cfg':'ZEE_8TeV_TuneCUETP8M1_cfi'},Kby(100,2000),step1FastDefaults]) -steps['ZTTFS']=merge([{'cfg':'ZTT_OneLepton_OtherHadrons_8TeV_TuneCUETP8M1_cfi'},Kby(100,2000),step1FastDefaults]) +steps['ZTTFS']=merge([{'cfg':'ZTT_Tauola_OneLepton_OtherHadrons_8TeV_TuneCUETP8M1_cfi'},Kby(100,2000),step1FastDefaults]) steps['QCDFlatPt153000FS']=merge([{'cfg':'QCDForPF_8TeV_TuneCUETP8M1_cfi'},Kby(27,2000),step1FastDefaults]) steps['QCD_Pt_80_120FS']=merge([{'cfg':'QCD_Pt_80_120_8TeV_TuneCUETP8M1_cfi'},Kby(100,500),stCond,step1FastDefaults]) steps['QCD_Pt_3000_3500FS']=merge([{'cfg':'QCD_Pt_3000_3500_8TeV_TuneCUETP8M1_cfi'},Kby(100,500),stCond,step1FastDefaults]) @@ -616,7 +616,7 @@ def addForAll(steps,d): #step1FastUpg2015Defaults steps['TTbarFS_13']=merge([{'cfg':'TTbar_13TeV_TuneCUETP8M1_cfi'},Kby(100,1000),step1FastUpg2015Defaults]) steps['ZEEFS_13']=merge([{'cfg':'ZEE_13TeV_TuneCUETP8M1_cfi'},Kby(100,2000),step1FastUpg2015Defaults]) -steps['ZTTFS_13']=merge([{'cfg':'ZTT_OneLepton_OtherHadrons_13TeV_TuneCUETP8M1_cfi'},Kby(100,2000),step1FastUpg2015Defaults]) +steps['ZTTFS_13']=merge([{'cfg':'ZTT_Tauola_OneLepton_OtherHadrons_13TeV_TuneCUETP8M1_cfi'},Kby(100,2000),step1FastUpg2015Defaults]) steps['QCDFlatPt153000FS_13']=merge([{'cfg':'QCDForPF_13TeV_TuneCUETP8M1_cfi'},Kby(27,2000),step1FastUpg2015Defaults]) steps['QCD_Pt_80_120FS_13']=merge([{'cfg':'QCD_Pt_80_120_13TeV_TuneCUETP8M1_cfi'},Kby(100,500),step1FastUpg2015Defaults]) steps['QCD_Pt_3000_3500FS_13']=merge([{'cfg':'QCD_Pt_3000_3500_13TeV_TuneCUETP8M1_cfi'},Kby(100,500),step1FastUpg2015Defaults]) @@ -711,17 +711,17 @@ def genvalid(fragment,d,suffix='all',fi='',dataSet=''): # Generator External Decays steps['TT_13TeV_pythia8-evtgen']=genvalid('Hadronizer_MgmMatchTuneCUETP8M1_13TeV_madgraph_pythia8_EvtGen_cff',step1GenDefaults,dataSet='/TTJets_MSDecaysCKM_central_13TeV-madgraph/Fall13wmLHE-START62_V1-v1/GEN') -steps['Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8']=genvalid('Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_cff',step1GenDefaults) -steps['WToLNu_13TeV_pythia8-tauola']=genvalid('Hadronizer_MgmMatchTuneCUETP8M1_13TeV_madgraph_pythia8_cff',step1GenDefaults,dataSet='/WJetsToLNu_13TeV-madgraph/Fall13wmLHE-START62_V1-v1/GEN') -steps['GGToH_13TeV_pythia8-tauola']=genvalid('GGToHtautau_13TeV_pythia8_cff',step1GenDefaults) +steps['Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_Tauola']=genvalid('Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_Tauola_cff',step1GenDefaults) +steps['WToLNu_13TeV_pythia8-tauola']=genvalid('Hadronizer_MgmMatchTuneCUETP8M1_13TeV_madgraph_pythia8_Tauola_cff',step1GenDefaults,dataSet='/WJetsToLNu_13TeV-madgraph/Fall13wmLHE-START62_V1-v1/GEN') +steps['GGToH_13TeV_pythia8-tauola']=genvalid('GGToHtautau_13TeV_pythia8_Tauola_cff',step1GenDefaults) -steps['WToLNutaupinu_13TeV_pythia8-tauola']=genvalid('Hadronizer_MgmMatchTuneCUETP8M1_13TeV_madgraph_pythia8_taupinu_cff',step1GenDefaults,dataSet='/WJetsToLNu_13TeV-madgraph/Fall13wmLHE-START62_V1-v1/GEN') -steps['Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_taupinu']=genvalid('Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_taupinu_cff',step1GenDefaults) -steps['GGToHtaupinu_13TeV_pythia8-tauola']=genvalid('GGToHtautau_13TeV_pythia8_taupinu_cff',step1GenDefaults) +steps['WToLNutaupinu_13TeV_pythia8-tauola']=genvalid('Hadronizer_MgmMatchTuneCUETP8M1_13TeV_madgraph_pythia8_Tauola_taupinu_cff',step1GenDefaults,dataSet='/WJetsToLNu_13TeV-madgraph/Fall13wmLHE-START62_V1-v1/GEN') +steps['Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_Tauola_taupinu']=genvalid('Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_Tauola_taupinu_cff',step1GenDefaults) +steps['GGToHtaupinu_13TeV_pythia8-tauola']=genvalid('GGToHtautau_13TeV_pythia8_Tauola_taupinu_cff',step1GenDefaults) -steps['WToLNutaurhonu_13TeV_pythia8-tauola']=genvalid('Hadronizer_MgmMatchTuneCUETP8M1_13TeV_madgraph_pythia8_taurhonu_cff',step1GenDefaults,dataSet='/WJetsToLNu_13TeV-madgraph/Fall13wmLHE-START62_V1-v1/GEN') -steps['Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_taurhonu']=genvalid('Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_taurhonu_cff',step1GenDefaults) -steps['GGToHtaurhonu_13TeV_pythia8-tauola']=genvalid('GGToHtautau_13TeV_pythia8_taurhonu_cff',step1GenDefaults) +steps['WToLNutaurhonu_13TeV_pythia8-tauola']=genvalid('Hadronizer_MgmMatchTuneCUETP8M1_13TeV_madgraph_pythia8_Tauola_taurhonu_cff',step1GenDefaults,dataSet='/WJetsToLNu_13TeV-madgraph/Fall13wmLHE-START62_V1-v1/GEN') +steps['Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_Tauola_taurhonu']=genvalid('Hadronizer_TuneCUETP8M1_13TeV_MLM_5f_max4j_LHE_pythia8_Tauola_taurhonu_cff',step1GenDefaults) +steps['GGToHtaurhonu_13TeV_pythia8-tauola']=genvalid('GGToHtautau_13TeV_pythia8_Tauola_taurhonu_cff',step1GenDefaults) # Heavy Ion steps['ReggeGribovPartonMC_EposLHC_5TeV_pPb']=genvalid('GeneratorInterface/ReggeGribovPartonMCInterface/ReggeGribovPartonMC_EposLHC_5TeV_pPb_cfi',step1GenDefaults) From 5970f82e8ce7eb79b559a9bb4f751766863d14f5 Mon Sep 17 00:00:00 2001 From: Josh Bendavid Date: Fri, 12 Dec 2014 03:49:43 +0100 Subject: [PATCH 24/28] migrate a few additional workflows to pythia8 --- ...1_cfi.py => Pythia8_BuJpsiK_13TeV_TuneCUETP8M1_cfi.py} | 0 .../PyReleaseValidation/python/relval_standard.py | 2 +- Configuration/PyReleaseValidation/python/relval_steps.py | 8 ++++---- 3 files changed, 5 insertions(+), 5 deletions(-) rename Configuration/Generator/python/{Pythia8_BuJpsiK_TuneZ2star_13TeV_TuneCUETP8M1_cfi.py => Pythia8_BuJpsiK_13TeV_TuneCUETP8M1_cfi.py} (100%) diff --git a/Configuration/Generator/python/Pythia8_BuJpsiK_TuneZ2star_13TeV_TuneCUETP8M1_cfi.py b/Configuration/Generator/python/Pythia8_BuJpsiK_13TeV_TuneCUETP8M1_cfi.py similarity index 100% rename from Configuration/Generator/python/Pythia8_BuJpsiK_TuneZ2star_13TeV_TuneCUETP8M1_cfi.py rename to Configuration/Generator/python/Pythia8_BuJpsiK_13TeV_TuneCUETP8M1_cfi.py diff --git a/Configuration/PyReleaseValidation/python/relval_standard.py b/Configuration/PyReleaseValidation/python/relval_standard.py index bd53058d8e0e8..6576a2f09b01e 100644 --- a/Configuration/PyReleaseValidation/python/relval_standard.py +++ b/Configuration/PyReleaseValidation/python/relval_standard.py @@ -216,7 +216,7 @@ workflows[1312] = ['', ['ZpMM_13','DIGIUP15','RECOUP15','HARVESTUP15','MINIAODMCUP15']] workflows[1314] = ['', ['WpM_13','DIGIUP15','RECOUP15','HARVESTUP15','MINIAODMCUP15']] -workflows[1340] = ['', ['Pythia6_BuJpsiK_TuneZ2star_13','DIGIUP15','RECOUP15','HARVESTUP15','MINIAODMCUP15']] +workflows[1340] = ['', ['BuJpsiK_13','DIGIUP15','RECOUP15','HARVESTUP15','MINIAODMCUP15']] workflows[1341] = ['', ['RSKKGluon_m3000GeV_13','DIGIUP15','RECOUP15','HARVESTUP15','MINIAODMCUP15']] workflows[1343] = ['', ['ZpMM_2250_13TeV','DIGIUP15','RECOUP15','HARVESTUP15','MINIAODMCUP15']] diff --git a/Configuration/PyReleaseValidation/python/relval_steps.py b/Configuration/PyReleaseValidation/python/relval_steps.py index e1bec2477fa28..4ef94284baf72 100644 --- a/Configuration/PyReleaseValidation/python/relval_steps.py +++ b/Configuration/PyReleaseValidation/python/relval_steps.py @@ -395,7 +395,7 @@ def identitySim(wf): steps['QQH1352T_13INPUT']={'INPUT':InputInfo(dataSet='/RelValQQH1352T_Tauola_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} steps['ADDMonoJet_d3MD3_13INPUT']={'INPUT':InputInfo(dataSet='/RelValADDMonoJet_d3MD3_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} steps['RSKKGluon_m3000GeV_13INPUT']={'INPUT':InputInfo(dataSet='/RelValRSKKGluon_m3000GeV_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} -steps['Pythia6_BuJpsiK_TuneZ2star_13INPUT']={'INPUT':InputInfo(dataSet='/RelValPythia6_BuJpsiK_TuneZ2star_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} +steps['BuJpsiK_13INPUT']={'INPUT':InputInfo(dataSet='/RelValPythia6_BuJpsiK_TuneZ2star_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} steps['Cosmics_UP15INPUT']={'INPUT':InputInfo(dataSet='/RelValCosmics_UP15/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} steps['BeamHalo_13INPUT']={'INPUT':InputInfo(dataSet='/RelValBeamHalo_13/%s/GEN-SIM'%(baseDataSetRelease[4],),location='STD')} # particle guns with postLS1 geometry recycle GEN-SIM input @@ -464,16 +464,16 @@ def genS(fragment,howMuch): steps['ZTT']=genS('ZTT_All_hadronic_8TeV_TuneCUETP8M1_cfi',Kby(9,150)) steps['H130GGgluonfusion']=genS('H130GGgluonfusion_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['PhotonJets_Pt_10']=genS('PhotonJet_Pt_10_8TeV_TuneCUETP8M1_cfi',Kby(9,150)) -steps['QQH1352T']=genS('QQH1352T_Tauola_8TeV_cfi',Kby(9,100)) +steps['QQH1352T']=genS('QQH1352T_8TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['ZTT_13']=gen2015('ZTT_All_hadronic_13TeV_TuneCUETP8M1_cfi',Kby(9,150)) steps['H130GGgluonfusion_13']=gen2015('H130GGgluonfusion_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) steps['PhotonJets_Pt_10_13']=gen2015('PhotonJet_Pt_10_13TeV_TuneCUETP8M1_cfi',Kby(9,150)) -steps['QQH1352T_13']=gen2015('QQH1352T_Tauola_13TeV_cfi',Kby(9,100)) +steps['QQH1352T_13']=gen2015('QQH1352T_13TeV_TuneCUETP8M1_cfi',Kby(9,100)) #steps['ZmumuJets_Pt_20_300']=gen('ZmumuJets_Pt_20_300_GEN_8TeV_TuneCUETP8M1_cfg',Kby(25,100)) steps['ADDMonoJet_d3MD3']=genS('ADDMonoJet_8TeV_d3MD3_TuneCUETP8M1_cfi',Kby(9,100)) steps['ADDMonoJet_d3MD3_13']=gen2015('ADDMonoJet_13TeV_d3MD3_TuneCUETP8M1_cfi',Kby(9,100)) steps['RSKKGluon_m3000GeV_13']=gen2015('RSKKGluon_m3000GeV_13TeV_TuneCUETP8M1_cff',Kby(9,100)) -steps['Pythia6_BuJpsiK_TuneZ2star_13']=gen2015('Pythia6_BuJpsiK_TuneZ2star_13TeV_cfi',Kby(36000,400000)) +steps['BuJpsiK_13']=gen2015('Pythia8_BuJpsiK_13TeV_TuneCUETP8M1_cfi',Kby(36000,400000)) steps['MinBias2INPUT']={'INPUT':InputInfo(dataSet='/RelValMinBias/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} steps['Higgs200ChargedTausINPUT']={'INPUT':InputInfo(dataSet='/RelValHiggs200ChargedTaus/%s/GEN-SIM'%(baseDataSetRelease[0],),location='STD')} From 2d11f85401803e3e5c7837abac75ff965368390f Mon Sep 17 00:00:00 2001 From: Tomasz Fruboes Date: Fri, 12 Dec 2014 08:08:30 +0100 Subject: [PATCH 25/28] Fix objects saving into filter product --- HLTrigger/special/src/HLTPixlMBFilt.cc | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/HLTrigger/special/src/HLTPixlMBFilt.cc b/HLTrigger/special/src/HLTPixlMBFilt.cc index 09d792500413e..7a582231b9506 100644 --- a/HLTrigger/special/src/HLTPixlMBFilt.cc +++ b/HLTrigger/special/src/HLTPixlMBFilt.cc @@ -71,8 +71,9 @@ bool HLTPixlMBFilt::hltFilter(edm::Event& iEvent, const edm::EventSetup& iSetup, // All HLT filters must create and fill an HLT filter object, // recording any reconstructed physics objects satisfying (or not) // this HLT filter, and place it in the Event. - - + if (saveTags()) { + filterproduct.addCollectionTag(pixlTag_); + } // Specific filter code From a1906eac10a0ba7c470d2463776aff2618a685aa Mon Sep 17 00:00:00 2001 From: David Date: Fri, 12 Dec 2014 09:52:26 +0100 Subject: [PATCH 26/28] remove the run1 unsch workflow --- Configuration/PyReleaseValidation/python/relval_unsch.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Configuration/PyReleaseValidation/python/relval_unsch.py b/Configuration/PyReleaseValidation/python/relval_unsch.py index 70943f4bb6fcf..126f2558b0bf0 100644 --- a/Configuration/PyReleaseValidation/python/relval_unsch.py +++ b/Configuration/PyReleaseValidation/python/relval_unsch.py @@ -10,5 +10,6 @@ # the name of step1 will be used # 50 ns at 8 TeV -workflows[10025] = ['', ['TTbar','DIGI','RECOUNSCH','HARVEST','ALCATT']] +#needs a new GT to work +#workflows[10025] = ['', ['TTbar','DIGI','RECOUNSCH','HARVEST','ALCATT']] workflows[11325] = ['', ['TTbar_13','DIGIUP15','RECOUP15UNSCH','HARVESTUP15','ALCATT']] From b9341fe19409b14e49c0ceaecf7dd7f778d004c9 Mon Sep 17 00:00:00 2001 From: mauro verzetti Date: Mon, 16 Feb 2015 15:49:29 +0100 Subject: [PATCH 27/28] refactor code to be a bit faster (run only once on the detId vector) and allow the addition of strip tracker-wide plots --- .../interface/SiStripApvGainsDQM.h | 9 +- .../interface/SiStripBackPlaneCorrectionDQM.h | 9 +- .../interface/SiStripBaseCondObjDQM.h | 17 ++-- .../interface/SiStripCablingDQM.h | 8 +- .../interface/SiStripLorentzAngleDQM.h | 9 +- .../interface/SiStripNoisesDQM.h | 9 +- .../interface/SiStripPedestalsDQM.h | 8 +- .../interface/SiStripQualityDQM.h | 8 +- .../interface/SiStripThresholdDQM.h | 7 +- .../src/SiStripApvGainsDQM.cc | 50 +--------- .../src/SiStripBackPlaneCorrectionDQM.cc | 93 +++++-------------- .../src/SiStripBaseCondObjDQM.cc | 89 ++++++++++-------- .../src/SiStripLorentzAngleDQM.cc | 89 +++++------------- .../src/SiStripNoisesDQM.cc | 38 +++++++- .../src/SiStripPedestalsDQM.cc | 54 +---------- .../src/SiStripQualityDQM.cc | 42 +-------- .../src/SiStripThresholdDQM.cc | 39 -------- 17 files changed, 184 insertions(+), 394 deletions(-) diff --git a/DQM/SiStripMonitorSummary/interface/SiStripApvGainsDQM.h b/DQM/SiStripMonitorSummary/interface/SiStripApvGainsDQM.h index 833e42b62be11..70b980ca6a000 100644 --- a/DQM/SiStripMonitorSummary/interface/SiStripApvGainsDQM.h +++ b/DQM/SiStripMonitorSummary/interface/SiStripApvGainsDQM.h @@ -22,12 +22,9 @@ class SiStripApvGainsDQM : public SiStripBaseCondObjDQM{ void getActiveDetIds(const edm::EventSetup & eSetup); - void fillModMEs(const std::vector & selectedDetIds, const edm::EventSetup& es); - void fillSummaryMEs(const std::vector & selectedDetIds, const edm::EventSetup& es); - - void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo); - - void fillMEsForLayer( /*std::map selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo); + virtual void saveSummaryMEs(); + virtual void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo); + virtual void fillMEsForLayer( /*std::map selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo); unsigned long long getCache(const edm::EventSetup & eSetup){ return eSetup.get().cacheIdentifier();} diff --git a/DQM/SiStripMonitorSummary/interface/SiStripBackPlaneCorrectionDQM.h b/DQM/SiStripMonitorSummary/interface/SiStripBackPlaneCorrectionDQM.h index 2c9ed335cdb8e..4c8f1b7581fa0 100644 --- a/DQM/SiStripMonitorSummary/interface/SiStripBackPlaneCorrectionDQM.h +++ b/DQM/SiStripMonitorSummary/interface/SiStripBackPlaneCorrectionDQM.h @@ -20,11 +20,9 @@ class SiStripBackPlaneCorrectionDQM : public SiStripBaseCondObjDQM{ void getActiveDetIds(const edm::EventSetup & eSetup); - void fillModMEs(const std::vector & selectedDetIds, const edm::EventSetup& es){}; - void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo){}; - - void fillSummaryMEs(const std::vector & selectedDetIds, const edm::EventSetup& es); - void fillMEsForLayer( /*std::map selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo); + virtual void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo){}; + virtual void saveSummaryMEs(); + virtual void fillMEsForLayer( /*std::map selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo); unsigned long long getCache(const edm::EventSetup & eSetup){ return eSetup.get().cacheIdentifier();} @@ -35,6 +33,7 @@ class SiStripBackPlaneCorrectionDQM : public SiStripBaseCondObjDQM{ private: edm::ESHandle bpcorrectionHandle_; + uint32_t last_id_processed_; }; #endif diff --git a/DQM/SiStripMonitorSummary/interface/SiStripBaseCondObjDQM.h b/DQM/SiStripMonitorSummary/interface/SiStripBaseCondObjDQM.h index cdbc799f77ff9..e8232e8895491 100644 --- a/DQM/SiStripMonitorSummary/interface/SiStripBaseCondObjDQM.h +++ b/DQM/SiStripMonitorSummary/interface/SiStripBaseCondObjDQM.h @@ -89,6 +89,8 @@ class SiStripBaseCondObjDQM { }; + const TrackerTopology* const topo(const edm::EventSetup& es); + void savePNG(MonitorElement* me); void getModMEs(ModMEs& CondObj_ME, const uint32_t& detId_, const TrackerTopology* tTopo); void getSummaryMEs(ModMEs& CondObj_ME, const uint32_t& detId_, const TrackerTopology* tTopo); std::pair getLayerNameAndId(const uint32_t& detId_, const TrackerTopology* tTopo); @@ -96,11 +98,12 @@ class SiStripBaseCondObjDQM { std::vector GetSameLayerDetId(const std::vector& activeDetIds, uint32_t selDetId, const TrackerTopology* tTopo); - virtual void fillModMEs(const std::vector & selectedDetIds, const edm::EventSetup& es); - virtual void fillSummaryMEs(const std::vector & selectedDetIds, const edm::EventSetup& es); + void fillModMEs(const std::vector & selectedDetIds, const edm::EventSetup& es); + void fillSummaryMEs(const std::vector & selectedDetIds, const edm::EventSetup& es); + virtual void saveSummaryMEs(); //allow different plots to be saved, but provide default system virtual void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo)=0; virtual void fillMEsForLayer( /*std::map selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo)=0; - + virtual void fillMEsForAll(uint32_t selDetId_, const TrackerTopology* tTopo) {}; void fillTkMap(const uint32_t& detid, const float& value); @@ -115,6 +118,8 @@ class SiStripBaseCondObjDQM { bool SummaryOnLayerLevel_On_; bool SummaryOnStringLevel_On_; bool GrandSummary_On_; + + bool GlobalPlots_; double minValue, maxValue; std::vector tkMapScaler; @@ -136,6 +141,9 @@ class SiStripBaseCondObjDQM { TkHistoMap* Tk_HM_L; TrackerMap * tkMap; + SiStripFolderOrganizer folder_organizer; + DQMStore* dqmStore_; + private: void bookProfileMEs(SiStripBaseCondObjDQM::ModMEs& CondObj_ME, const uint32_t& detId_, const TrackerTopology* tTopo); @@ -157,9 +165,6 @@ class SiStripBaseCondObjDQM { std::string condDataMonitoringMode_; SiStripHistoId hidmanager; - SiStripFolderOrganizer folder_organizer; - DQMStore* dqmStore_; - }; diff --git a/DQM/SiStripMonitorSummary/interface/SiStripCablingDQM.h b/DQM/SiStripMonitorSummary/interface/SiStripCablingDQM.h index 0e095ffe34b6c..387b25ffaf950 100644 --- a/DQM/SiStripMonitorSummary/interface/SiStripCablingDQM.h +++ b/DQM/SiStripMonitorSummary/interface/SiStripCablingDQM.h @@ -22,11 +22,9 @@ class SiStripCablingDQM: public SiStripBaseCondObjDQM{ ~SiStripCablingDQM(); - void fillModMEs(const std::vector & selectedDetIds, const edm::EventSetup& es){;} - void fillSummaryMEs(const std::vector & selectedDetIds, const edm::EventSetup& es){;} - - void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo){;} - void fillMEsForLayer( /*std::map selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo){;} + virtual void saveSummaryMEs(){;} + virtual void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo){;} + virtual void fillMEsForLayer( /*std::map selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo){;} void getActiveDetIds(const edm::EventSetup & eSetup); unsigned long long getCache(const edm::EventSetup & eSetup){ return eSetup.get().cacheIdentifier();} diff --git a/DQM/SiStripMonitorSummary/interface/SiStripLorentzAngleDQM.h b/DQM/SiStripMonitorSummary/interface/SiStripLorentzAngleDQM.h index 55747f1fc3f0c..1e41c92fdbbe5 100644 --- a/DQM/SiStripMonitorSummary/interface/SiStripLorentzAngleDQM.h +++ b/DQM/SiStripMonitorSummary/interface/SiStripLorentzAngleDQM.h @@ -20,11 +20,9 @@ class SiStripLorentzAngleDQM : public SiStripBaseCondObjDQM{ void getActiveDetIds(const edm::EventSetup & eSetup); - void fillModMEs(const std::vector & selectedDetIds, const edm::EventSetup& es){}; - void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo){}; - - void fillSummaryMEs(const std::vector & selectedDetIds, const edm::EventSetup& es); - void fillMEsForLayer( /*std::map selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo); + virtual void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo){}; + virtual void saveSummaryMEs(); + virtual void fillMEsForLayer( /*std::map selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo); unsigned long long getCache(const edm::EventSetup & eSetup){ return eSetup.get().cacheIdentifier();} @@ -35,6 +33,7 @@ class SiStripLorentzAngleDQM : public SiStripBaseCondObjDQM{ private: edm::ESHandle lorentzangleHandle_; + uint32_t last_id_processed_; }; #endif diff --git a/DQM/SiStripMonitorSummary/interface/SiStripNoisesDQM.h b/DQM/SiStripMonitorSummary/interface/SiStripNoisesDQM.h index f42723c8e91c9..6fd729003d9b8 100644 --- a/DQM/SiStripMonitorSummary/interface/SiStripNoisesDQM.h +++ b/DQM/SiStripMonitorSummary/interface/SiStripNoisesDQM.h @@ -21,10 +21,11 @@ class SiStripNoisesDQM : public SiStripBaseCondObjDQM{ void getActiveDetIds(const edm::EventSetup & eSetup); - void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo); - void fillMEsForLayer( /*std::map selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo); + virtual void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo); + virtual void fillMEsForLayer( /*std::map selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo); + virtual void fillMEsForAll(uint32_t selDetId_, const TrackerTopology* tTopo); - unsigned long long getCache(const edm::EventSetup & eSetup){ return eSetup.get().cacheIdentifier();} + unsigned long long getCache(const edm::EventSetup & eSetup){return eSetup.get().cacheIdentifier();} void getConditionObject(const edm::EventSetup & eSetup){ eSetup.get().get(noiseHandle_); @@ -35,7 +36,7 @@ class SiStripNoisesDQM : public SiStripBaseCondObjDQM{ bool gainRenormalisation_; edm::ESHandle noiseHandle_; edm::ESHandle gainHandle_; - + MonitorElement *noise_vs_dettype, *legth_vs_dettype; }; #endif diff --git a/DQM/SiStripMonitorSummary/interface/SiStripPedestalsDQM.h b/DQM/SiStripMonitorSummary/interface/SiStripPedestalsDQM.h index ea9fa9a1f35b1..4d6a9150b3716 100644 --- a/DQM/SiStripMonitorSummary/interface/SiStripPedestalsDQM.h +++ b/DQM/SiStripMonitorSummary/interface/SiStripPedestalsDQM.h @@ -20,11 +20,9 @@ class SiStripPedestalsDQM : public SiStripBaseCondObjDQM{ void getActiveDetIds(const edm::EventSetup & eSetup); - void fillModMEs(const std::vector & selectedDetIds, const edm::EventSetup& es); - void fillSummaryMEs(const std::vector & selectedDetIds, const edm::EventSetup& es); - - void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo); - void fillMEsForLayer( /*std::map selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo); + virtual void saveSummaryMEs(); + virtual void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo); + virtual void fillMEsForLayer( /*std::map selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo); unsigned long long getCache(const edm::EventSetup & eSetup){ return eSetup.get().cacheIdentifier();} diff --git a/DQM/SiStripMonitorSummary/interface/SiStripQualityDQM.h b/DQM/SiStripMonitorSummary/interface/SiStripQualityDQM.h index 3d887e0287dd9..321fed5d172ad 100644 --- a/DQM/SiStripMonitorSummary/interface/SiStripQualityDQM.h +++ b/DQM/SiStripMonitorSummary/interface/SiStripQualityDQM.h @@ -37,11 +37,9 @@ class SiStripQualityDQM : public SiStripBaseCondObjDQM{ void getActiveDetIds(const edm::EventSetup & eSetup); - void fillModMEs(const std::vector & selectedDetIds, const edm::EventSetup& es); - void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo); - - void fillSummaryMEs(const std::vector & selectedDetIds, const edm::EventSetup& es); - void fillMEsForLayer( /*std::map selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo); + virtual void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo); + virtual void saveSummaryMEs(); + virtual void fillMEsForLayer( /*std::map selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo); void fillGrandSummaryMEs(const edm::EventSetup& eSetup); diff --git a/DQM/SiStripMonitorSummary/interface/SiStripThresholdDQM.h b/DQM/SiStripMonitorSummary/interface/SiStripThresholdDQM.h index e5c03f91b5367..ccd744f7f6165 100644 --- a/DQM/SiStripMonitorSummary/interface/SiStripThresholdDQM.h +++ b/DQM/SiStripMonitorSummary/interface/SiStripThresholdDQM.h @@ -20,11 +20,8 @@ class SiStripThresholdDQM : public SiStripBaseCondObjDQM{ void getActiveDetIds(const edm::EventSetup & eSetup); - void fillModMEs(const std::vector & selectedDetIds, const edm::EventSetup& es); - void fillSummaryMEs(const std::vector & selectedDetIds, const edm::EventSetup& es); - - void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo); - void fillMEsForLayer( /*std::map selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo); + virtual void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo); + virtual void fillMEsForLayer( /*std::map selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo); unsigned long long getCache(const edm::EventSetup & eSetup){ return eSetup.get().cacheIdentifier();} diff --git a/DQM/SiStripMonitorSummary/src/SiStripApvGainsDQM.cc b/DQM/SiStripMonitorSummary/src/SiStripApvGainsDQM.cc index 116c365698dfc..4b2f2af050d89 100644 --- a/DQM/SiStripMonitorSummary/src/SiStripApvGainsDQM.cc +++ b/DQM/SiStripMonitorSummary/src/SiStripApvGainsDQM.cc @@ -28,26 +28,6 @@ void SiStripApvGainsDQM::getActiveDetIds(const edm::EventSetup & eSetup){ } // ----- - - - - -// ----- -void SiStripApvGainsDQM::fillModMEs(const std::vector & selectedDetIds, const edm::EventSetup& es){ - - //Retrieve tracker topology from geometry - edm::ESHandle tTopoHandle; - es.get().get(tTopoHandle); - const TrackerTopology* const tTopo = tTopoHandle.product(); - - ModMEs CondObj_ME; - - for(std::vector::const_iterator detIter_ =selectedDetIds.begin(); - detIter_!=selectedDetIds.end();++detIter_){ - fillMEsForDet(CondObj_ME,*detIter_,tTopo); - } -} - // ----- void SiStripApvGainsDQM::fillMEsForDet(const ModMEs& _selModME_, uint32_t selDetId_, const TrackerTopology* tTopo){ @@ -77,42 +57,20 @@ void SiStripApvGainsDQM::fillMEsForDet(const ModMEs& _selModME_, uint32_t selDet } } -// ----- -void SiStripApvGainsDQM::fillSummaryMEs(const std::vector & selectedDetIds, const edm::EventSetup& es){ - - //Retrieve tracker topology from geometry - edm::ESHandle tTopoHandle; - es.get().get(tTopoHandle); - const TrackerTopology* const tTopo = tTopoHandle.product(); - - for(std::vector::const_iterator detIter_ = selectedDetIds.begin(); - detIter_!= selectedDetIds.end();detIter_++){ - fillMEsForLayer(/*SummaryMEsMap_,*/ *detIter_, tTopo); - } - +//========================== +void SiStripApvGainsDQM::saveSummaryMEs(){ for (std::map::iterator iter=SummaryMEsMap_.begin(); iter!=SummaryMEsMap_.end(); iter++){ ModMEs selME; selME = iter->second; if(hPSet_.getParameter("FillSummaryProfileAtLayerLevel") && fPSet_.getParameter("OutputSummaryProfileAtLayerLevelAsImage")){ - - TCanvas c1("c1"); - selME.SummaryOfProfileDistr->getTProfile()->Draw(); - std::string name (selME.SummaryOfProfileDistr->getTProfile()->GetTitle()); - name+=".png"; - c1.Print(name.c_str()); + savePNG(selME.SummaryOfProfileDistr); } if(hPSet_.getParameter("FillSummaryAtLayerLevel") && fPSet_.getParameter("OutputSummaryAtLayerLevelAsImage")){ - - TCanvas c1("c1"); - selME.SummaryDistr->getTH1()->Draw(); - std::string name (selME.SummaryDistr->getTH1()->GetTitle()); - name+=".png"; - c1.Print(name.c_str()); + savePNG(selME.SummaryDistr); } } - } // ----- diff --git a/DQM/SiStripMonitorSummary/src/SiStripBackPlaneCorrectionDQM.cc b/DQM/SiStripMonitorSummary/src/SiStripBackPlaneCorrectionDQM.cc index a9ebb512ce9f8..724ee170d26d6 100644 --- a/DQM/SiStripMonitorSummary/src/SiStripBackPlaneCorrectionDQM.cc +++ b/DQM/SiStripMonitorSummary/src/SiStripBackPlaneCorrectionDQM.cc @@ -5,11 +5,12 @@ // ----- SiStripBackPlaneCorrectionDQM::SiStripBackPlaneCorrectionDQM(const edm::EventSetup & eSetup, edm::ParameterSet const& hPSet, - edm::ParameterSet const& fPSet):SiStripBaseCondObjDQM(eSetup, hPSet, fPSet){ - + edm::ParameterSet const& fPSet): + SiStripBaseCondObjDQM(eSetup, hPSet, fPSet), + last_id_processed_(0) +{ // Build the Histo_TkMap: if(HistoMaps_On_ ) Tk_HM_ = new TkHistoMap("SiStrip/Histo_Map","BP_TkMap",0.); - } // ----- @@ -37,87 +38,29 @@ void SiStripBackPlaneCorrectionDQM::getActiveDetIds(const edm::EventSetup & eSet } // ----- - -// ----- -void SiStripBackPlaneCorrectionDQM::fillSummaryMEs(const std::vector & selectedDetIds, const edm::EventSetup& es){ - - //Retrieve tracker topology from geometry - edm::ESHandle tTopoHandle; - es.get().get(tTopoHandle); - const TrackerTopology* const tTopo = tTopoHandle.product(); - - // ----- - // BP on layer-level : fill at once all detIds belonging to same layer when encountering first detID in the layer - - bool fillNext = true; - for(unsigned int i=0;i>25)&0x7); - if( subDetId_<3 ||subDetId_>6 ){ - edm::LogError("SiStripBackPlaneCorrection") - << "[SiStripBackPlaneCorrection::fillSummaryMEs] WRONG INPUT : no such subdetector type : " - << subDetId_ << " and detId " << selectedDetIds[i] << " therefore no filling!" - << std::endl; - } - else if (SummaryOnLayerLevel_On_) { - if( fillNext) { fillMEsForLayer(/*SummaryMEsMap_,*/ selectedDetIds[i],tTopo);} - if( getLayerNameAndId(selectedDetIds[i+1],tTopo)==getLayerNameAndId(selectedDetIds[i],tTopo)){ fillNext=false;} - else { fillNext=true;} - } - else if (SummaryOnStringLevel_On_) { - if( fillNext) { fillMEsForLayer(/*SummaryMEsMap_,*/ selectedDetIds[i],tTopo);} - if( getStringNameAndId(selectedDetIds[i+1],tTopo)==getStringNameAndId(selectedDetIds[i],tTopo)){ fillNext=false;} - else { fillNext=true;} - } - } - +void SiStripBackPlaneCorrectionDQM::saveSummaryMEs(){ for (std::map::iterator iter=SummaryMEsMap_.begin(); iter!=SummaryMEsMap_.end(); iter++){ ModMEs selME; selME = iter->second; if(SummaryOnStringLevel_On_){ - if (fPSet_.getParameter("OutputSummaryProfileAtLayerLevelAsImage")){ - - TCanvas c1("c1"); - selME.SummaryOfProfileDistr->getTProfile()->Draw(); - std::string name (selME.SummaryOfProfileDistr->getTProfile()->GetTitle()); - name+=".png"; - c1.Print(name.c_str()); + savePNG(selME.SummaryOfProfileDistr); } - if (fPSet_.getParameter("OutputCumulativeSummaryAtLayerLevelAsImage")){ - - TCanvas c2("c2"); - selME.SummaryOfCumulDistr->getTH1()->Draw(); - std::string name2 (selME.SummaryOfCumulDistr->getTH1()->GetTitle()); - name2+=".png"; - c2.Print(name2.c_str()); + savePNG(selME.SummaryOfCumulDistr); } - } else{ if(hPSet_.getParameter("FillSummaryProfileAtLayerLevel") && fPSet_.getParameter("OutputSummaryProfileAtLayerLevelAsImage")){ - - TCanvas c1("c1"); - selME.SummaryOfProfileDistr->getTProfile()->Draw(); - std::string name (selME.SummaryOfProfileDistr->getTProfile()->GetTitle()); - name+=".png"; - c1.Print(name.c_str()); + savePNG(selME.SummaryOfProfileDistr); } - if(hPSet_.getParameter("FillCumulativeSummaryAtLayerLevel") && fPSet_.getParameter("OutputCumulativeSummaryAtLayerLevelAsImage")){ - - TCanvas c1("c1"); - selME.SummaryOfCumulDistr->getTH1()->Draw(); - std::string name (selME.SummaryOfCumulDistr->getTH1()->GetTitle()); - name+=".png"; - c1.Print(name.c_str()); + savePNG(selME.SummaryOfCumulDistr); } } - } - } // ----- @@ -125,6 +68,22 @@ void SiStripBackPlaneCorrectionDQM::fillSummaryMEs(const std::vector & // ----- void SiStripBackPlaneCorrectionDQM::fillMEsForLayer( /*std::map selMEsMap_,*/ uint32_t selDetId_, const TrackerTopology* tTopo){ + //check if we need to do anything + int subDetId_ = ((selDetId_>>25)&0x7); + if( subDetId_<3 ||subDetId_>6 ){ + edm::LogError("SiStripBackPlaneCorrection") + << "[SiStripBackPlaneCorrection::fillMEsForLayer] WRONG INPUT : no such subdetector type : " + << subDetId_ << " and detId " << selDetId_ << " therefore no filling!" + << std::endl; + } + else if (SummaryOnLayerLevel_On_) { + if( getLayerNameAndId(last_id_processed_, tTopo) == getLayerNameAndId(selDetId_, tTopo)){return;} + } + else if (SummaryOnStringLevel_On_) { + if( getStringNameAndId(last_id_processed_, tTopo)==getStringNameAndId(selDetId_, tTopo)){return;} + } + last_id_processed_ = selDetId_; + SiStripHistoId hidmanager; @@ -134,8 +93,6 @@ void SiStripBackPlaneCorrectionDQM::fillMEsForLayer( /*std::map>25)&0x7); - if( subDetId_<3 || subDetId_>6 ){ edm::LogError("SiStripBackPlaneCorrectionDQM") << "[SiStripBackPlaneCorrectionDQM::fillMEsForLayer] WRONG INPUT : no such subdetector type : " diff --git a/DQM/SiStripMonitorSummary/src/SiStripBaseCondObjDQM.cc b/DQM/SiStripMonitorSummary/src/SiStripBaseCondObjDQM.cc index ea7c7ecc094f2..1627965c0ef1a 100644 --- a/DQM/SiStripMonitorSummary/src/SiStripBaseCondObjDQM.cc +++ b/DQM/SiStripMonitorSummary/src/SiStripBaseCondObjDQM.cc @@ -23,7 +23,7 @@ SiStripBaseCondObjDQM::SiStripBaseCondObjDQM(const edm::EventSetup & eSetup, SummaryOnStringLevel_On_ = fPSet_.getParameter("SummaryOnStringLevel_On"); GrandSummary_On_ = fPSet_.getParameter("GrandSummary_On"); - + GlobalPlots_ = fPSet_.existsAs("GlobalPlots") ? fPSet_.getParameter("GlobalPlots") : false; CondObj_fillId_ = hPSet_.getParameter("CondObj_fillId"); CondObj_name_ = hPSet_.getParameter("CondObj_name"); @@ -64,8 +64,16 @@ void SiStripBaseCondObjDQM::analysis(const edm::EventSetup & eSetup_){ selectModules(activeDetIds); - if(Mod_On_ ) { fillModMEs (activeDetIds, eSetup_); } - if(SummaryOnLayerLevel_On_ || SummaryOnStringLevel_On_ ){ fillSummaryMEs(activeDetIds, eSetup_); } + const TrackerTopology* const tTopo = topo(eSetup_); + ModMEs CondObj_ME; + + for(std::vector::const_iterator detIter = activeDetIds.begin(); + detIter != activeDetIds.end(); ++detIter){ + if(Mod_On_ ) {fillMEsForDet(CondObj_ME, *detIter, tTopo);} + if(SummaryOnLayerLevel_On_ || SummaryOnStringLevel_On_ ){fillMEsForLayer(/*SummaryMEsMap_,*/ *detIter, tTopo);} + if(GlobalPlots_ ) {fillMEsForAll(*detIter, tTopo);} + } + saveSummaryMEs(); if(fPSet_.getParameter("TkMap_On") || hPSet_.getParameter("TkMap_On")) { std::string filename = hPSet_.getParameter("TkMapName"); @@ -166,7 +174,6 @@ std::vector SiStripBaseCondObjDQM::getCabledModules() { //#FIXME : very long method. please factorize it void SiStripBaseCondObjDQM::selectModules(std::vector & detIds_){ - edm::LogInfo("SiStripBaseCondObjDQM") << "[SiStripBaseCondObjDQM::selectModules] input detIds_: " << detIds_.size() << std::endl; if( fPSet_.getParameter("restrictModules")){ @@ -1246,13 +1253,37 @@ void SiStripBaseCondObjDQM::end(){ } //========================== -void SiStripBaseCondObjDQM::fillModMEs(const std::vector & selectedDetIds, const edm::EventSetup& es){ +void SiStripBaseCondObjDQM::savePNG(MonitorElement* me){ + TCanvas c1("ItDoesNotMatter"); + switch(me->kind()){ + case MonitorElement::Kind::DQM_KIND_TPROFILE : me->getTProfile()->Draw(); break; + case MonitorElement::Kind::DQM_KIND_TH1F : me->getTH1()->Draw(); break; + case MonitorElement::Kind::DQM_KIND_TH1S : me->getTH1()->Draw(); break; + case MonitorElement::Kind::DQM_KIND_TH1D : me->getTH1()->Draw(); break; + //case MonitorElement::Kind:: : ; break; + default : throw edm::Exception(edm::errors::Configuration) + << "DQM Type is not recognised by SiStripBaseCondObjDQM::savePNG for " + << "PNG image printout, plase add the appropriate information to " + << "the code"; + } + std::string name (me->getTitle()); + name+=".png"; + c1.Print(name.c_str()); +} - //Retrieve tracker topology from geometry +//========================== +const TrackerTopology* const SiStripBaseCondObjDQM::topo(const edm::EventSetup& es){ + //Retrieve tracker topology from geometry edm::ESHandle tTopoHandle; es.get().get(tTopoHandle); const TrackerTopology* const tTopo = tTopoHandle.product(); + return tTopo; +} + +//========================== +void SiStripBaseCondObjDQM::fillModMEs(const std::vector & selectedDetIds, const edm::EventSetup& es){ + const TrackerTopology* const tTopo = topo(es); ModMEs CondObj_ME; for(std::vector::const_iterator detIter_=selectedDetIds.begin(); @@ -1261,19 +1292,8 @@ void SiStripBaseCondObjDQM::fillModMEs(const std::vector & selectedDet } } -//========================== -void SiStripBaseCondObjDQM::fillSummaryMEs(const std::vector & selectedDetIds, const edm::EventSetup& es){ - - //Retrieve tracker topology from geometry - edm::ESHandle tTopoHandle; - es.get().get(tTopoHandle); - const TrackerTopology* const tTopo = tTopoHandle.product(); - - for(std::vector::const_iterator detIter_ = selectedDetIds.begin(); - detIter_!= selectedDetIds.end();detIter_++){ - fillMEsForLayer(/*SummaryMEsMap_,*/ *detIter_,tTopo); - } - +//========================== +void SiStripBaseCondObjDQM::saveSummaryMEs(){ for (std::map::iterator iter=SummaryMEsMap_.begin(); iter!=SummaryMEsMap_.end(); iter++){ @@ -1284,35 +1304,30 @@ void SiStripBaseCondObjDQM::fillSummaryMEs(const std::vector & selecte fPSet_.getParameter("OutputSummaryProfileAtLayerLevelAsImage")){ if( CondObj_fillId_ =="onlyProfile" || CondObj_fillId_ =="ProfileAndCumul"){ - - TCanvas c1("c1"); - selME.SummaryOfProfileDistr->getTProfile()->Draw(); - std::string name (selME.SummaryOfProfileDistr->getTProfile()->GetTitle()); - name+=".png"; - c1.Print(name.c_str()); + savePNG(selME.SummaryOfProfileDistr); } } if(hPSet_.getParameter("FillSummaryAtLayerLevel") && fPSet_.getParameter("OutputSummaryAtLayerLevelAsImage")){ - - TCanvas c1("c1"); - selME.SummaryDistr->getTH1()->Draw(); - std::string name (selME.SummaryDistr->getTH1()->GetTitle()); - name+=".png"; - c1.Print(name.c_str()); + savePNG(selME.SummaryDistr); } if(hPSet_.getParameter("FillCumulativeSummaryAtLayerLevel") && fPSet_.getParameter("OutputCumulativeSummaryAtLayerLevelAsImage")){ if( CondObj_fillId_ =="onlyCumul" || CondObj_fillId_ =="ProfileAndCumul"){ - - TCanvas c1("c1"); - selME.SummaryOfCumulDistr->getTH1()->Draw(); - std::string name (selME.SummaryOfCumulDistr->getTH1()->GetTitle()); - name+=".png"; - c1.Print(name.c_str()); + savePNG(selME.SummaryOfCumulDistr); } } + } +} +//========================== +void SiStripBaseCondObjDQM::fillSummaryMEs(const std::vector & selectedDetIds, const edm::EventSetup& es){ + const TrackerTopology* const tTopo = topo(es); + + for(std::vector::const_iterator detIter_ = selectedDetIds.begin(); + detIter_!= selectedDetIds.end();detIter_++){ + fillMEsForLayer(/*SummaryMEsMap_,*/ *detIter_,tTopo); } + saveSummaryMEs(); } diff --git a/DQM/SiStripMonitorSummary/src/SiStripLorentzAngleDQM.cc b/DQM/SiStripMonitorSummary/src/SiStripLorentzAngleDQM.cc index 6199679a194c3..db743b880d724 100644 --- a/DQM/SiStripMonitorSummary/src/SiStripLorentzAngleDQM.cc +++ b/DQM/SiStripMonitorSummary/src/SiStripLorentzAngleDQM.cc @@ -5,7 +5,10 @@ // ----- SiStripLorentzAngleDQM::SiStripLorentzAngleDQM(const edm::EventSetup & eSetup, edm::ParameterSet const& hPSet, - edm::ParameterSet const& fPSet):SiStripBaseCondObjDQM(eSetup, hPSet, fPSet){ + edm::ParameterSet const& fPSet): + SiStripBaseCondObjDQM(eSetup, hPSet, fPSet), + last_id_processed_(0) +{ // Build the Histo_TkMap: if(HistoMaps_On_ ) Tk_HM_ = new TkHistoMap("SiStrip/Histo_Map","LA_TkMap",0.); @@ -35,89 +38,31 @@ void SiStripLorentzAngleDQM::getActiveDetIds(const edm::EventSetup & eSetup){ } } -// ----- - // ----- -void SiStripLorentzAngleDQM::fillSummaryMEs(const std::vector & selectedDetIds, const edm::EventSetup& es){ - - //Retrieve tracker topology from geometry - edm::ESHandle tTopoHandle; - es.get().get(tTopoHandle); - const TrackerTopology* const tTopo = tTopoHandle.product(); - - // ----- - // LA on layer-level : fill at once all detIds belonging to same layer when encountering first detID in the layer - - bool fillNext = true; - for(unsigned int i=0;i>25)&0x7); - if( subDetId_<3 ||subDetId_>6 ){ - edm::LogError("SiStripLorentzAngle") - << "[SiStripLorentzAngle::fillSummaryMEs] WRONG INPUT : no such subdetector type : " - << subDetId_ << " and detId " << selectedDetIds[i] << " therefore no filling!" - << std::endl; - } - else if (SummaryOnLayerLevel_On_) { - if( fillNext) { fillMEsForLayer(/*SummaryMEsMap_,*/ selectedDetIds[i],tTopo);} - if( getLayerNameAndId(selectedDetIds[i+1],tTopo)==getLayerNameAndId(selectedDetIds[i],tTopo)){ fillNext=false;} - else { fillNext=true;} - } - else if (SummaryOnStringLevel_On_) { - if( fillNext) { fillMEsForLayer(/*SummaryMEsMap_,*/ selectedDetIds[i],tTopo);} - if( getStringNameAndId(selectedDetIds[i+1],tTopo)==getStringNameAndId(selectedDetIds[i],tTopo)){ fillNext=false;} - else { fillNext=true;} - } - } - +void SiStripLorentzAngleDQM::saveSummaryMEs(){ for (std::map::iterator iter=SummaryMEsMap_.begin(); iter!=SummaryMEsMap_.end(); iter++){ ModMEs selME; selME = iter->second; if(SummaryOnStringLevel_On_){ - if (fPSet_.getParameter("OutputSummaryProfileAtLayerLevelAsImage")){ - - TCanvas c1("c1"); - selME.SummaryOfProfileDistr->getTProfile()->Draw(); - std::string name (selME.SummaryOfProfileDistr->getTProfile()->GetTitle()); - name+=".png"; - c1.Print(name.c_str()); + savePNG(selME.SummaryOfProfileDistr); } - if (fPSet_.getParameter("OutputCumulativeSummaryAtLayerLevelAsImage")){ - - TCanvas c2("c2"); - selME.SummaryOfCumulDistr->getTH1()->Draw(); - std::string name2 (selME.SummaryOfCumulDistr->getTH1()->GetTitle()); - name2+=".png"; - c2.Print(name2.c_str()); + savePNG(selME.SummaryOfCumulDistr); } - } else{ if(hPSet_.getParameter("FillSummaryProfileAtLayerLevel") && fPSet_.getParameter("OutputSummaryProfileAtLayerLevelAsImage")){ - - TCanvas c1("c1"); - selME.SummaryOfProfileDistr->getTProfile()->Draw(); - std::string name (selME.SummaryOfProfileDistr->getTProfile()->GetTitle()); - name+=".png"; - c1.Print(name.c_str()); + savePNG(selME.SummaryOfProfileDistr); } - if(hPSet_.getParameter("FillCumulativeSummaryAtLayerLevel") && fPSet_.getParameter("OutputCumulativeSummaryAtLayerLevelAsImage")){ - - TCanvas c1("c1"); - selME.SummaryOfCumulDistr->getTH1()->Draw(); - std::string name (selME.SummaryOfCumulDistr->getTH1()->GetTitle()); - name+=".png"; - c1.Print(name.c_str()); + savePNG(selME.SummaryOfCumulDistr); } } - } - } // ----- @@ -125,6 +70,20 @@ void SiStripLorentzAngleDQM::fillSummaryMEs(const std::vector & select // ----- void SiStripLorentzAngleDQM::fillMEsForLayer( /*std::map selMEsMap_,*/ uint32_t selDetId_, const TrackerTopology* tTopo){ + int subDetId_ = ((selDetId_>>25)&0x7); + if( subDetId_<3 ||subDetId_>6 ){ + edm::LogError("SiStripLorentzAngle") + << "[SiStripLorentzAngle::fillMEsForLayer] WRONG INPUT : no such subdetector type : " + << subDetId_ << " and detId " << selDetId_ << " therefore no filling!" + << std::endl; + } + else if (SummaryOnLayerLevel_On_) { + if(getLayerNameAndId(last_id_processed_, tTopo)==getLayerNameAndId(selDetId_, tTopo)){return;} + } + else if (SummaryOnStringLevel_On_) { + if(getStringNameAndId(last_id_processed_, tTopo)==getStringNameAndId(selDetId_, tTopo)){return;} + } + last_id_processed_ = selDetId_; SiStripHistoId hidmanager; @@ -134,8 +93,6 @@ void SiStripLorentzAngleDQM::fillMEsForLayer( /*std::map selME std::string hSummary_name; - int subDetId_ = ((selDetId_>>25)&0x7); - if( subDetId_<3 || subDetId_>6 ){ edm::LogError("SiStripLorentzAngleDQM") << "[SiStripLorentzAngleDQM::fillMEsForLayer] WRONG INPUT : no such subdetector type : " diff --git a/DQM/SiStripMonitorSummary/src/SiStripNoisesDQM.cc b/DQM/SiStripMonitorSummary/src/SiStripNoisesDQM.cc index 41d9878c5e4bf..959ac3110935e 100644 --- a/DQM/SiStripMonitorSummary/src/SiStripNoisesDQM.cc +++ b/DQM/SiStripMonitorSummary/src/SiStripNoisesDQM.cc @@ -1,6 +1,6 @@ #include "DQM/SiStripMonitorSummary/interface/SiStripNoisesDQM.h" - +#include "DataFormats/SiStripDetId/interface/SiStripDetId.h" #include "DQMServices/Core/interface/MonitorElement.h" #include "TCanvas.h" @@ -16,6 +16,13 @@ SiStripNoisesDQM::SiStripNoisesDQM(const edm::EventSetup & eSetup, // Build the Histo_TkMap: if(HistoMaps_On_ ) Tk_HM_ = new TkHistoMap("SiStrip/Histo_Map","MeanNoise_TkMap",0.); + if(GlobalPlots_){ + const TrackerTopology* tTopo = topo(eSetup); + folder_organizer.setLayerFolder(0, tTopo); + int last_enum_element = SiStripDetId::ModuleGeometry::W7 + 1; + noise_vs_dettype = dqmStore_->bookProfile("noise_vs_dettype", "noise_vs_dettype", last_enum_element, 0, last_enum_element, 100, 0, 10); + legth_vs_dettype = dqmStore_->bookProfile("lenght_vs_dettype", "lenght_vs_dettype", last_enum_element, 0, last_enum_element, 150, 7, 22); + } } // ----- @@ -32,6 +39,35 @@ void SiStripNoisesDQM::getActiveDetIds(const edm::EventSetup & eSetup){ } +// ----- +void SiStripNoisesDQM::fillMEsForAll(uint32_t selDetId_, const TrackerTopology* tTopo){ + SiStripNoises::Range noiseRange = noiseHandle_->getRange(selDetId_); + + int nStrip = reader->getNumberOfApvsAndStripLength(selDetId_).first*128; + float lenght = reader->getNumberOfApvsAndStripLength(selDetId_).second; + int detectory_type = SiStripDetId(selDetId_).moduleGeometry(); + + legth_vs_dettype->Fill(detectory_type, lenght); + + float gainFactor; + float stripnoise; + + SiStripApvGain::Range gainRange; + if( gainRenormalisation_ ){ + gainRange = gainHandle_->getRange(selDetId_); + } + + for(int istrip=0; istripgetStripGain(istrip, gainRange) ? gainHandle_ ->getStripGain(istrip,gainRange) : 1.; + else + gainFactor=1; + + stripnoise = noiseHandle_->getNoise(istrip, noiseRange)/gainFactor; + noise_vs_dettype->Fill(detectory_type, stripnoise); + } //istrip +} + // ----- void SiStripNoisesDQM::fillMEsForDet(const ModMEs& _selModME_, uint32_t selDetId_, const TrackerTopology* tTopo){ ModMEs selModME_ = _selModME_; diff --git a/DQM/SiStripMonitorSummary/src/SiStripPedestalsDQM.cc b/DQM/SiStripMonitorSummary/src/SiStripPedestalsDQM.cc index 1ca3d8fbbbb2c..c476248a0976f 100644 --- a/DQM/SiStripMonitorSummary/src/SiStripPedestalsDQM.cc +++ b/DQM/SiStripMonitorSummary/src/SiStripPedestalsDQM.cc @@ -28,29 +28,6 @@ void SiStripPedestalsDQM::getActiveDetIds(const edm::EventSetup & eSetup){ } // ----- - -// ----- -void SiStripPedestalsDQM::fillModMEs(const std::vector & selectedDetIds, const edm::EventSetup& es){ - - //Retrieve tracker topology from geometry - edm::ESHandle tTopoHandle; - es.get().get(tTopoHandle); - const TrackerTopology* const tTopo = tTopoHandle.product(); - - ModMEs CondObj_ME; - - for(std::vector::const_iterator detIter_ = selectedDetIds.begin(); - detIter_!= selectedDetIds.end();detIter_++){ - - fillMEsForDet(CondObj_ME,*detIter_,tTopo); - - } -} -// ----- - - - - // ----- void SiStripPedestalsDQM::fillMEsForDet(const ModMEs& _selModME_, uint32_t selDetId_, const TrackerTopology* tTopo){ ModMEs selModME_ = _selModME_; @@ -70,46 +47,21 @@ void SiStripPedestalsDQM::fillMEsForDet(const ModMEs& _selModME_, uint32_t selDe -// ----- -void SiStripPedestalsDQM::fillSummaryMEs(const std::vector & selectedDetIds, const edm::EventSetup& es){ - - //Retrieve tracker topology from geometry - edm::ESHandle tTopoHandle; - es.get().get(tTopoHandle); - const TrackerTopology* const tTopo = tTopoHandle.product(); - - for(std::vector::const_iterator detIter_ = selectedDetIds.begin(); - detIter_!= selectedDetIds.end();detIter_++){ - fillMEsForLayer(/*SummaryMEsMap_,*/ *detIter_,tTopo); - } - +void SiStripPedestalsDQM::saveSummaryMEs(){ for (std::map::iterator iter=SummaryMEsMap_.begin(); iter!=SummaryMEsMap_.end(); iter++){ ModMEs selME; selME = iter->second; if(hPSet_.getParameter("FillSummaryProfileAtLayerLevel") && fPSet_.getParameter("OutputSummaryProfileAtLayerLevelAsImage")){ - if( CondObj_fillId_ =="onlyProfile" || CondObj_fillId_ =="ProfileAndCumul"){ - - TCanvas c1("c1"); - selME.SummaryOfProfileDistr->getTProfile()->Draw(); - std::string name (selME.SummaryOfProfileDistr->getTProfile()->GetTitle()); - name+=".png"; - c1.Print(name.c_str()); + savePNG(selME.SummaryOfProfileDistr); } } if(hPSet_.getParameter("FillSummaryAtLayerLevel") && fPSet_.getParameter("OutputSummaryAtLayerLevelAsImage")){ - - TCanvas c1("c1"); - selME.SummaryDistr->getTH1()->Draw(); - std::string name (selME.SummaryDistr->getTH1()->GetTitle()); - name+=".png"; - c1.Print(name.c_str()); + savePNG(selME.SummaryDistr); } - } - } // ----- diff --git a/DQM/SiStripMonitorSummary/src/SiStripQualityDQM.cc b/DQM/SiStripMonitorSummary/src/SiStripQualityDQM.cc index e7dda5a8bccdb..52b87019a78b5 100644 --- a/DQM/SiStripMonitorSummary/src/SiStripQualityDQM.cc +++ b/DQM/SiStripMonitorSummary/src/SiStripQualityDQM.cc @@ -31,27 +31,6 @@ void SiStripQualityDQM::getActiveDetIds(const edm::EventSetup & eSetup){ //================================================ // ----- -void SiStripQualityDQM::fillModMEs(const std::vector & selectedDetIds, const edm::EventSetup& es){ - - //Retrieve tracker topology from geometry - edm::ESHandle tTopoHandle; - es.get().get(tTopoHandle); - const TrackerTopology* const tTopo = tTopoHandle.product(); - - ModMEs CondObj_ME; - - for(std::vector::const_iterator detIter_ = selectedDetIds.begin(); - detIter_!= selectedDetIds.end();detIter_++){ - fillMEsForDet(CondObj_ME,*detIter_,tTopo); - - } -} -// ----- - - - -//=================================================== -// ----- void SiStripQualityDQM::fillMEsForDet(const ModMEs& _selModME_, uint32_t selDetId_, const TrackerTopology* tTopo){ ModMEs selModME_ = _selModME_; getModMEs(selModME_,selDetId_, tTopo); @@ -69,31 +48,14 @@ void SiStripQualityDQM::fillMEsForDet(const ModMEs& _selModME_, uint32_t selDetI //==================================================== // ----- -void SiStripQualityDQM::fillSummaryMEs(const std::vector & selectedDetIds, const edm::EventSetup& es){ - - //Retrieve tracker topology from geometry - edm::ESHandle tTopoHandle; - es.get().get(tTopoHandle); - const TrackerTopology* const tTopo = tTopoHandle.product(); - - for(std::vector::const_iterator detIter_ = selectedDetIds.begin(); - detIter_!= selectedDetIds.end();detIter_++){ - fillMEsForLayer(/*SummaryMEsMap_,*/ *detIter_,tTopo); - - } - +void SiStripQualityDQM::saveSummaryMEs(){ for (std::map::iterator iter=SummaryMEsMap_.begin(); iter!=SummaryMEsMap_.end(); iter++){ ModMEs selME; selME = iter->second; if(hPSet_.getParameter("FillSummaryAtLayerLevel") && fPSet_.getParameter("OutputSummaryAtLayerLevelAsImage")){ - - TCanvas c1("c1"); - selME.SummaryDistr->getTH1()->Draw(); - std::string name (selME.SummaryDistr->getTH1()->GetTitle()); - name+=".png"; - c1.Print(name.c_str()); + savePNG(selME.SummaryOfProfileDistr); } } diff --git a/DQM/SiStripMonitorSummary/src/SiStripThresholdDQM.cc b/DQM/SiStripMonitorSummary/src/SiStripThresholdDQM.cc index 47ff2e93c21e1..141e48e37a841 100644 --- a/DQM/SiStripMonitorSummary/src/SiStripThresholdDQM.cc +++ b/DQM/SiStripMonitorSummary/src/SiStripThresholdDQM.cc @@ -35,29 +35,6 @@ void SiStripThresholdDQM::getActiveDetIds(const edm::EventSetup & eSetup){ //===================================================================================== - -// ----- -void SiStripThresholdDQM::fillModMEs(const std::vector & selectedDetIds, const edm::EventSetup& es){ - - //Retrieve tracker topology from geometry - edm::ESHandle tTopoHandle; - es.get().get(tTopoHandle); - const TrackerTopology* const tTopo = tTopoHandle.product(); - - ModMEs CondObj_ME; - - - for(std::vector::const_iterator detIter_ = selectedDetIds.begin(); - detIter_!= selectedDetIds.end();detIter_++){ - - fillMEsForDet(CondObj_ME,*detIter_,tTopo); - - } -} -// ----- - - - //====================================================================================== // ----- @@ -96,22 +73,6 @@ void SiStripThresholdDQM::fillMEsForDet(const ModMEs& _selModME_, uint32_t selDe //======================================================================================= // ----- -void SiStripThresholdDQM::fillSummaryMEs(const std::vector & selectedDetIds, const edm::EventSetup& es){ - - //Retrieve tracker topology from geometry - edm::ESHandle tTopoHandle; - es.get().get(tTopoHandle); - const TrackerTopology* const tTopo = tTopoHandle.product(); - - for(std::vector::const_iterator detIter_ = selectedDetIds.begin(); - detIter_!= selectedDetIds.end();detIter_++){ - fillMEsForLayer(/*SummaryMEsMap_,*/ *detIter_,tTopo); - - } - -} -// ----- - //======================================================================================= // ----- From 5bc9bd80b712acce65686e2dd2d8db90976ae68a Mon Sep 17 00:00:00 2001 From: mauro verzetti Date: Mon, 16 Feb 2015 16:00:38 +0100 Subject: [PATCH 28/28] added CLI options to produce strip tracker-wide plots and noise gain renormalization --- .../python/SiStripMonitorCondData_cfi.py | 1 + .../test/DBReader_conddbmonitoring_generic_cfg.py | 12 ++++++++++++ 2 files changed, 13 insertions(+) diff --git a/DQM/SiStripMonitorSummary/python/SiStripMonitorCondData_cfi.py b/DQM/SiStripMonitorSummary/python/SiStripMonitorCondData_cfi.py index 6a8627ddfafb5..1babf9b05ec3a 100644 --- a/DQM/SiStripMonitorSummary/python/SiStripMonitorCondData_cfi.py +++ b/DQM/SiStripMonitorSummary/python/SiStripMonitorCondData_cfi.py @@ -25,6 +25,7 @@ HistoMaps_On = cms.bool(True), SummaryOnStringLevel_On = cms.bool(False), SummaryOnLayerLevel_On = cms.bool(True), + GlobalPlots = cms.bool(False), GrandSummary_On = cms.bool(True), StripQualityLabel = cms.string(''), diff --git a/DQM/SiStripMonitorSummary/test/DBReader_conddbmonitoring_generic_cfg.py b/DQM/SiStripMonitorSummary/test/DBReader_conddbmonitoring_generic_cfg.py index bbd22821fe989..51bdbabee7d0c 100644 --- a/DQM/SiStripMonitorSummary/test/DBReader_conddbmonitoring_generic_cfg.py +++ b/DQM/SiStripMonitorSummary/test/DBReader_conddbmonitoring_generic_cfg.py @@ -86,6 +86,11 @@ VarParsing.VarParsing.multiplicity.singleton, # singleton or list VarParsing.VarParsing.varType.bool, # string, int, or float "Monitor noise?") +options.register ('GainRenormalisation', + False, + VarParsing.VarParsing.multiplicity.singleton, # singleton or list + VarParsing.VarParsing.varType.bool, # string, int, or float + "Renormalize noise according to gain?") options.register ('QualityMon', False, VarParsing.VarParsing.multiplicity.singleton, # singleton or list @@ -121,6 +126,11 @@ VarParsing.VarParsing.multiplicity.singleton, # singleton or list VarParsing.VarParsing.varType.bool, # string, int, or float "Cumulative Monitoring?") +options.register ('GlobalPlots', + False, + VarParsing.VarParsing.multiplicity.singleton, # singleton or list + VarParsing.VarParsing.varType.bool, # string, int, or float + "Produce detector-wide plots?") options.register ('ActiveDetId', False, VarParsing.VarParsing.multiplicity.singleton, # singleton or list @@ -241,6 +251,7 @@ process.CondDataMonitoring.FillConditions_PSet.TkMap_On = True # This is just for test until TkMap is included in all classes!!! Uncomment!!!! process.CondDataMonitoring.FillConditions_PSet.ActiveDetIds_On = options.ActiveDetId # This should be set to False only for Lorentz Angle process.CondDataMonitoring.FillConditions_PSet.Mod_On = False # Set to True if you want to have single module histograms + process.CondDataMonitoring.FillConditions_PSet.GlobalPlots = options.GlobalPlots process.CondDataMonitoring.SiStripPedestalsDQM_PSet.FillSummaryAtLayerLevel = True process.CondDataMonitoring.SiStripNoisesDQM_PSet.FillSummaryAtLayerLevel = True @@ -280,6 +291,7 @@ process.CondDataMonitoring.SiStripNoisesDQM_PSet.TkMapName = 'NoiseTkMap.png' process.CondDataMonitoring.SiStripNoisesDQM_PSet.minValue = 3. process.CondDataMonitoring.SiStripNoisesDQM_PSet.maxValue = 9. + process.CondDataMonitoring.SiStripNoisesDQM_PSet.GainRenormalisation = options.GainRenormalisation process.CondDataMonitoring.SiStripApvGainsDQM_PSet.TkMap_On = True process.CondDataMonitoring.SiStripApvGainsDQM_PSet.TkMapName = 'GainTkMap.png'