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 <vector>
+#include <climits>
+#include <algorithm>
+
+#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<class Pulse>
+    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 = &paramMask_[0];
+                for (unsigned i=0; i<nExpected; ++i)
+                    count += mask[i];
+                allSet_ = count == nExpected;
+            }
+            else
+                allSet_ = true;
+        }
+        return allSet_;
+    }
+
+    inline void setParameter(const unsigned which, const double value)
+    {
+        if (!initialized_)
+            initialize();
+        paramMask_.at(which) = 1;
+        params_[which] = value;
+    }
+
+    inline double getParameter(const unsigned which) const
+    {
+        if (!paramMask_.at(which)) throw cms::Exception(
+            "In AbsElectronicODERHS::getParameter: no such parameter or "
+            "parameter value is not established yet");
+        return params_[which];
+    }
+
+    inline const std::vector<double>& 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<imax; ++i)
+            {
+                params_[i] = values[i];
+                paramMask_[i] = 1;
+            }
+        }
+    }
+
+    inline void setLeadingParameters(const std::vector<double>& values)
+    {
+        if (!values.empty())
+            setLeadingParameters(&values[0], values.size());
+    }
+
+protected:
+    HcalInterpolatedPulse inputPulse_;
+    std::vector<double> params_;
+
+private:
+    std::vector<unsigned char> 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<nExpected; ++i)
+                paramMask_[i] = 0;
+        }
+        initialized_ = true;
+    }
+};
+
+#endif // CalibCalorimetry_HcalAlgos_AbsElectronicODERHS_h_
diff --git a/CalibCalorimetry/HcalAlgos/interface/AbsODERHS.h b/CalibCalorimetry/HcalAlgos/interface/AbsODERHS.h
new file mode 100644
index 0000000000000..271dc6820fa4f
--- /dev/null
+++ b/CalibCalorimetry/HcalAlgos/interface/AbsODERHS.h
@@ -0,0 +1,18 @@
+#ifndef CalibCalorimetry_HcalAlgos_AbsODERHS_h_
+#define CalibCalorimetry_HcalAlgos_AbsODERHS_h_
+
+//
+// Base class for the ODE right hand sides
+//
+class AbsODERHS
+{
+public:
+    inline virtual ~AbsODERHS() {}
+
+    virtual AbsODERHS* clone() const = 0;
+
+    virtual void calc(double t, const double* x, unsigned lenX,
+                      double* derivative) = 0;
+};
+
+#endif // CalibCalorimetry_HcalAlgos_AbsODERHS_h_
diff --git a/CalibCalorimetry/HcalAlgos/interface/ConstantStepOdeSolver.h b/CalibCalorimetry/HcalAlgos/interface/ConstantStepOdeSolver.h
new file mode 100644
index 0000000000000..cb30ab1350429
--- /dev/null
+++ b/CalibCalorimetry/HcalAlgos/interface/ConstantStepOdeSolver.h
@@ -0,0 +1,184 @@
+#ifndef CalibCalorimetry_HcalAlgos_ConstantStepOdeSolver_h_
+#define CalibCalorimetry_HcalAlgos_ConstantStepOdeSolver_h_
+
+#include <vector>
+#include <iostream>
+#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<double> historyBuffer_;
+    std::vector<double> 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<double> 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<double> 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 <cassert>
+#include <algorithm>
+
+#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 ODE1, class ODE2, class DelayTimeModel1, class DelayTimeModel2>
+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 = &params_[npTau1 + npOde1 + npTau2 + npOde2];
+        const double* pars = pstart;
+        const double ctlGainOut = *pars++;
+        const double inGainOut  = *pars++;
+        const double outGainOut = *pars++;
+        assert(thisCodeNumPars == static_cast<unsigned>(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, &params_[firstPar], npTau2);
+
+        // Set the ODE parameters for the control circuit
+        firstPar += npTau2;
+        if (npOde2)
+            ode2_.setParameters(&params_[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, &params_[0], npTau1);
+
+        // ODE parameters for the output circuit
+        if (npOde1)
+            ode1_.setParameters(&params_[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<const AbsElectronicODERHS*>(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<class Signal>
+    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<class Real>
+    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<AbsElectronicODERHS*>(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<double> initialConditions_;
+    std::vector<double> 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 <cassert>
+
+#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<runLen_; ++i)
+        if (hbuf[dim_*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<ConstantStepOdeSolver*>(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; i<rlenm1; ++i)
+    {
+        sum += (coord[dim_*(i-2U)]*(-1.0/24.0) +
+                coord[dim_*(i-1U)]*(13.0/24.0) +
+                coord[dim_*i]     *(13.0/24.0) +
+                coord[dim_*(i+1U)]*(-1.0/24.0));
+        integ[i] = sum;
+    }
+    sum += (coord[dim_*rlenm1]     *(3.0/8.0) +
+            coord[dim_*(rlenm1-1U)]*(19.0/24.0) +
+            coord[dim_*(rlenm1-2U)]*(-5.0/24.0) +
+            coord[dim_*(rlenm1-3U)]*(1.0/24.0));
+    integ[rlenm1] = sum;                                      
+    if (dt_ != 1.0)
+        for (unsigned i=1; i<runLen_; ++i)
+            integ[i] *= dt_;
+    lastIntegrated_ = which;
+}
+
+void ConstantStepOdeSolver::writeHistory(std::ostream& os,
+                                         const double dt,
+                                         const bool cubic) const
+{
+    os << "# " << this->methodName() << '\n';
+    if (dim_ && runLen_)
+    {
+        if (dt == dt_)
+        {
+            for (unsigned ipt=0; ipt<runLen_; ++ipt)
+            {
+                os << getTime(ipt);
+                for (unsigned which=0; which<dim_; ++which)
+                    os << ' ' << getCoordinate(which, ipt);
+                os << '\n';
+            }
+        }
+        else
+        {
+            const double tmax = lastMaxT();
+            for (unsigned i=0; ; ++i)
+            {
+                const double t = i*dt;
+                if (t > tmax)
+                    break;
+                os << t;
+                for (unsigned which=0; which<dim_; ++which)
+                    os << ' ' << interpolateCoordinate(which, t, cubic);
+                os << '\n';
+            }
+        }
+    }
+}
+
+void ConstantStepOdeSolver::writeIntegrated(std::ostream& os,
+                                            const unsigned which,
+                                            const double dt,
+                                            const bool cubic) const
+{
+    os << "# " << this->methodName() << '\n';
+    if (dim_ && runLen_)
+    {
+        if (dt == dt_)
+        {
+            for (unsigned ipt=0; ipt<runLen_; ++ipt)
+                os << getTime(ipt) << ' ' << getIntegrated(which, ipt) << '\n';
+        }
+        else
+        {
+            const double tmax = lastMaxT();
+            for (unsigned i=0; ; ++i)
+            {
+                const double t = i*dt;
+                if (t > 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<runLen_; ++i)
+    {
+        if (buf[dim_*i] < minValue)
+            buf[dim_*i] = minValue;
+        else if (buf[dim_*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<ConstantStepOdeSolver*>(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; i<len; ++i)
+        *arr++ = *data++;
+    for (unsigned i=0; i<dim; ++i)
+        *arr++ = 0.0;
+}
+
+void ConstantStepOdeSolver::run(const double* initialConditions,
+                                const unsigned lenInitialConditions,
+                                const double dt, const unsigned nSteps)
+{
+    if (!nSteps || !lenInitialConditions)
+        return;
+    if (!rhs_) throw cms::Exception(
+        "In ConstantStepOdeSolver::run: ODE right hand side has not been set");
+    if (dt <= 0.0) throw cms::Exception(
+        "In ConstantStepOdeSolver::run: can not run backwards in time");
+    assert(initialConditions);
+    dt_ = dt;
+    dim_ = lenInitialConditions;
+    lastIntegrated_ = dim_;
+    runLen_ = nSteps + 1U;
+    const unsigned sz = (runLen_+1U)*dim_;
+    if (historyBuffer_.size() < sz)
+        historyBuffer_.resize(sz);
+    double* arr = &historyBuffer_[0];
+    for (unsigned i=0; i<lenInitialConditions; ++i)
+        arr[i] = initialConditions[i];
+    double* stepBuffer = arr + runLen_*dim_;
+
+    for (unsigned i = 0; i < nSteps; ++i, arr += lenInitialConditions)
+    {
+        const double t = i*dt;
+        this->step(t, dt, arr, lenInitialConditions, stepBuffer);
+        double* next = arr + lenInitialConditions;
+        for (unsigned i=0; i<lenInitialConditions; ++i)
+            next[i] = arr[i] + stepBuffer[i];
+    }
+}
+
+void EulerOdeSolver::step(const double t, const double dt,
+                          const double* x, const unsigned lenX,
+                          double* coordIncrement) const
+{
+    rhs_->calc(t, x, lenX, coordIncrement);
+    for (unsigned i=0; i<lenX; ++i)
+        coordIncrement[i] *= dt;
+}
+
+void RK2::step(const double t, const double dt,
+               const double* x, const unsigned lenX,
+               double* coordIncrement) const
+{
+    const double halfstep = dt/2.0;
+    if (buf_.size() < lenX)
+        buf_.resize(lenX);
+    double* midpoint = &buf_[0];
+    rhs_->calc(t, x, lenX, midpoint);
+    for (unsigned i=0; i<lenX; ++i)
+    {
+        midpoint[i] *= halfstep;
+        midpoint[i] += x[i];
+    }
+    rhs_->calc(t + halfstep, midpoint, lenX, coordIncrement);
+    for (unsigned i=0; i<lenX; ++i)
+        coordIncrement[i] *= dt;
+}
+
+void RK4::step(const double t, const double dt,
+               const double* x, const unsigned lenX,
+               double* coordIncrement) const
+{
+    const double halfstep = dt/2.0;
+    if (buf_.size() < 4*lenX)
+        buf_.resize(4*lenX);
+    double* k1x = &buf_[0];
+    double* k2x = k1x + lenX;
+    double* k3x = k2x + lenX;
+    double* k4x = k3x + lenX;
+    rhs_->calc(t, x, lenX, k1x);
+    for (unsigned i=0; i<lenX; ++i)
+        coordIncrement[i] = x[i] + halfstep*k1x[i];
+    rhs_->calc(t + halfstep, coordIncrement, lenX, k2x);
+    for (unsigned i=0; i<lenX; ++i)
+        coordIncrement[i] = x[i] + halfstep*k2x[i];
+    rhs_->calc(t + halfstep, coordIncrement, lenX, k3x);
+    for (unsigned i=0; i<lenX; ++i)
+        coordIncrement[i] = x[i] + dt*k3x[i];
+    rhs_->calc(t + dt, coordIncrement, lenX, k4x);
+    for (unsigned i=0; i<lenX; ++i)
+        coordIncrement[i] = dt/6.0*(k1x[i] + 2.0*(k2x[i] + k3x[i]) + k4x[i]);
+}
diff --git a/CalibCalorimetry/HcalAlgos/src/LowPassFilterTiming.cc b/CalibCalorimetry/HcalAlgos/src/LowPassFilterTiming.cc
new file mode 100644
index 0000000000000..c8e78f83301cc
--- /dev/null
+++ b/CalibCalorimetry/HcalAlgos/src/LowPassFilterTiming.cc
@@ -0,0 +1,88 @@
+#include <cmath>
+#include <cassert>
+#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 <cassert>
+#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 <cmath>
+#include <cfloat>
+
+#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<double>(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<runLen; ++istep, ++hbuf)
+            rhs.calc(istep*dt, 0, 0U, hbuf);
+        solver_.setHistory(dt, &historyBuffer_[0], 1U, runLen);
+    }
+
+    // Truncate the preamp output if this will affect subsequent results
+    if (integrateToGetCharge_ && preampOutputCut_ > -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<lenTS; ++its)
+        {
+            const double t0 = tDigitize + its*tsWidth;
+            if (t0 < lastTStop)
+            {
+                double t1 = t0 + tsWidth;
+                if (t1 > 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<sz; ++i)
+            *c++ = *values++;
+    }
+}
+
+void QIE8Simulator::setRHS(const AbsElectronicODERHS& rhs,
+                           const unsigned chargeNode,
+                           const bool useCubicInterpolation)
+{
+    if (chargeNode >= 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<sz; ++i)
+            *c++ = 0.0;
+    }
+}
+
+void QIE8Simulator::validateGain() const
+{
+    if (inputGain_ <= 0.0) throw cms::Exception(
+        "In QIE8Simulator::validateGain: invalid input gain");
+}
+
+double QIE8Simulator::lastStopTime() const
+{
+    if (!runCount_) throw cms::Exception(
+        "In QIE8Simulator::lastStopTime: please run the simulation first");
+    return solver_.lastMaxT();
+}
+
+double QIE8Simulator::totalIntegratedCharge(const double t) const
+{
+    if (!runCount_) throw cms::Exception(
+        "In QIE8Simulator::totalIntegratedCharge: "
+        "please run the simulation first");
+    return outputGain_*getCharge(t);
+}
diff --git a/CalibCalorimetry/HcalAlgos/src/ThirdOrderDelayODE.cc b/CalibCalorimetry/HcalAlgos/src/ThirdOrderDelayODE.cc
new file mode 100644
index 0000000000000..64ed6d6ca1e5b
--- /dev/null
+++ b/CalibCalorimetry/HcalAlgos/src/ThirdOrderDelayODE.cc
@@ -0,0 +1,35 @@
+#include <cmath>
+#include <cassert>
+#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/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;
 
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/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<DYTParamsObjectRcd> {};
+
+#endif
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:
+    <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<HcalInterpolatedPulseCollRcd> {};
+
+#endif // CondFormats_HcalInterpolatedPulseCollRcd_h
+
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/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<sz; ++i)
+            if (dat[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<uint32_t> group_;
+
+    inline bool validate() const
+    {
+        return group_.size() == HBHELinearMap::ChannelCount;
+    }
+
+    friend class boost::serialization::access;
+
+    template<class Archive>
+    inline void save(Archive & ar, const unsigned /* version */) const
+    {
+        if (!validate()) throw cms::Exception(
+            "In HBHEChannelGroups::save: invalid data");
+        ar & group_;
+    }
+
+    template<class Archive>
+    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 <vector>
+#include <utility>
+
+#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<HBHEChannelId,unsigned> MapPair;
+    typedef std::vector<MapPair> 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..370675649a178
--- /dev/null
+++ b/CondFormats/HcalObjects/interface/HcalInterpolatedPulseColl.h
@@ -0,0 +1,49 @@
+#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 HcalInterpolatedPulseColl
+{
+public:
+    HcalInterpolatedPulseColl(
+        const std::vector<HcalInterpolatedPulse>& 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<HcalInterpolatedPulse> pulses_;
+    HBHEChannelGroups groups_;
+
+public:
+    // Default constructor needed for serialization.
+    // Do not use in application code.
+    inline HcalInterpolatedPulseColl() {}
+
+private:
+    friend class boost::serialization::access;
+
+    template<class Archive>
+    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 <cassert>
+#include "FWCore/Utilities/interface/Exception.h"
+
+#include "boost/serialization/access.hpp"
+#include "boost/serialization/version.hpp"
+
+template<unsigned MaxLen>
+class InterpolatedPulse
+{
+    template <unsigned Len2> 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 <typename Real>
+    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<length_; ++i)
+            *buf++ = *rbuf++;
+    }
+
+    // Converting copy constructor
+    template <unsigned Len2>
+    inline InterpolatedPulse(const InterpolatedPulse<Len2>& 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<length_; ++i)
+            *buf++ = *rbuf++;
+    }
+
+    // Efficient assignment operator
+    inline InterpolatedPulse& operator=(const InterpolatedPulse& r)
+    {
+        if (this != &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<length_; ++i)
+                *buf++ = *rbuf++;
+        }
+        return *this;
+    }
+
+    // Converting assignment operator
+    template <unsigned Len2>
+    inline InterpolatedPulse& operator=(const InterpolatedPulse<Len2>& 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<length_; ++i)
+            *buf++ = *rbuf++;
+        return *this;
+    }
+
+    template <typename Real>
+    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<len; ++i)
+            *buf++ = *values++;
+    }
+
+    // Zero out the signal
+    inline void zeroOut()
+    {
+        for (unsigned i=0; i<length_; ++i)
+            pulse_[i] = 0.0;
+    }
+
+    // Simple inspectors
+    inline const double* getPulse() const {return &pulse_[0];}
+    inline unsigned getLength() const {return length_;}
+    inline double getStartTime() const {return tmin_;}
+    inline double getStopTime() const {return tmin_ + width_;}
+    inline double getPulseWidth() const {return width_;}
+    inline double getTimeStep() const {return width_/(length_ - 1U);}
+
+    // Simple modifiers
+    inline void setStartTime(const double newStartTime)
+        {tmin_ = newStartTime;}
+
+    inline void setPulseWidth(const double newWidth)
+    {
+        if (newWidth <= 0.0) throw cms::Exception(
+            "In InterpolatedPulse::setPulseWidth: invalid pulse width");
+        width_ = newWidth;
+    }
+
+    // Get the pulse value at the given time using linear interpolation
+    inline double operator()(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;
+        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<length_; ++i)
+                *buf++ *= scale;
+        }
+        return *this;
+    }
+
+    // Add another pulse to this one. Note that addition of another pulse
+    // will not change the start time or the width of _this_ pulse. The
+    // added pulse will be truncated as needed.
+    template <unsigned Len2>
+    inline InterpolatedPulse& operator+=(const InterpolatedPulse<Len2>& r)
+    {
+        const double step = width_/(length_ - 1U);
+        for (unsigned i=0; i<length_; ++i)
+            pulse_[i] += r(tmin_ + i*step);
+        return *this;
+    }
+
+    template <unsigned Len2>
+    inline bool operator==(const InterpolatedPulse<Len2>& 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<length_; ++i)
+            if (*buf++ != *rbuf++)
+                return false;
+        return true;
+    }
+
+    template <unsigned Len2>
+    inline bool operator!=(const InterpolatedPulse<Len2>& 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; i<nIntervals; ++i)
+            sum += buf[i];
+        sum += buf[nIntervals]/2.0;
+        return sum*width_/nIntervals;
+    }
+
+    inline void setIntegral(const double newValue)
+    {
+        const double integ = this->getIntegral();
+        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<length_; ++i)
+            if (buf[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<class Archive>
+    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<length_; ++i)
+            ar & pulse_[i];
+    }
+};
+
+// boost serialization version number for this template
+namespace boost {
+    namespace serialization {
+        template<unsigned MaxLen>
+        struct version<InterpolatedPulse<MaxLen> >
+        {
+            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 <cassert>
+#include "FWCore/Utilities/interface/Exception.h"
+#include <algorithm>
+
+#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<ChannelCount; ++i)
+        inverse_.push_back(MapPair(lookup_[i], i));
+    std::sort(inverse_.begin(), inverse_.end());
+}
+
+HcalSubdetector HBHELinearMap::getSubdetector(const unsigned depth,
+                                              const int ieta)
+{
+    const unsigned abseta = std::abs(ieta);
+
+    // Make sure the arguments are in range
+    if (!(abseta <= 29U))
+        throw cms::Exception("In HBHELinearMap::getSubdetector: "
+                                    "eta argument out of range");
+    if (!(depth > 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..9e6007815ea52
--- /dev/null
+++ b/CondFormats/HcalObjects/src/HcalInterpolatedPulseColl.cc
@@ -0,0 +1,25 @@
+#include "CondFormats/HcalObjects/interface/HcalInterpolatedPulseColl.h"
+#include "CondFormats/HcalObjects/interface/HBHELinearMap.h"
+
+HcalInterpolatedPulseColl::HcalInterpolatedPulseColl(
+    const std::vector<HcalInterpolatedPulse>& 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..6f8492d060aad 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;
+
+    // QIE8 input pulse representation objects
+    HcalInterpolatedPulse myHcalInterpolatedPulse;
+    std::vector<HcalInterpolatedPulse> myHcalInterpolatedPulseVec;
+    HBHEChannelGroups myHBHEChannelGroups;
+    HcalInterpolatedPulseColl myHcalInterpolatedPulseColl;
   };
 }
 
diff --git a/CondFormats/HcalObjects/src/classes_def.xml b/CondFormats/HcalObjects/src/classes_def.xml
index e039b505a24d2..b8fedfc18715b 100644
--- a/CondFormats/HcalObjects/src/classes_def.xml
+++ b/CondFormats/HcalObjects/src/classes_def.xml
@@ -391,5 +391,10 @@
  <class name="OOTPileupCorrectionBuffer">
   <field name="m_buffer" mapping="blob" />
  </class>
-
+ <class name="HcalInterpolatedPulse" class_version="1"/>
+ <class name="std::vector<HcalInterpolatedPulse>"/>
+ <class name="HBHEChannelGroups" class_version="1">
+  <field name="group_" mapping="blob" />
+ </class>
+ <class name="HcalInterpolatedPulseColl" class_version="1"/>
 </lcgdict>   
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"
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<vector>
+#include "DataFormats/DetId/interface/DetId.h"
+#include "CondFormats/Serialization/interface/Serializable.h"
+
+class DYTParamObject {
+ public:
+  
+  DYTParamObject() { };
+  DYTParamObject(uint32_t id, std::vector<double> & 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<double> 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 <vector>
+#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<DYTParamObject> & getParamObjs() const { return m_paramObjs; };
+
+  // Get the functional parametrization                                                                                                                                                                    
+  const std::string & formula() const { return m_formula; };
+
+ private:
+  
+  std::vector<DYTParamObject> 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..840f26598a460
--- /dev/null
+++ b/CondFormats/RecoMuonObjects/src/DYTParamObject.cc
@@ -0,0 +1,17 @@
+#include "CondFormats/RecoMuonObjects/interface/DYTParamObject.h"
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+
+double DYTParamObject::parameter(unsigned int iParam) const
+{
+  
+  if (iParam >= paramSize())
+    {
+      edm::LogWarning("DYTParamObject") 
+	<< "The requested parameter (" << (iParam + 1) 
+	<< ") is outside size range (" << paramSize() << ").";
+      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<PhysicsTools::Calibration::HistogramD2D> a;
     MuScleFitDBobject e;
+    DYTParamsObject g;
   };
 }
diff --git a/CondFormats/RecoMuonObjects/src/classes_def.xml b/CondFormats/RecoMuonObjects/src/classes_def.xml
index 53bf55a73c763..c7f12bc68f3e7 100644
--- a/CondFormats/RecoMuonObjects/src/classes_def.xml
+++ b/CondFormats/RecoMuonObjects/src/classes_def.xml
@@ -3,4 +3,7 @@
    <class name="DYTThrObject" class_version="0"/>
    <class name="DYTThrObject::DytThrStruct"/>
    <class name="std::vector<DYTThrObject::DytThrStruct>"/>
+   <class name="DYTParamsObject" class_version="2"/>
+   <class name="DYTParamObject"/>
+   <class name="std::vector<DYTParamObject>"/>
 </lcgdict>   
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<MuScleFitDBobject>();
+    testSerialization<DYTParamsObject>();
     testSerialization<DYTThrObject>();
     return 0;
 }
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<HcalInterpolatedPulseColl> HcalInterpolatedPulseDBWriter;
+
+typedef BoostIODBReader<HcalInterpolatedPulseColl,HcalInterpolatedPulseCollRcd> 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)
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_13TeV_TuneCUETP8M1_cfi.py
similarity index 95%
rename from Configuration/Generator/python/Pythia8_BuJpsiK_TuneZ2star_13TeV_TuneCUETP8M1_cfi.py
rename to Configuration/Generator/python/Pythia8_BuJpsiK_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_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/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/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/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 996479028c690..e0106a4f2ec0e 100644
--- a/Configuration/Generator/python/ZpEE_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py
+++ b/Configuration/Generator/python/ZpEE_2250_8TeV_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_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 4c89ab8efc37e..0360bb86f651a 100644
--- a/Configuration/Generator/python/ZpMM_2250_8TeV_Tauola_TuneCUETP8M1_cfi.py
+++ b/Configuration/Generator/python/ZpMM_2250_8TeV_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,
@@ -56,3 +49,4 @@
                                     )
         )
                          )
+ProductionFilterSequence = cms.Sequence(generator)
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/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_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..6576a2f09b01e 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']]
@@ -216,12 +216,12 @@
 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_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 1da319fd218c4..c5eb8c28483cf 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_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_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_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_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_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))
 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']=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,10 +392,10 @@ 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_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
@@ -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['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_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['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_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_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_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['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')}
@@ -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])
@@ -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_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_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_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_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_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_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_8TeV_TuneCUETP8M1_cfi',
                            '-s':'GEN,SIM,RECO,EI,HLT:@fake,VALIDATION',
                            '--fast':''},
                           step1FastDefaults])
@@ -932,8 +932,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/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']]
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<uint32_t> & selectedDetIds, const edm::EventSetup& es);
-  void fillSummaryMEs(const std::vector<uint32_t> & selectedDetIds, const edm::EventSetup& es);
-  
-  void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo);
-  
-  void fillMEsForLayer( /*std::map<uint32_t, ModMEs> 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<uint32_t, ModMEs> selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo);
   
   unsigned long long getCache(const edm::EventSetup & eSetup){ return eSetup.get<SiStripApvGainRcd>().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<uint32_t> & selectedDetIds, const edm::EventSetup& es){};
-  void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo){};
-  
-  void fillSummaryMEs(const std::vector<uint32_t> & selectedDetIds, const edm::EventSetup& es);
-  void fillMEsForLayer( /*std::map<uint32_t, ModMEs> 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<uint32_t, ModMEs> selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo);
   
   unsigned long long getCache(const edm::EventSetup & eSetup){ return eSetup.get<SiStripBackPlaneCorrectionRcd>().cacheIdentifier();}
   
@@ -35,6 +33,7 @@ class SiStripBackPlaneCorrectionDQM : public SiStripBaseCondObjDQM{
 
   private:
     edm::ESHandle<SiStripBackPlaneCorrection> 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<std::string,uint32_t> getLayerNameAndId(const uint32_t& detId_, const TrackerTopology* tTopo);
@@ -96,11 +98,12 @@ class SiStripBaseCondObjDQM {
     std::vector<uint32_t> GetSameLayerDetId(const std::vector<uint32_t>& activeDetIds, uint32_t selDetId, const TrackerTopology* tTopo);
 
 
-    virtual void fillModMEs(const std::vector<uint32_t> & selectedDetIds, const edm::EventSetup& es);
-    virtual void fillSummaryMEs(const std::vector<uint32_t> & selectedDetIds, const edm::EventSetup& es);
+    void fillModMEs(const std::vector<uint32_t> & selectedDetIds, const edm::EventSetup& es);
+    void fillSummaryMEs(const std::vector<uint32_t> & 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<uint32_t, ModMEs> 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<int> 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<uint32_t> & selectedDetIds, const edm::EventSetup& es){;}
-  void fillSummaryMEs(const std::vector<uint32_t> & selectedDetIds, const edm::EventSetup& es){;}
-
-  void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo){;}
-  void fillMEsForLayer( /*std::map<uint32_t, ModMEs> 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<uint32_t, ModMEs> selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo){;}
 
   void getActiveDetIds(const edm::EventSetup & eSetup);
   unsigned long long getCache(const edm::EventSetup & eSetup){ return eSetup.get<SiStripDetCablingRcd>().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<uint32_t> & selectedDetIds, const edm::EventSetup& es){};
-  void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo){};
-  
-  void fillSummaryMEs(const std::vector<uint32_t> & selectedDetIds, const edm::EventSetup& es);
-  void fillMEsForLayer( /*std::map<uint32_t, ModMEs> 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<uint32_t, ModMEs> selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo);
   
   unsigned long long getCache(const edm::EventSetup & eSetup){ return eSetup.get<SiStripLorentzAngleRcd>().cacheIdentifier();}
   
@@ -35,6 +33,7 @@ class SiStripLorentzAngleDQM : public SiStripBaseCondObjDQM{
 
   private:
     edm::ESHandle<SiStripLorentzAngle> 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<uint32_t, ModMEs> selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo);
+  virtual void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo);
+  virtual void fillMEsForLayer( /*std::map<uint32_t, ModMEs> 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<SiStripNoisesRcd>().cacheIdentifier();}
+  unsigned long long getCache(const edm::EventSetup & eSetup){return eSetup.get<SiStripNoisesRcd>().cacheIdentifier();}
   
   void getConditionObject(const edm::EventSetup & eSetup){
     eSetup.get<SiStripNoisesRcd>().get(noiseHandle_);
@@ -35,7 +36,7 @@ class SiStripNoisesDQM : public SiStripBaseCondObjDQM{
     bool gainRenormalisation_;
     edm::ESHandle<SiStripNoises> noiseHandle_; 
     edm::ESHandle<SiStripApvGain> 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<uint32_t> & selectedDetIds, const edm::EventSetup& es);
-  void fillSummaryMEs(const std::vector<uint32_t> & selectedDetIds, const edm::EventSetup& es);
- 	       
-  void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo);
-  void fillMEsForLayer( /*std::map<uint32_t, ModMEs> 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<uint32_t, ModMEs> selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo);
   
   unsigned long long getCache(const edm::EventSetup & eSetup){ return eSetup.get<SiStripPedestalsRcd>().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<uint32_t> & selectedDetIds, const edm::EventSetup& es);
-  void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo);
-  
-  void fillSummaryMEs(const std::vector<uint32_t> & selectedDetIds, const edm::EventSetup& es);
-  void fillMEsForLayer( /*std::map<uint32_t, ModMEs> 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<uint32_t, ModMEs> 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<uint32_t> & selectedDetIds, const edm::EventSetup& es); 
-   void fillSummaryMEs(const std::vector<uint32_t> & selectedDetIds, const edm::EventSetup& es); 
- 	       
-  void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo);
-  void fillMEsForLayer( /*std::map<uint32_t, ModMEs> selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo);
+  virtual void fillMEsForDet(const ModMEs& selModME_,uint32_t selDetId_, const TrackerTopology* tTopo);
+  virtual void fillMEsForLayer( /*std::map<uint32_t, ModMEs> selModMEsMap_, */ uint32_t selDetId_, const TrackerTopology* tTopo);
   
   unsigned long long getCache(const edm::EventSetup & eSetup){ return eSetup.get<SiStripThresholdRcd>().cacheIdentifier();}
   
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/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<uint32_t> & selectedDetIds, const edm::EventSetup& es){
-
-  //Retrieve tracker topology from geometry
-  edm::ESHandle<TrackerTopology> tTopoHandle;
-  es.get<IdealGeometryRecord>().get(tTopoHandle);
-  const TrackerTopology* const tTopo = tTopoHandle.product();
-
-  ModMEs CondObj_ME;
-
-  for(std::vector<uint32_t>::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<uint32_t> & selectedDetIds, const edm::EventSetup& es){
-  
-  //Retrieve tracker topology from geometry
-  edm::ESHandle<TrackerTopology> tTopoHandle;
-  es.get<IdealGeometryRecord>().get(tTopoHandle);
-  const TrackerTopology* const tTopo = tTopoHandle.product();
-
-  for(std::vector<uint32_t>::const_iterator detIter_ = selectedDetIds.begin();
-      detIter_!= selectedDetIds.end();detIter_++){
-    fillMEsForLayer(/*SummaryMEsMap_,*/ *detIter_, tTopo);
-  }
-
+//==========================                                                                                                                                                                                     
+void SiStripApvGainsDQM::saveSummaryMEs(){
   for (std::map<uint32_t, ModMEs>::iterator iter=SummaryMEsMap_.begin(); iter!=SummaryMEsMap_.end(); iter++){
 
     ModMEs selME;
     selME = iter->second;
 
     if(hPSet_.getParameter<bool>("FillSummaryProfileAtLayerLevel") && fPSet_.getParameter<bool>("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<bool>("FillSummaryAtLayerLevel") && fPSet_.getParameter<bool>("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<uint32_t> & selectedDetIds, const edm::EventSetup& es){
-
-  //Retrieve tracker topology from geometry
-  edm::ESHandle<TrackerTopology> tTopoHandle;
-  es.get<IdealGeometryRecord>().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<selectedDetIds.size();i++){					    
-    int subDetId_ = ((selectedDetIds[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<uint32_t, ModMEs>::iterator iter=SummaryMEsMap_.begin(); iter!=SummaryMEsMap_.end(); iter++){
 
     ModMEs selME;
     selME = iter->second;
 
     if(SummaryOnStringLevel_On_){
-
       if (fPSet_.getParameter<bool>("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<bool>("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<bool>("FillSummaryProfileAtLayerLevel") && fPSet_.getParameter<bool>("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<bool>("FillCumulativeSummaryAtLayerLevel") && fPSet_.getParameter<bool>("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<uint32_t> &
 
 // -----
 void SiStripBackPlaneCorrectionDQM::fillMEsForLayer( /*std::map<uint32_t, ModMEs> 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<uint32_t, ModMEs
 
   std::string hSummary_name; 
 
-  int subDetId_ = ((selDetId_>>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<bool>("SummaryOnStringLevel_On");
 
   GrandSummary_On_         = fPSet_.getParameter<bool>("GrandSummary_On");
-
+  GlobalPlots_ = fPSet_.existsAs<bool>("GlobalPlots") ? fPSet_.getParameter<bool>("GlobalPlots") : false;
   CondObj_fillId_    = hPSet_.getParameter<std::string>("CondObj_fillId");
   CondObj_name_      = hPSet_.getParameter<std::string>("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<uint32_t>::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<bool>("TkMap_On") || hPSet_.getParameter<bool>("TkMap_On")) {
     std::string filename = hPSet_.getParameter<std::string>("TkMapName");
@@ -166,7 +174,6 @@ std::vector<uint32_t> SiStripBaseCondObjDQM::getCabledModules() {
 //#FIXME : very long method. please factorize it
  
 void SiStripBaseCondObjDQM::selectModules(std::vector<uint32_t> & detIds_){
-  
   edm::LogInfo("SiStripBaseCondObjDQM") << "[SiStripBaseCondObjDQM::selectModules] input detIds_: " << detIds_.size() << std::endl;
   
   if( fPSet_.getParameter<bool>("restrictModules")){
@@ -1246,13 +1253,37 @@ void SiStripBaseCondObjDQM::end(){
 }
 
 //==========================
-void SiStripBaseCondObjDQM::fillModMEs(const std::vector<uint32_t> & 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<TrackerTopology> tTopoHandle;
   es.get<IdealGeometryRecord>().get(tTopoHandle);
   const TrackerTopology* const tTopo = tTopoHandle.product();
+  return tTopo;
+}
+
 
+//==========================
+void SiStripBaseCondObjDQM::fillModMEs(const std::vector<uint32_t> & selectedDetIds, const edm::EventSetup& es){
+  const TrackerTopology* const tTopo = topo(es);
   ModMEs CondObj_ME;
  
   for(std::vector<uint32_t>::const_iterator detIter_=selectedDetIds.begin();
@@ -1261,19 +1292,8 @@ void SiStripBaseCondObjDQM::fillModMEs(const std::vector<uint32_t> & selectedDet
   }
 }
 
-//==========================
-void SiStripBaseCondObjDQM::fillSummaryMEs(const std::vector<uint32_t> & selectedDetIds, const edm::EventSetup& es){
-
-  //Retrieve tracker topology from geometry
-  edm::ESHandle<TrackerTopology> tTopoHandle;
-  es.get<IdealGeometryRecord>().get(tTopoHandle);
-  const TrackerTopology* const tTopo = tTopoHandle.product();
-  
-  for(std::vector<uint32_t>::const_iterator detIter_ = selectedDetIds.begin();
-      detIter_!= selectedDetIds.end();detIter_++){
-    fillMEsForLayer(/*SummaryMEsMap_,*/ *detIter_,tTopo);    
-  }
-
+//==========================    
+void SiStripBaseCondObjDQM::saveSummaryMEs(){
   for (std::map<uint32_t, ModMEs>::iterator iter=SummaryMEsMap_.begin();
        iter!=SummaryMEsMap_.end(); iter++){
 
@@ -1284,35 +1304,30 @@ void SiStripBaseCondObjDQM::fillSummaryMEs(const std::vector<uint32_t> & selecte
        fPSet_.getParameter<bool>("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<bool>("FillSummaryAtLayerLevel") &&
        fPSet_.getParameter<bool>("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<bool>("FillCumulativeSummaryAtLayerLevel") &&
        fPSet_.getParameter<bool>("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<uint32_t> & selectedDetIds, const edm::EventSetup& es){
+  const TrackerTopology* const tTopo = topo(es);
+
+  for(std::vector<uint32_t>::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<uint32_t> & selectedDetIds, const edm::EventSetup& es){
-
-  //Retrieve tracker topology from geometry
-  edm::ESHandle<TrackerTopology> tTopoHandle;
-  es.get<IdealGeometryRecord>().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<selectedDetIds.size();i++){					    
-    int subDetId_ = ((selectedDetIds[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<uint32_t, ModMEs>::iterator iter=SummaryMEsMap_.begin(); iter!=SummaryMEsMap_.end(); iter++){
 
     ModMEs selME;
     selME = iter->second;
 
     if(SummaryOnStringLevel_On_){
-
       if (fPSet_.getParameter<bool>("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<bool>("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<bool>("FillSummaryProfileAtLayerLevel") && fPSet_.getParameter<bool>("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<bool>("FillCumulativeSummaryAtLayerLevel") && fPSet_.getParameter<bool>("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<uint32_t> & select
 
 // -----
 void SiStripLorentzAngleDQM::fillMEsForLayer( /*std::map<uint32_t, ModMEs> 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<uint32_t, ModMEs> 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; istrip<nStrip; ++istrip){
+    if( gainRenormalisation_ )
+      gainFactor= gainHandle_ ->getStripGain(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<uint32_t> & selectedDetIds, const edm::EventSetup& es){
-   
-  //Retrieve tracker topology from geometry
-  edm::ESHandle<TrackerTopology> tTopoHandle;
-  es.get<IdealGeometryRecord>().get(tTopoHandle);
-  const TrackerTopology* const tTopo = tTopoHandle.product();
-
-  ModMEs CondObj_ME;
-  
-  for(std::vector<uint32_t>::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<uint32_t> & selectedDetIds, const edm::EventSetup& es){
-   
-  //Retrieve tracker topology from geometry
-  edm::ESHandle<TrackerTopology> tTopoHandle;
-  es.get<IdealGeometryRecord>().get(tTopoHandle);
-  const TrackerTopology* const tTopo = tTopoHandle.product();
-
-  for(std::vector<uint32_t>::const_iterator detIter_ = selectedDetIds.begin();
-      detIter_!= selectedDetIds.end();detIter_++){
-    fillMEsForLayer(/*SummaryMEsMap_,*/ *detIter_,tTopo);
-  }
-
+void SiStripPedestalsDQM::saveSummaryMEs(){
   for (std::map<uint32_t, ModMEs>::iterator iter=SummaryMEsMap_.begin(); iter!=SummaryMEsMap_.end(); iter++){
 
     ModMEs selME;
     selME = iter->second;
 
     if(hPSet_.getParameter<bool>("FillSummaryProfileAtLayerLevel") && fPSet_.getParameter<bool>("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<bool>("FillSummaryAtLayerLevel") && fPSet_.getParameter<bool>("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<uint32_t> & selectedDetIds, const edm::EventSetup& es){
-
-  //Retrieve tracker topology from geometry
-  edm::ESHandle<TrackerTopology> tTopoHandle;
-  es.get<IdealGeometryRecord>().get(tTopoHandle);
-  const TrackerTopology* const tTopo = tTopoHandle.product();
-   
-  ModMEs CondObj_ME;
-  
-  for(std::vector<uint32_t>::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<uint32_t> & selectedDetIds, const edm::EventSetup& es){
-
-  //Retrieve tracker topology from geometry
-  edm::ESHandle<TrackerTopology> tTopoHandle;
-  es.get<IdealGeometryRecord>().get(tTopoHandle);
-  const TrackerTopology* const tTopo = tTopoHandle.product();
-
-  for(std::vector<uint32_t>::const_iterator detIter_ = selectedDetIds.begin();
-                                            detIter_!= selectedDetIds.end();detIter_++){
-    fillMEsForLayer(/*SummaryMEsMap_,*/ *detIter_,tTopo);
-
-  }
-
+void SiStripQualityDQM::saveSummaryMEs(){
   for (std::map<uint32_t, ModMEs>::iterator iter=SummaryMEsMap_.begin(); iter!=SummaryMEsMap_.end(); iter++){
 
     ModMEs selME;
     selME = iter->second;
 
     if(hPSet_.getParameter<bool>("FillSummaryAtLayerLevel") && fPSet_.getParameter<bool>("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<uint32_t> & selectedDetIds, const edm::EventSetup& es){
-   
-  //Retrieve tracker topology from geometry
-  edm::ESHandle<TrackerTopology> tTopoHandle;
-  es.get<IdealGeometryRecord>().get(tTopoHandle);
-  const TrackerTopology* const tTopo = tTopoHandle.product();
-
-  ModMEs CondObj_ME;
-  
-    
-  for(std::vector<uint32_t>::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<uint32_t> & selectedDetIds, const edm::EventSetup& es){
-   
-   //Retrieve tracker topology from geometry
-   edm::ESHandle<TrackerTopology> tTopoHandle;
-   es.get<IdealGeometryRecord>().get(tTopoHandle);
-   const TrackerTopology* const tTopo = tTopoHandle.product();
-
-   for(std::vector<uint32_t>::const_iterator detIter_ = selectedDetIds.begin();
-       detIter_!= selectedDetIds.end();detIter_++){
-     fillMEsForLayer(/*SummaryMEsMap_,*/ *detIter_,tTopo);
-
-   }
-  
-}    
-// -----
-
 
 //=======================================================================================
 // -----
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'
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 <iosfwd>
 #include <map>
 #include <string>
+#include <utility>
 #include <vector>
 #include "FWCore/Utilities/interface/HideStdSharedPtrFromRoot.h"
 
@@ -118,6 +119,10 @@ namespace edm {
       return transient_.missingDictionaries_;
     }
 
+    std::vector<std::pair<std::string, std::string> > const& aliasToOriginal() const {
+      return transient_.aliasToOriginal_;
+    }
+
     ProductHolderIndex const& getNextIndexValue(BranchType branchType) const;
 
     void initializeTransients() {transient_.reset();}
@@ -144,6 +149,8 @@ namespace edm {
       std::map<BranchID, ProductHolderIndex> branchIDToIndex_;
 
       std::vector<std::string> missingDictionaries_;
+
+      std::vector<std::pair<std::string, std::string> > 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<ProductList::iterator, bool> 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 <map>
+#include <string>
 #include <vector>
 
 // 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<typename T> class WillGetIfMatch;
 
@@ -75,7 +80,14 @@ namespace edm {
     
     void modulesDependentUpon(const std::string& iProcessName,
                               std::vector<const char*>& oModuleLabels) const;
-    
+
+    void modulesWhoseProductsAreConsumed(std::vector<ModuleDescription const*>& modules,
+                                         ProductRegistry const& preg,
+                                         std::map<std::string, ModuleDescription const*> const& labelsToDesc,
+                                         std::string const& processName) const;
+
+    std::vector<ConsumesInfo> consumesInfo() const;
+
   protected:
     friend class ConsumesCollector;
     template<typename T> 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<ExceptionToActionTable const>          act_table_;
     std::shared_ptr<ProcessConfiguration const>       processConfiguration_;
     ProcessContext                                processContext_;
+    PathsAndConsumesOfModules                     pathsAndConsumesOfModules_;
     std::auto_ptr<Schedule>                       schedule_;
     std::auto_ptr<SubProcess>                     subProcess_;
     std::unique_ptr<HistoryAppender>            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 <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace edm {
+
+  class ModuleDescription;
+  class ProductRegistry;
+  class Schedule;
+
+  class PathsAndConsumesOfModules : public PathsAndConsumesOfModulesBase {
+  public:
+
+    virtual ~PathsAndConsumesOfModules();
+
+    void initialize(Schedule const*, std::shared_ptr<ProductRegistry const>);
+
+  private:
+
+    virtual std::vector<std::string> const& doPaths() const override { return paths_; }
+    virtual std::vector<std::string> const& doEndPaths() const override { return endPaths_; }
+
+    virtual std::vector<ModuleDescription const*> const& doAllModules() const override { return allModuleDescriptions_; }
+    virtual ModuleDescription const* doModuleDescription(unsigned int moduleID) const override;
+
+    virtual std::vector<ModuleDescription const*> const& doModulesOnPath(unsigned int pathIndex) const override;
+    virtual std::vector<ModuleDescription const*> const& doModulesOnEndPath(unsigned int endPathIndex) const override;
+    virtual std::vector<ModuleDescription const*> const& doModulesWhoseProductsAreConsumedBy(unsigned int moduleID) const override;
+
+    virtual std::vector<ConsumesInfo> doConsumesInfo(unsigned int moduleID) const override;
+
+    unsigned int moduleIndex(unsigned int moduleID) const;
+
+    // data members
+
+    std::vector<std::string> paths_;
+    std::vector<std::string> endPaths_;
+
+    std::vector<ModuleDescription const*> allModuleDescriptions_;
+
+    std::vector<std::vector<ModuleDescription const*> > modulesOnPaths_;
+    std::vector<std::vector<ModuleDescription const*> > modulesOnEndPaths_;
+
+    // Gives a translation from the module ID to the index into the
+    // following data member
+    std::vector<std::pair<unsigned int, unsigned int> > moduleIDToIndex_;
+
+    std::vector<std::vector<ModuleDescription const*> > modulesWhoseProductsAreConsumedBy_;
+
+    Schedule const* schedule_;
+    std::shared_ptr<ProductRegistry const> 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 <string>
 #include <vector>
 #include <sstream>
+#include <utility>
 
 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<std::string>& 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<std::string>& oLabelsToFill) const;
+
+    ///adds to oLabelsToFill the labels for all end paths in the process
+    void endPaths(std::vector<std::string>& oLabelsToFill) const;
+
     ///adds to oLabelsToFill in execution order the labels of all modules in path iPathLabel
     void modulesInPath(std::string const& iPathLabel,
                        std::vector<std::string>& 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<ModuleDescription const*>& 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<ModuleDescription const*>& descriptions,
+                                     unsigned int hint) const;
+
+    void fillModuleAndConsumesInfo(std::vector<ModuleDescription const*>& allModuleDescriptions,
+                                   std::vector<std::pair<unsigned int, unsigned int> >& moduleIDToIndex,
+                                   std::vector<std::vector<ModuleDescription const*> >& 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 <set>
 
 namespace edm {
+  class ActivityRegistry;
   class BranchDescription;
   class BranchIDListHelper;
   class HistoryAppender;
@@ -229,6 +231,7 @@ namespace edm {
     }
 
     
+    std::shared_ptr<ActivityRegistry>             actReg_;
     ServiceToken                                  serviceToken_;
     std::shared_ptr<ProductRegistry const>        parentPreg_;
     std::shared_ptr<ProductRegistry const>        preg_;
@@ -237,6 +240,7 @@ namespace edm {
     std::unique_ptr<ExceptionToActionTable const> act_table_;
     std::shared_ptr<ProcessConfiguration const>   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 <map>
+#include <string>
 #include <vector>
 
 // 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<const char*>& oModuleLabels) const;
+
+      void modulesWhoseProductsAreConsumed(std::vector<ModuleDescription const*>& modules,
+                                           ProductRegistry const& preg,
+                                           std::map<std::string, ModuleDescription const*> const& labelsToDesc,
+                                           std::string const& processName) const;
+
+      std::vector<ConsumesInfo> 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 <map>
+#include <string>
+#include <vector>
 
 // 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<const char*>& oModuleLabels) const;
 
+      void modulesWhoseProductsAreConsumed(std::vector<ModuleDescription const*>& modules,
+                                           ProductRegistry const& preg,
+                                           std::map<std::string, ModuleDescription const*> const& labelsToDesc,
+                                           std::string const& processName) const;
+
+      std::vector<ConsumesInfo> consumesInfo() const;
 
     protected:
       template<typename F> 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 <algorithm>
 #include <cassert>
-#include <utility>
 #include <cstring>
+#include <set>
+#include <utility>
 
 // 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<const char*>& oModuleLabels
-                                     ) const
-{
+                                     std::vector<const char*>& oModuleLabels) const {
   std::set<const char*, CharStarComp> uniqueModules;
   for(unsigned int index=0, iEnd=m_tokenInfo.size();index <iEnd; ++index) {
     auto const& info = m_tokenInfo.get<kLookupInfo>(index);
@@ -396,6 +398,142 @@ EDConsumerBase::modulesDependentUpon(const std::string& iProcessName,
   oModuleLabels = std::vector<const char*>(uniqueModules.begin(),uniqueModules.end());
 }
 
-//
-// static member functions
-//
+
+namespace {
+  void
+  insertFoundModuleLabel(const char* consumedModuleLabel,
+                         std::vector<ModuleDescription const*>& modules,
+                         std::set<std::string>& alreadyFound,
+                         std::map<std::string, ModuleDescription const*> 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<std::pair<std::string, std::string> > const& aliasToOriginal = preg.aliasToOriginal();
+    std::pair<std::string, std::string> 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<ModuleDescription const*>& modules,
+                                                ProductRegistry const& preg,
+                                                std::map<std::string, ModuleDescription const*> const& labelsToDesc,
+                                                std::string const& processName) const {
+
+  ProductHolderIndexHelper const& iHelper = *preg.productLookup(InEvent);
+
+  std::set<std::string> alreadyFound;
+
+  auto itKind = m_tokenInfo.begin<kKind>();
+  auto itLabels = m_tokenInfo.begin<kLabels>();
+  for(auto itInfo = m_tokenInfo.begin<kLookupInfo>(),itEnd = m_tokenInfo.end<kLookupInfo>();
+      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<ConsumesInfo>
+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<edm::TypeID> alreadySeenTypes;
+
+  std::vector<ConsumesInfo> result;
+  auto itAlways = m_tokenInfo.begin<kAlwaysGets>();
+  auto itKind = m_tokenInfo.begin<kKind>();
+  auto itLabels = m_tokenInfo.begin<kLabels>();
+  for(auto itInfo = m_tokenInfo.begin<kLookupInfo>(),itEnd = m_tokenInfo.end<kLookupInfo>();
+      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 <algorithm>
+
+namespace edm {
+
+  PathsAndConsumesOfModules::~PathsAndConsumesOfModules() {
+  }
+
+  void PathsAndConsumesOfModules::initialize(Schedule const* schedule, std::shared_ptr<ProductRegistry const> 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<std::pair<unsigned int, unsigned int> >::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<ModuleDescription const*> const&
+  PathsAndConsumesOfModules::doModulesOnPath(unsigned int pathIndex) const {
+    return modulesOnPaths_.at(pathIndex);
+  }
+
+  std::vector<ModuleDescription const*> const&
+  PathsAndConsumesOfModules::doModulesOnEndPath(unsigned int endPathIndex) const {
+    return modulesOnEndPaths_.at(endPathIndex);
+  }
+
+  std::vector<ModuleDescription const*> const&
+  PathsAndConsumesOfModules::doModulesWhoseProductsAreConsumedBy(unsigned int moduleID) const {
+    return modulesWhoseProductsAreConsumedBy_.at(moduleIndex(moduleID));
+  }
+
+  std::vector<ConsumesInfo> 
+  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<std::pair<unsigned int, unsigned int> >::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<std::string>& oLabelsToFill) const {
+    streamSchedules_[0]->triggerPaths(oLabelsToFill);
+  }
+
+  void
+  Schedule::endPaths(std::vector<std::string>& oLabelsToFill) const {
+    streamSchedules_[0]->endPaths(oLabelsToFill);
+  }
+
   void
   Schedule::modulesInPath(std::string const& iPathLabel,
                           std::vector<std::string>& oLabelsToFill) const {
     streamSchedules_[0]->modulesInPath(iPathLabel,oLabelsToFill);
   }
 
+  void
+  Schedule::moduleDescriptionsInPath(std::string const& iPathLabel,
+                                     std::vector<ModuleDescription const*>& descriptions,
+                                     unsigned int hint) const {
+    streamSchedules_[0]->moduleDescriptionsInPath(iPathLabel, descriptions, hint);
+  }
+
+  void
+  Schedule::moduleDescriptionsInEndPath(std::string const& iEndPathLabel,
+                                        std::vector<ModuleDescription const*>& descriptions,
+                                        unsigned int hint) const {
+    streamSchedules_[0]->moduleDescriptionsInEndPath(iEndPathLabel, descriptions, hint);
+  }
+
+  void
+  Schedule::fillModuleAndConsumesInfo(std::vector<ModuleDescription const*>& allModuleDescriptions,
+                                      std::vector<std::pair<unsigned int, unsigned int> >& moduleIDToIndex,
+                                      std::vector<std::vector<ModuleDescription const*> >& 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<std::string, ModuleDescription const*> labelToDesc;
+    unsigned int i = 0;
+    for (auto const& worker : allWorkers()) {
+      ModuleDescription const* p = worker->descPtr();
+      allModuleDescriptions.push_back(p);
+      moduleIDToIndex.push_back(std::pair<unsigned int, unsigned int>(p->id(), i));
+      labelToDesc[p->moduleLabel()] = p;
+      ++i;
+    }
+    sort_all(moduleIDToIndex);
+
+    i = 0;
+    for (auto const& worker : allWorkers()) {
+      std::vector<ModuleDescription const*>& 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<std::string>& oLabelsToFill) const {
+    oLabelsToFill = trig_name_list_;
+  }
+
+  void
+  StreamSchedule::endPaths(std::vector<std::string>& oLabelsToFill) const {
+    oLabelsToFill = end_path_name_list_;
+  }
+
   void
   StreamSchedule::modulesInPath(std::string const& iPathLabel,
                           std::vector<std::string>& oLabelsToFill) const {
@@ -567,6 +577,64 @@ namespace edm {
     }
   }
 
+  void
+  StreamSchedule::moduleDescriptionsInPath(std::string const& iPathLabel,
+                                           std::vector<ModuleDescription const*>& 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<std::string>(),
+                                        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<ModuleDescription const*>& 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<std::string>(),
+                                        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<std::string>& 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<std::string>& oLabelsToFill) const;
+
+    ///adds to oLabelsToFill the labels for all end paths in the process
+    void endPaths(std::vector<std::string>& oLabelsToFill) const;
+
     ///adds to oLabelsToFill in execution order the labels of all modules in path iPathLabel
     void modulesInPath(std::string const& iPathLabel,
                        std::vector<std::string>& oLabelsToFill) const;
 
+    void moduleDescriptionsInPath(std::string const& iPathLabel,
+                                  std::vector<ModuleDescription const*>& descriptions,
+                                  unsigned int hint) const;
+
+    void moduleDescriptionsInEndPath(std::string const& iEndPathLabel,
+                                     std::vector<ModuleDescription const*>& 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 <cassert>
@@ -110,6 +111,7 @@ namespace edm {
     std::shared_ptr<ParameterSet> subProcessParameterSet(popSubProcessParameterSet(*processParameterSet_).release());
   
     ScheduleItems items(*parentProductRegistry, *this);
+    actReg_ = items.actReg_;
 
     ParameterSet const& optionsPset(processParameterSet_->getUntrackedParameterSet("options", ParameterSet()));
     IllegalParameters::setThrowAnException(optionsPset.getUntrackedParameter<bool>("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 <map>
 #include <memory>
 #include <sstream>
+#include <string>
 #include <vector>
 
 namespace edm {
@@ -107,6 +110,12 @@ namespace edm {
 
     virtual void modulesDependentUpon(std::vector<const char*>& oModuleLabels) const = 0;
 
+    virtual void modulesWhoseProductsAreConsumed(std::vector<ModuleDescription const*>& modules,
+                                                 ProductRegistry const& preg,
+                                                 std::map<std::string, ModuleDescription const*> const& labelsToDesc) const = 0;
+
+    virtual std::vector<ConsumesInfo> 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 <map>
 #include <memory>
+#include <string>
+#include <vector>
 
 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<ModuleDescription const*>& modules,
+                                                 ProductRegistry const& preg,
+                                                 std::map<std::string, ModuleDescription const*> const& labelsToDesc) const override {
+      module_->modulesWhoseProductsAreConsumed(modules, preg, labelsToDesc, module_->moduleDescription().processName());
+    }
+
+    virtual std::vector<ConsumesInfo> consumesInfo() const override {
+      return module_->consumesInfo();
+    }
+
     virtual void itemsToGet(BranchType branchType, std::vector<ProductHolderIndexAndSkipBit>& 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 <cassert>
 
 // 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<ModuleDescription const*>& modules,
+                                                       ProductRegistry const& preg,
+                                                       std::map<std::string, ModuleDescription const*> const& labelsToDesc,
+                                                       std::string const& processName) const {
+  assert(not m_streamModules.empty());
+  return m_streamModules[0]->modulesWhoseProductsAreConsumed(modules, preg, labelsToDesc, processName);
+}
+
+std::vector<edm::ConsumesInfo>
+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 <cassert>
 
 // 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<T>::modulesWhoseProductsAreConsumed(std::vector<ModuleDescription const*>& modules,
+                                                                   ProductRegistry const& preg,
+                                                                   std::map<std::string, ModuleDescription const*> 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<edm::ConsumesInfo>
+    ProducingModuleAdaptorBase<T>::consumesInfo() const {
+      assert(not m_streamModules.empty());
+      return m_streamModules[0]->consumesInfo();
+    }
+
     template< typename T>
     void
     ProducingModuleAdaptorBase<T>::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<edm::BranchDescription> 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<std::pair<std::string, std::string> > 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/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<unsigned int> run;
    mutable std::atomic<unsigned int> lumi;
 };
-} //end anonymous namespace
-
-
+} //end cache namespace
 
+  using Cache = cache::Cache;
 
   class GlobalIntAnalyzer : public edm::stream::EDAnalyzer<edm::GlobalCache<Cache>> {
   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<unsigned int> value;
@@ -36,9 +37,9 @@ struct Cache {
    mutable std::atomic<unsigned int> lumi;
 };
 
-} //end anonymous namespace
-
+} //end cache namespace
 
+  using Cache = cache::Cache;
 
   class GlobalIntFilter : public edm::stream::EDFilter<edm::GlobalCache<Cache>> {
   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<edm::GlobalCache<Cache>> {
   public:
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<int>("valueMustMatch")),
+      moduleLabel_(iPSet.getUntrackedParameter<std::string>("moduleLabel"), "") {
+      mayConsume<IntProduct>(moduleLabel_);
+    }
+
+    void analyze(edm::Event const& iEvent, edm::EventSetup const&) {
+      edm::Handle<IntProduct> 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 <cassert>
 #include <string>
@@ -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<int>("ivalue")) {
+      produces<IntProduct>();
+      // not used, only exists to test PathAndConsumesOfModules
+      consumes<edm::TriggerResults>(edm::InputTag("TriggerResults"));
+      consumesMany<edm::TriggerResults>();
+    }
+    explicit ConsumingIntProducer(int i) : value_(i) {
+      produces<IntProduct>();
+      // not used, only exists to test PathAndConsumesOfModules
+      consumes<edm::TriggerResults>(edm::InputTag("TriggerResults"));
+      consumesMany<edm::TriggerResults>();
+    }
+    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<IntProduct> 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<int> '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/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")
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<void(PathsAndConsumesOfModulesBase const&, ProcessContext const&)> 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<void()> 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 <string>
+
+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 <string>
+#include <vector>
+
+namespace edm {
+
+  class ModuleDescription;
+
+  class PathsAndConsumesOfModulesBase {
+  public:
+
+    virtual ~PathsAndConsumesOfModulesBase();
+
+    std::vector<std::string> const& paths() const { return doPaths(); }
+    std::vector<std::string> const& endPaths() const { return doEndPaths(); }
+
+    std::vector<ModuleDescription const*> const& allModules() const {
+      return doAllModules();
+    }
+
+    ModuleDescription const* moduleDescription(unsigned int moduleID) const {
+      return doModuleDescription(moduleID);
+    }
+
+    std::vector<ModuleDescription const*> const& modulesOnPath(unsigned int pathIndex) const {
+      return doModulesOnPath(pathIndex);
+    }
+
+    std::vector<ModuleDescription const*> 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<ModuleDescription const*> 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> consumesInfo(unsigned int moduleID) const {
+      return doConsumesInfo(moduleID);
+    }
+
+  private:
+
+    virtual std::vector<std::string> const& doPaths() const = 0;
+    virtual std::vector<std::string> const& doEndPaths() const = 0;
+    virtual std::vector<ModuleDescription const*> const& doAllModules() const = 0;
+    virtual ModuleDescription const* doModuleDescription(unsigned int moduleID) const = 0;
+    virtual std::vector<ModuleDescription const*> const& doModulesOnPath(unsigned int pathIndex) const = 0;
+    virtual std::vector<ModuleDescription const*> const& doModulesOnEndPath(unsigned int endPathIndex) const = 0;
+    virtual std::vector<ModuleDescription const*> const& doModulesWhoseProductsAreConsumedBy(unsigned int moduleID) const = 0;
+    virtual std::vector<ConsumesInfo> 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 <iostream>
+#include <vector>
 
 using namespace edm::service;
 
@@ -60,6 +67,7 @@ Tracer::Tracer(ParameterSet const& iPS, ActivityRegistry&iRegistry) :
   indention_(iPS.getUntrackedParameter<std::string>("indention")),
   dumpContextForLabels_(),
   dumpNonModuleContext_(iPS.getUntrackedParameter<bool>("dumpNonModuleContext")),
+  dumpPathsAndConsumes_(iPS.getUntrackedParameter<bool>("dumpPathsAndConsumes")),
   printTimestamps_(iPS.getUntrackedParameter<bool>("printTimestamps"))
 {
   for (std::string & label: iPS.getUntrackedParameter<std::vector<std::string>>("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<std::string>("indention", "++")->setComment("Prefix characters for output. The characters are repeated to form the indentation.");
   desc.addUntracked<std::vector<std::string>>("dumpContextForLabels", std::vector<std::string>{})->setComment("Prints context information to cout for the module transitions associated with these modules' labels");
   desc.addUntracked<bool>("dumpNonModuleContext", false)->setComment("Prints context information to cout for the transitions not associated with any module label");
+  desc.addUntracked<bool>("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<bool>("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<std::string> const& paths = pathsAndConsumes.paths();
+    for(auto const& path : paths) {
+      out << "  " << path << "\n";
+    }
+    out << "end paths:\n";
+    std::vector<std::string> const& endpaths = pathsAndConsumes.endPaths();
+    for(auto const& endpath : endpaths) {
+      out << "  " << endpath << "\n";
+    }
+    for(unsigned int j = 0; j < paths.size(); ++j) {
+      std::vector<ModuleDescription const*> 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<ModuleDescription const*> 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<ModuleDescription const*> 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<ModuleDescription const*> 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> 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<std::string> dumpContextForLabels_;
          bool dumpNonModuleContext_;
+         bool dumpPathsAndConsumes_;
          bool printTimestamps_;
       };
    }
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 ),
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 <class T>
-  AlphaT(std::vector<T const *> const & p4, bool use_et = true);
+  AlphaT(std::vector<T const *> const & p4, bool setDHtZero = false , bool use_et = true);
 
   template <class T>
-  AlphaT(std::vector<T> const & p4, bool use_et = true);
+  AlphaT(std::vector<T> const & p4, bool setDHtZero = false, bool use_et = true);
 
 private:
   std::vector<double> et_;
@@ -25,23 +25,26 @@ class AlphaT {
 
 private:
   double value_(std::vector<bool> * jet_sign) const;
+  bool setDHtZero_;
 };
 
 
 // -----------------------------------------------------------------------------
 template<class T>
-AlphaT::AlphaT(std::vector<T const *> const & p4, bool use_et /* = true */) {
+AlphaT::AlphaT(std::vector<T const *> 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<class T>
-AlphaT::AlphaT(std::vector<T> const & p4, bool use_et /* = true */) {
+AlphaT::AlphaT(std::vector<T> 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<bool> * 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<T>::HLTAlphaTFilter(const edm::ParameterSet& iConfig) : HLTFilte
   minAlphaT_           = iConfig.getParameter<double> ("minAlphaT");
   triggerType_         = iConfig.getParameter<int>("triggerType");
   dynamicAlphaT_       = iConfig.getParameter<bool>("dynamicAlphaT");
+  setDHtZero_          = iConfig.getParameter<bool>("setDHtZero");
   // sanity checks
 
   if (       (minPtJet_.size()    !=  etaJet_.size())
@@ -86,6 +87,7 @@ void HLTAlphaTFilter<T>::fillDescriptions(edm::ConfigurationDescriptions& descri
   desc.add<double>("minAlphaT",0.0);
   desc.add<int>("triggerType",trigger::TriggerJet);
   desc.add<bool>("dynamicAlphaT",true); //Set to reproduce old behaviour
+  desc.add<bool>("setDHtZero",false); //Set to reproduce old behaviour
   descriptions.add(std::string("hlt")+std::string(typeid(HLTAlphaTFilter<T>).name()),desc);
 }
 
@@ -164,7 +166,7 @@ bool HLTAlphaTFilter<T>::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<T>::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_){
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
 
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_*_*',
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<bool>("useLegacyError") ? conf.getParameter<bool>("useLegacyError") : true)
+  , maxChgOneMIP(conf.existsAs<float>("maxChgOneMIP") ? conf.getParameter<double>("maxChgOneMIP") : -6000.)
   {
     mLC_P[0] = conf.existsAs<double>("mLC_P0") ? conf.getParameter<double>("mLC_P0") : -.326;
     mLC_P[1] = conf.existsAs<double>("mLC_P1") ? conf.getParameter<double>("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());
 
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            ) ,