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
	map containing the conditions

Functions
std::vector< l1t::L1Candidate >	array_from_row_sorted_matrix (std::vector< std::vector< l1t::L1Candidate > > input_matrix, unsigned int n_keep)
std::vector< std::vector < l1t::L1Candidate > >	extract_sub_jet_energy_position_matrix (std::vector< std::vector< l1t::L1Candidate > > 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 > > energies, int rows, int cols)
std::vector< std::vector < l1t::L1Candidate > >	presort_egamma (std::vector< l1t::L1Candidate > input_egamma, int rows, int cols)
void	print2DVector (std::vector< std::vector< l1t::L1Candidate > > myVector)
std::vector< l1t::L1Candidate >	sort_array (std::vector< l1t::L1Candidate > inputArray)
std::vector< std::vector < l1t::L1Candidate > >	sort_by_row_in_groups (std::vector< std::vector< l1t::L1Candidate > > input_matrix, int group_size)
std::vector< std::vector < l1t::L1Candidate > >	sort_matrix_rows (std::vector< std::vector< l1t::L1Candidate > > 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 > > input_matrix, unsigned int group_size, unsigned int n_keep)

Variables
int	fw_to_gt_phi_map [] = {4, 3, 2, 1, 0, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5}
int	gt_to_fw_phi_map [] = {4, 3, 2, 1, 0, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5}
bool	verbose = false

Function Documentation

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

Definition at line 154 of file HardwareSortingMethods.cc.

References i, j, relval_steps::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;
}

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

Definition at line 104 of file HardwareSortingMethods.cc.

References i, 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;
}

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

Definition at line 62 of file HardwareSortingMethods.cc.

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

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

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

Definition at line 212 of file HardwareSortingMethods.cc.

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

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, 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
      //cout << "row, col = " << row << ", " << col << endl;

      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;

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

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

  return sorted_energies;
}

void print2DVector

(

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

myVector

)

Definition at line 35 of file HardwareSortingMethods.cc.

References EnergyCorrector::c, gather_cfg::cout, 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;
  }
}

std::vector<l1t::L1Candidate> sort_array

(

std::vector< l1t::L1Candidate >

inputArray

)

Definition at line 50 of file HardwareSortingMethods.cc.

References i, and 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;
}

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

Definition at line 134 of file HardwareSortingMethods.cc.

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

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

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

(

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

input_matrix

)

Definition at line 120 of file HardwareSortingMethods.cc.

References i, and 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;
}

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

Definition at line 186 of file HardwareSortingMethods.cc.

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

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

Variable Documentation

int fw_to_gt_phi_map[] = {4, 3, 2, 1, 0, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5}

Definition at line 15 of file HardwareSortingMethods.cc.

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

int gt_to_fw_phi_map[] = {4, 3, 2, 1, 0, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5}

Definition at line 16 of file HardwareSortingMethods.cc.

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

bool verbose = false

Definition at line 13 of file HardwareSortingMethods.cc.

Referenced by L1TdeGCT::analyze(), L1TDEMON::analyze(), L1Comparator::beginRun(), L1TdeGCT::bookHistograms(), L1TDEMON::bookHistograms(), CalibratedElectronProducer::CalibratedElectronProducer(), CalibratedPatElectronProducer::CalibratedPatElectronProducer(), MultiVertexFitter::fit(), FlavorHistoryFilter::FlavorHistoryFilter(), JetMETDQMDCSFilter::JetMETDQMDCSFilter(), L1Comparator::L1Comparator(), L1DummyProducer::L1DummyProducer(), L1EmulBias::L1EmulBias(), L1TdeGCT::L1TdeGCT(), L1TDEMON::L1TDEMON(), MultiVertexFitter::lostVertexClaimer(), main(), parseFFTJetCorrector(), L1Comparator::process(), L1EmulBias::produce(), L1DummyProducer::produce(), L1Comparator::produce(), FFTJetCorrectionESProducer< CT >::produce(), PFPileUpAlgo::setVerbose(), TH1Store::setVerbose(), QCriterion::setVerbose(), PFECALSuperClusterAlgo::setVerbosityLevel(), MultiVertexFitter::updateSeeds(), MultiVertexFitter::updateWeights(), MultiVertexReconstructor::vertices(), and MultiVertexFitter::vertices().