cmtool Namespace Reference

Classes
class	CBAlgoAngleAlign
class	CBAlgoAngleCompat
class	CBAlgoAngleIncompat
class	CBAlgoAngleSeparate
class	CBAlgoArray
class	CBAlgoCenterOfMass
class	CBAlgoCenterOfMassSmall
class	CBAlgoFake
class	CBAlgoMergeAll
class	CBAlgoMergeTinyWithBig
class	CBAlgoOutOfConeSeparate
class	CBAlgoPolyContain
class	CBAlgoPolyHitOverlap
class	CBAlgoPolyOverlap
class	CBAlgoPolyShortestDist
class	CBAlgoProhibitAllTracks
class	CBAlgoProhibitBigClusters
class	CBAlgoShortestDist
class	CBAlgoShortestDistNonEndpoint
class	CBAlgoShortestDistSmallCluster
class	CBAlgoStartInCone
class	CBAlgoStartInPoly
class	CBAlgoStartNearEnd
class	CBAlgoStartTrack
class	CBAlgoTrackSeparate
class	CBoolAlgoBase
class	CFAlgo3DAngle
class	CFAlgoArray
class	CFAlgoChargeDistrib
class	CFAlgoQRatio
class	CFAlgoShowerCompat
class	CFAlgoStartPointCompat
class	CFAlgoStartPointMatch
class	CFAlgoStartTimeCompat
class	CFAlgoTimeOverlap
class	CFAlgoTimeProf
class	CFAlgoVolumeOverlap
class	CFAlgoWireOverlap
class	CFAlgoZOverlap
class	CFloatAlgoBase
class	CMAlgoBase
class	CMatchBookKeeper
class	CMatchManager
class	CMergeBookKeeper
class	CMergeHelper
class	CMergeManager
class	CMManagerBase
class	CMTException
class	CPAlgoArray
class	CPAlgoIgnoreTracks
class	CPAlgoNHits
class	CPAlgoPolyArea
class	CPAlgoQSum
class	CPriorityAlgoBase

Functions
unsigned int	CMFactorial (unsigned int n)
std::vector< std::vector< size_t > >	SimpleCombination (size_t n, size_t r)
std::vector< std::vector< size_t > >	ClusterCombinations (const std::vector< size_t > &seed)
std::vector< std::vector< std::pair< size_t, size_t > > >	PlaneClusterCombinations (const std::vector< size_t > &seed)

Function Documentation

std::vector<std::vector<size_t> > cmtool::ClusterCombinations

(

const std::vector< size_t > &

seed

)

Definition at line 81 of file CMatchManager.cxx.

References fhicl::detail::atom::value().

Referenced by PlaneClusterCombinations().

  {
  
    std::vector<size_t> ctr(seed.size(),0);
    
    std::vector<std::vector<size_t> > res;
    
    while(1) {
      
      res.push_back(std::vector<size_t>(seed.size(),0));
      for(size_t index=0; index<ctr.size(); ++index)
        
        (*res.rbegin())[index] = ctr.at(index);
    
      for(size_t i=0; i<ctr.size(); ++i) {
        
        size_t index = (size_t)(ctr.size()-i-1);
        
        ctr.at(index) +=1;
        
        if(ctr.at(index) < seed.at(index))
          
          break;
        
        ctr.at(index) = 0;

      }

      bool abort = true;
      for(auto const& value : ctr)
        
        abort = abort && (!(value));
      
    if(abort) break;
    }
    return res;
  }

unsigned int cmtool::CMFactorial

(

unsigned int

n

)

Definition at line 57 of file CMatchManager.cxx.

References n.

Referenced by SimpleCombination().

  {return (n == 1 || n == 0) ? 1 : CMFactorial(n - 1) * n;}

std::vector<std::vector<std::pair<size_t,size_t> > > cmtool::PlaneClusterCombinations

(

const std::vector< size_t > &

seed

)

Definition at line 119 of file CMatchManager.cxx.

References ClusterCombinations(), SimpleCombination(), and lar::dump::vector().

Referenced by cmtool::CMatchManager::IterationProcess().

  {
    // Result container
    std::vector<std::vector<std::pair<size_t,size_t> > > result;

    // Loop over N-planes: start from max number of planes => down to 2 planes
    for(size_t i=0; i<seed.size(); ++i) {
      
      // If finish making clusters down to 2 palnes, break
      if(seed.size() < 2+i) break;

      // Compute possible N-plane combinations
      auto const& plane_comb_v = SimpleCombination(seed.size(),seed.size()-i);

      // Loop over possible N-plane combinations
      for(auto const& plane_comb : plane_comb_v){

        // Make a seed for cluster combinations
        std::vector<size_t> cluster_seed_v;
        cluster_seed_v.reserve(plane_comb.size());
        for(auto const& index : plane_comb) cluster_seed_v.push_back(seed[index]);
        
        // Compute cluster combinations
        for(auto const& cluster_comb : ClusterCombinations(cluster_seed_v)) {
          
          // Store result
          result.push_back(std::vector<std::pair<size_t,size_t> >());
          for(size_t i=0; i<cluster_comb.size(); ++i)
            
            (*result.rbegin()).push_back(std::make_pair(plane_comb.at(i),cluster_comb.at(i)));
        }
      }
    }
    return result;
      
  }

std::vector<std::vector<size_t> > cmtool::SimpleCombination	(	size_t	n,
		size_t	r
	)

Definition at line 60 of file CMatchManager.cxx.

References CMFactorial(), trkf::fill(), n, and tmp.

Referenced by PlaneClusterCombinations().

                                                                      {
    
    if(!n || !r) exit(1);
    if(r > n) exit(1);
    
    std::vector<bool> v(n,false);
    std::fill(v.begin()+n-r,v.end(),true);
    std::vector<std::vector<size_t> > res;
    res.reserve(CMFactorial(n)/CMFactorial(n-r)/CMFactorial(r));
    
    do {
      std::vector<size_t> tmp;
      tmp.reserve(r);
      
      for(size_t i=0; i<n; ++i) { if(v[i]) tmp.push_back(i); }
      res.push_back(tmp);
    } while (std::next_permutation(v.begin(),v.end()));
    
    return res;
  }