HardwareSortingMethods.cc File Reference

#include <iostream>
#include "L1Trigger/L1TCalorimeter/interface/HardwareSortingMethods.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

Go to the source code of this file.

Namespaces
	l1t
	delete x;

Functions
std::vector< l1t::L1Candidate >	array_from_row_sorted_matrix (std::vector< std::vector< l1t::L1Candidate > > const &input_matrix, unsigned int n_keep)
std::vector< std::vector< l1t::L1Candidate > >	extract_sub_jet_energy_position_matrix (std::vector< std::vector< l1t::L1Candidate > > const &input_matrix, unsigned int row_i, unsigned int row_f, unsigned int col_i, unsigned int col_f)
unsigned int	l1t::pack15bits (int pt, int eta, int phi)
unsigned int	l1t::pack16bits (int pt, int eta, int phi)
unsigned int	l1t::pack16bitsEgammaSpecial (int pt, int eta, int phi)
std::vector< std::vector< l1t::L1Candidate > >	presort (std::vector< std::vector< l1t::L1Candidate > > const &energies, int rows, int cols)
std::vector< std::vector< l1t::L1Candidate > >	presort_egamma (std::vector< l1t::L1Candidate > const &input_egamma, int rows, int cols)
void	print2DVector (std::vector< std::vector< l1t::L1Candidate > > const &myVector)
std::vector< l1t::L1Candidate >	sort_array (std::vector< l1t::L1Candidate > const &inputArray)
std::vector< std::vector< l1t::L1Candidate > >	sort_by_row_in_groups (std::vector< std::vector< l1t::L1Candidate > > const &input_matrix, int group_size)
std::vector< std::vector< l1t::L1Candidate > >	sort_matrix_rows (std::vector< std::vector< l1t::L1Candidate > > const &input_matrix)
void	l1t::SortEGammas (std::vector< l1t::EGamma > *input, std::vector< l1t::EGamma > *output)
void	l1t::SortJets (std::vector< l1t::Jet > *input, std::vector< l1t::Jet > *output)
void	l1t::SortTaus (std::vector< l1t::Tau > *input, std::vector< l1t::Tau > *output)
std::vector< std::vector< l1t::L1Candidate > >	super_sort_matrix_rows (std::vector< std::vector< l1t::L1Candidate > > const &input_matrix, unsigned int group_size, unsigned int n_keep)

Function Documentation

array_from_row_sorted_matrix()

std::vector<l1t::L1Candidate> array_from_row_sorted_matrix	(	std::vector< std::vector< l1t::L1Candidate > > const &	input_matrix,
		unsigned int	n_keep
	)

Definition at line 176 of file HardwareSortingMethods.cc.

References mps_fire::i, dqmiolumiharvest::j, dqmdumpme::k, l1t::L1Candidate::setHwEta(), l1t::L1Candidate::setHwPhi(), l1t::L1Candidate::setHwPt(), l1t::L1Candidate::setHwQual(), and findQualityFiles::size.

Referenced by super_sort_matrix_rows().

                                                                                    {
  std::vector<l1t::L1Candidate> output_array(n_keep * (n_keep + 1) / 2);
  unsigned int max_row = n_keep - 1;
  unsigned int max_col = n_keep - 1;

  //compute size
  if (input_matrix.size() < n_keep)
    max_row = input_matrix.size() - 1;
  if (input_matrix[0].size() < n_keep)
    max_col = input_matrix[0].size() - 1;

  unsigned int array_position = 0;
  for (unsigned int i = 0; i <= max_row; i++) {
    for (unsigned int j = 0; j <= max_col - i; j++) {
      //cout << input_matrix[i][j].hwPt() << endl;
      output_array[array_position] = input_matrix[i][j];
      array_position++;
    }  //j
  }    //i

  //fill rest with zeros
  l1t::L1Candidate dummyJet;
  dummyJet.setHwPt(0);
  dummyJet.setHwPhi(99);
  dummyJet.setHwEta(99);
  dummyJet.setHwQual(0x10);
  for (unsigned int k = array_position; k < output_array.size(); k++) {
    output_array[k] = dummyJet;
  }

  //printVector(output_array);
  return output_array;
}

extract_sub_jet_energy_position_matrix()

std::vector<std::vector<l1t::L1Candidate> > extract_sub_jet_energy_position_matrix	(	std::vector< std::vector< l1t::L1Candidate > > const &	input_matrix,
		unsigned int	row_i,
		unsigned int	row_f,
		unsigned int	col_i,
		unsigned int	col_f
	)

Definition at line 107 of file HardwareSortingMethods.cc.

References mps_fire::i, dqmiolumiharvest::j, l1t::L1Candidate::setHwEta(), l1t::L1Candidate::setHwPhi(), l1t::L1Candidate::setHwPt(), and l1t::L1Candidate::setHwQual().

Referenced by sort_by_row_in_groups(), and super_sort_matrix_rows().

                        {
  std::vector<std::vector<l1t::L1Candidate> > output_matrix(row_f - row_i + 1,
                                                            std::vector<l1t::L1Candidate>(col_f - col_i + 1));
  l1t::L1Candidate dummyJet;
  dummyJet.setHwPt(0);
  dummyJet.setHwPhi(99);
  dummyJet.setHwEta(99);
  dummyJet.setHwQual(0x10);
  for (unsigned int i = 0; i < row_f - row_i + 1; i++) {
    for (unsigned int j = 0; j < col_f - col_i + 1; j++) {
      if (row_i + i > input_matrix.size() - 1)
        output_matrix[i][j] = dummyJet;
      else
        output_matrix[i][j] = input_matrix[row_i + i][col_i + j];
    }  //j
  }    //i
  return output_matrix;
}

presort()

std::vector<std::vector<l1t::L1Candidate> > presort	(	std::vector< std::vector< l1t::L1Candidate > > const &	energies,
		int	rows,
		int	cols
	)

Definition at line 62 of file HardwareSortingMethods.cc.

References HltBtagPostValidation_cff::c, cuy::col, print2DVector(), alignCSCRings::r, mysort::rows, l1t::L1Candidate::setHwEta(), l1t::L1Candidate::setHwPhi(), l1t::L1Candidate::setHwPt(), l1t::L1Candidate::setHwQual(), sort_array(), and verbose.

Referenced by l1t::SortJets(), and l1t::SortTaus().

                                                              {
  int row_block_length = energies.size() / cols;
  if (energies.size() % cols != 0)
    row_block_length++;

  l1t::L1Candidate dummyJet;
  dummyJet.setHwPt(0);
  dummyJet.setHwPhi(99);
  dummyJet.setHwEta(99);
  dummyJet.setHwQual(0x10);
  std::vector<std::vector<l1t::L1Candidate> > sorted_energies(rows, std::vector<l1t::L1Candidate>(cols, dummyJet));
  if (verbose)
    print2DVector(sorted_energies);

  unsigned int row = 0, col = 0;
  std::vector<l1t::L1Candidate> energy_feeder(cols, dummyJet);
  std::vector<l1t::L1Candidate> energy_result(cols, dummyJet);
  for (int r = 0; r < rows; r++) {
    for (int c = 0; c < cols; c++) {
      row = (r % row_block_length) * cols + c;  //row goes up to 19 and we pad with zeros

      if (row < energies.size()) {
        energy_feeder[c] = energies[row][col];
      } else {
        energy_feeder[c] = dummyJet;
      }

    }  //c

    energy_result = sort_array(energy_feeder);  //sort!

    sorted_energies[r] = energy_result;

    if (r % row_block_length == row_block_length - 1)
      col++;

  }  //r
  if (verbose)
    print2DVector(sorted_energies);

  return sorted_energies;
}

presort_egamma()

std::vector<std::vector<l1t::L1Candidate> > presort_egamma	(	std::vector< l1t::L1Candidate > const &	input_egamma,
		int	rows,
		int	cols
	)

Definition at line 243 of file HardwareSortingMethods.cc.

References HltBtagPostValidation_cff::c, print2DVector(), alignCSCRings::r, mysort::rows, l1t::L1Candidate::setHwEta(), l1t::L1Candidate::setHwPhi(), l1t::L1Candidate::setHwPt(), l1t::L1Candidate::setHwQual(), sort_array(), and verbose.

Referenced by l1t::SortEGammas().

                                                                     {
  int row_block_length = input_egamma.size() / cols;
  if (input_egamma.size() % cols != 0)
    row_block_length++;

  //Initialize output
  l1t::L1Candidate dummyJet;
  dummyJet.setHwPt(0);
  dummyJet.setHwPhi(99);
  dummyJet.setHwEta(99);
  dummyJet.setHwQual(0x10);
  std::vector<std::vector<l1t::L1Candidate> > sorted_energies(rows, std::vector<l1t::L1Candidate>(cols, dummyJet));
  if (verbose)
    print2DVector(sorted_energies);

  unsigned int row = 0;
  std::vector<l1t::L1Candidate> energy_feeder(cols, dummyJet);
  std::vector<l1t::L1Candidate> energy_result(cols, dummyJet);
  for (int r = 0; r < rows; r++) {
    for (int c = 0; c < cols; c++) {
      row = (r % row_block_length) * cols + c;  //row goes up to 19 and we pad with zeros

      if (row < input_egamma.size()) {
        energy_feeder[c] = input_egamma[row];
      } else {
        energy_feeder[c] = dummyJet;
      }

    }  //c

    energy_result = sort_array(energy_feeder);  //sort!

    sorted_energies[r] = energy_result;
  }  //r
  if (verbose)
    print2DVector(sorted_energies);

  return sorted_energies;
}

print2DVector()

void print2DVector

(

std::vector< std::vector< l1t::L1Candidate > > const &

myVector

)

Definition at line 34 of file HardwareSortingMethods.cc.

References HltBtagPostValidation_cff::c, gather_cfg::cout, hgcalPlots::ncols, and alignCSCRings::r.

Referenced by presort(), presort_egamma(), sort_by_row_in_groups(), and super_sort_matrix_rows().

                                                                          {
  int nrows = myVector.size();
  int ncols = myVector[0].size();
  std::cout << std::endl;
  std::cout << "rows: " << nrows << std::endl;
  std::cout << "cols: " << ncols << std::endl;

  for (int r = 0; r < nrows; r++) {
    for (int c = 0; c < ncols; c++) {
      std::cout << std::setw(5) << myVector[r][c].hwPt() << ' ';
    }
    std::cout << std::endl;
  }
}

sort_array()

std::vector<l1t::L1Candidate> sort_array

(

std::vector< l1t::L1Candidate > const &

inputArray

)

Definition at line 49 of file HardwareSortingMethods.cc.

References l1trig_cff::hwPt, mps_fire::i, and dqmiolumiharvest::j.

Referenced by presort(), presort_egamma(), and super_sort_matrix_rows().

                                                                                  {
  std::vector<l1t::L1Candidate> outputArray(inputArray.size());
  for (unsigned int i = 0; i < inputArray.size(); i++) {
    int rank = 0;
    for (unsigned int j = 0; j < inputArray.size(); j++) {
      if ((inputArray[i].hwPt() > inputArray[j].hwPt()) || ((inputArray[i].hwPt() == inputArray[j].hwPt()) && i < j))
        rank++;
    }  //j
    outputArray[outputArray.size() - 1 - rank] = inputArray[i];
  }  //i
  return outputArray;
}

sort_by_row_in_groups()

std::vector<std::vector<l1t::L1Candidate> > sort_by_row_in_groups	(	std::vector< std::vector< l1t::L1Candidate > > const &	input_matrix,
		int	group_size
	)

Definition at line 149 of file HardwareSortingMethods.cc.

References extract_sub_jet_energy_position_matrix(), g, mps_fire::i, print2DVector(), findQualityFiles::size, sort_matrix_rows(), and verbose.

Referenced by l1t::SortEGammas(), l1t::SortJets(), and l1t::SortTaus().

                                                                               {
  int n_groups =
      input_matrix.size() / group_size +
      (1 - input_matrix.size() / group_size * group_size / input_matrix.size());  //constants must make this an integer
  //std::vector<std::vector<l1t::L1Candidate> > output_matrix(input_matrix.size()+(input_matrix.size() % group_size), std::vector<l1t::L1Candidate> (input_matrix[0].size()));
  std::vector<std::vector<l1t::L1Candidate> > output_matrix(
      input_matrix.size() +
          (group_size * (1 - ((input_matrix.size() / group_size) * group_size) / input_matrix.size())) -
          (input_matrix.size() % group_size),
      std::vector<l1t::L1Candidate>(input_matrix[0].size()));

  for (int g = 0; g < n_groups; g++) {
    std::vector<std::vector<l1t::L1Candidate> > small_output_matrix = extract_sub_jet_energy_position_matrix(
        input_matrix, g * group_size, (g + 1) * group_size - 1, 0, input_matrix[0].size() - 1);
    small_output_matrix = sort_matrix_rows(small_output_matrix);

    for (unsigned int i = 0; i < small_output_matrix.size(); i++) {
      output_matrix[g * group_size + i] = small_output_matrix[i];
    }
  }

  if (verbose)
    print2DVector(output_matrix);
  return output_matrix;
}

sort_matrix_rows()

std::vector<std::vector<l1t::L1Candidate> > sort_matrix_rows

(

std::vector< std::vector< l1t::L1Candidate > > const &

input_matrix

)

Definition at line 131 of file HardwareSortingMethods.cc.

References l1trig_cff::hwPt, mps_fire::i, and dqmiolumiharvest::j.

Referenced by sort_by_row_in_groups().

                                                               {
  std::vector<std::vector<l1t::L1Candidate> > output_matrix(input_matrix.size(),
                                                            std::vector<l1t::L1Candidate>(input_matrix[0].size()));

  for (unsigned int i = 0; i < input_matrix.size(); i++) {
    int rank = 0;
    for (unsigned int j = 0; j < input_matrix.size(); j++) {
      if ((input_matrix[i][0].hwPt() > input_matrix[j][0].hwPt()) ||
          ((input_matrix[i][0].hwPt() == input_matrix[j][0].hwPt()) && i < j))
        rank++;
    }  //j
    output_matrix[input_matrix.size() - 1 - rank] = input_matrix[i];
  }  //i

  return output_matrix;
}

super_sort_matrix_rows()

std::vector<std::vector<l1t::L1Candidate> > super_sort_matrix_rows	(	std::vector< std::vector< l1t::L1Candidate > > const &	input_matrix,
		unsigned int	group_size,
		unsigned int	n_keep
	)

Definition at line 211 of file HardwareSortingMethods.cc.

References array_from_row_sorted_matrix(), extract_sub_jet_energy_position_matrix(), g, mps_fire::i, print2DVector(), findQualityFiles::size, sort_array(), and verbose.

Referenced by l1t::SortEGammas(), l1t::SortJets(), and l1t::SortTaus().

                                                                                                             {
  unsigned int n_groups =
      input_matrix.size() / group_size +
      (1 - input_matrix.size() / group_size * group_size / input_matrix.size());  //constants must make this an integer
  std::vector<std::vector<l1t::L1Candidate> > output_matrix(n_groups, std::vector<l1t::L1Candidate>(n_keep));

  for (unsigned int g = 0; g < n_groups; g++) {
    std::vector<std::vector<l1t::L1Candidate> > small_output_matrix = extract_sub_jet_energy_position_matrix(
        input_matrix, g * group_size, (g + 1) * group_size - 1, 0, input_matrix[0].size() - 1);
    std::vector<l1t::L1Candidate> unsorted_array = array_from_row_sorted_matrix(small_output_matrix, n_keep);
    std::vector<l1t::L1Candidate> unsorted_array_without_largest(unsorted_array.size() -
                                                                 1);  //we know first element is the biggest
    for (unsigned int i = 0; i < unsorted_array.size() - 1; i++) {
      unsorted_array_without_largest[i] = unsorted_array[1 + i];
    }
    std::vector<l1t::L1Candidate> sorted_array_without_largest = sort_array(unsorted_array_without_largest);

    std::vector<l1t::L1Candidate> sorted_array(n_keep);
    sorted_array[0] = unsorted_array[0];
    for (unsigned int i = 0; i < n_keep - 1; i++) {
      sorted_array[1 + i] = sorted_array_without_largest[i];
    }

    output_matrix[g] = sorted_array;
  }  //g

  if (verbose)
    print2DVector(output_matrix);
  return output_matrix;
}