MatchableEvent.cxx

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////
/// \file    MatchableEvent.cxx
/// \brief   Attach some information used in matching to an EventSummary
/// \author  Christopher Backhouse - bckhouse@caltech.edu
////////////////////////////////////////////////////////////////////////

#include "LEM/func/MatchableEvent.h"

#include "LEM/func/DistanceMap.h"

#include <algorithm>

namespace lem
{
  //......................................................................
  MatchableEvent::MatchableEvent(const EventSummary& evt)
    : EventSummary(evt), weight(1)
  {
    const DistanceMap& dm = DistanceMap::Instance();

    selfEnergy = 0;

    for(unsigned int i = 0; i < nhits; ++i){
      const LiteHit& hi = hits[i];

      selfEnergy += .5*hi.pecorr*hi.pecorr*dm.InvDist(hi, hi);

      for(unsigned int j = i+1; j < nhits; ++j){
        const LiteHit& hj = hits[j];

        // Only if they're in the same view
        if(hi.Plane()%2 == hj.Plane()%2)
          selfEnergy += hi.pecorr*hj.pecorr*dm.InvDist(hi, hj);
      } // end for j
    } // end for i
  }

  //......................................................................
  MatchableEvent MatchableEvent::Downsampled(int factor) const
  {
    std::vector<LiteHit> tmp(hits, hits+nhits);

    for(unsigned int i = 0; i < nhits; ++i){
      int p = tmp[i].Plane();
      int c = tmp[i].Cell();
      p = ((p>>(factor+1))<<1)+p%2;
      c = c>>factor;
      // This encoding screws up Plane() and Cell(), but it collapses all the
      // possible hits into a small range of indices, so should be better for
      // looking them up in the Potential map?
      tmp[i].cellIdx = (p<<(8-factor))+c;
    } // end for i

    // Put in order of cellIdx
    std::sort(tmp.begin(), tmp.end());

    // Merge identical cellIdxs
    std::vector<LiteHit> tmp2;
    for(unsigned int i = 0; i < nhits; ++i){
      if(tmp2.empty() || tmp2.back().cellIdx != tmp[i].cellIdx)
        tmp2.push_back(tmp[i]);
      else
        tmp2.back().pecorr += tmp[i].pecorr;
    } // end for i

    MatchableEvent ret = *this;
    ret.nhits = tmp2.size();
    delete[] ret.hits;
    ret.hits = new LiteHit[ret.nhits];
    for(int i = 0; i < ret.nhits; ++i) ret.hits[i] = tmp2[i];

    return ret;
  }

  //......................................................................
  MatchableEvent MatchableEvent::Flipped(bool flipEven, bool flipOdd) const
  {
    MatchableEvent ret = *this;

    for(int i = 0; i < ret.nhits; ++i){
      LiteHit& h = ret.hits[i];
      if((h.Plane()%2 == 0 && flipEven) ||
         (h.Plane()%2 == 1 && flipOdd)){
        h.SetCell(2*kVertexCell-h.Cell());
      }
    }

    // TODO: can we try and use move to not have to call another copy
    // constructor here?
    return ret;
  }

} // namespace