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	CBAlgoStartNearEnd
class	CBAlgoStartTrack
class	CBoolAlgoBase
class	CFAlgoQRatio
class	CFAlgoShowerCompat
class	CFAlgoTimeOverlap
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 107 of file CMatchManager.cxx.

  {

    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 76 of file CMatchManager.cxx.

  {
    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 143 of file CMatchManager.cxx.

  {
    // 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 82 of file CMatchManager.cxx.

  {

    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;
  }