WeightSharedHitsAlg.cxx

Go to the documentation of this file.

#include "messagefacility/MessageLogger/MessageLogger.h"
#include "canvas/Persistency/Common/Ptr.h"
#include "canvas/Persistency/Common/PtrVector.h"

#include "FuzzyKVertex/WeightSharedHitsAlg.h"

#include "Calibrator/Calibrator.h"
#include "GeometryObjects/CellGeo.h"
#include "GeometryObjects/Geo.h"
#include "Utilities/func/MathUtil.h"

#include "TGeoManager.h"
#include "TGeoNode.h"
#include "TMatrixD.h"

#include <string.h>

namespace fuzz{

  WeightSharedHitsAlg::WeightSharedHitsAlg(const WeightSharedHitsParams& /*params*/)
  {
  }

  WeightSharedHitsAlg::~WeightSharedHitsAlg()
  {

  }


  void WeightSharedHitsAlg::GetWeights( std::vector<rb::WeightedProng>& prongs )
  {
    const int nPro = prongs.size();

    // This map holds info about the cells that are shared by 
    // multiple prongs. The key is the channel, and the value 
    // is another map. In the inner map, the key is the index 
    // of the prong and the value is the index of the cell in
    // that prong. Therefore, proIdx[chan][prgIdx] = [cellIdx]
    std::map< uint32_t , std::map< int,  int > > proIdx ;

    for( int iPro = 0; iPro < nPro; ++iPro){

      // loop over cells in ith prong
      for( unsigned int iCell = 0; iCell < prongs[iPro].NCell(); ++iCell ){
        const art::Ptr<rb::CellHit>& ihit = prongs[iPro].Cell(iCell);

        // In the following loop, we will find which other
        // prongs the ihits[iCell] belongs to.

        for( int jPro = iPro+1; jPro < nPro; ++jPro){

          // loop over cells in jth prong
          for( unsigned int jCell = 0 ; jCell < prongs[jPro].NCell(); ++jCell){
            const art::Ptr<rb::CellHit>& jhit = prongs[jPro].Cell(jCell);

            if( *jhit == *ihit){
              proIdx[ ihit->Channel() ][ iPro ] = iCell;
              proIdx[ ihit->Channel() ][ jPro ] = jCell;
            }

          }// end loop over jprong cells
        }// end j loop over prongs 
      }// end loop over iprong cells
    }// end i loop over prongs
    
    // We now have all the info we need to set weights:
    // 1/N weights
    // loop over channels
    for( auto & cmap : proIdx){
      // for each channel, get number of prongs that share that channel
      int nsharedprongs = cmap.second.size();
      // loop over the shared prongs for that channel
      for( auto & pmap : cmap.second){
        // doing the really naive thing which is weighting by 1/Nprongs
        prongs[pmap.first].SetWeight(pmap.second, 1./nsharedprongs);
      }
    }// end loop over proIdx
    
    return;
    
  }// end of GetWeights

}//end fuzz namespace