Merge branch 'CMSSW_7_0_X' of https://github.com/cms-sw/cmssw into MuonDQM-GED-code
Merge branch 'MuonDQM-GED-code' into CMSSW_7_0_X to keep track of the previous developments
Thread safe changes
add calibrated energy to CaloCluster
log interpolation errors only once per channel, thread safe
Move .h to interface/ folder and multirun support
Merge branch 'CMSSW_7_0_X' of https://github.com/cms-sw/cmssw into CMSSW_7_0_X
merging MuonDQM-MultiRun and CMSSW_7_0_X
Resolve conflicts on multi-run support
Merge branch 'MuonDQM-MultiRun' of github.com:folguera/cmssw into CMSSW_7_0_X
new test on raw relval in 700
add consumes interface
add consumes interface
add consumes interface
add consumes interface
Reorganize KDTree data structure for improved CPU performance

Half-way SoA solution, use separate vectors to store Node structs and
the data, and an index to refer to the current node. By construction,
the index of the left child is always current+1, therefore we don't
have to store it.

We can exploit the fact that the dimension where the split of leaf
nodes is done alternates from tree depth N to N+1. For each depth it
is enough to store only the median (1 float) of the contained leaf
nodes of the current dimension instead of the bounding box of the the
leaves (4 floats). The search can be accommodated to this change by
giving the search box as 4 floats, and alternating the min/max of the
current/other dimension in each recSearch() call. Although
addSubTree() can no longer be utilized, the smaller data structure and
the reduction of comparisons (=branches) in recSearch() lead to
noticeable performance improvement.

The Node.right field, which stores the index of the right child, can
be abused to contain the information of whether the current node is
leaf or not (smallest valid value of right child index is 2). The
Node.right field can be further exploited to store the active
dimension of the current tree depth (0 or 1).
Use bit-wise & instead of logical && in the innermost point-in-rectangle check
Reorganize KDTree data structure even further, change search interface

Employ Structure-of-Arrays. This implies an interface change,
i.e. vector of only DATA can be returned (instead of
KDTreeNodeInfo<DATA>). Returning only vector<DATA> would be faster
also without the SoA data structure modification. In all uses of
KDTree I found (including the non-templated one in
RecoParticleFlow/PFProducer), the coordinates of the found items are
not used.

With SoA the data structure can be compacted a bit by storing the
coordinate of the current dimension for leaf nodes in the same array
where the median is stored for intermediate nodes.
Use std::nth_element to partially sort the input vector

std::nth_element appears to be slightly faster than the hand-written
Wirth algorithm.
Remove partly the recursion in recSearch()

The recursion in cases only one child node will be accessed can be
easily transformed to iteration, which is somewhat faster. When both
children need to be accessed, it is probably better to keep the
recursion, as some kind of stack would be needed anyway.