00001
00012 #include "NTupleSorter.h"
00013
00014 #include "NTuple.h"
00015
00016 #include <algorithm>
00017 #include <functional>
00018 #include <iterator>
00019
00020 using std::distance;
00021 using std::greater;
00022 using std::sort;
00023 using std::vector;
00024 using std::lower_bound;
00025
00026 namespace hippodraw {
00027
00028 NTupleSorter::
00029 NTupleSorter ( NTuple * ntuple )
00030 : m_column ( 0 ),
00031 m_increasing ( true ),
00032 m_ntuple ( ntuple )
00033 {
00034 }
00035
00036 NTupleSorter::
00037 NTupleSorter ( const NTupleSorter & sorter )
00038 : m_column ( sorter.m_column ),
00039 m_increasing ( sorter.m_increasing ),
00040 m_ntuple ( 0 )
00041 {
00042 }
00043
00044 NTuple *
00045 NTupleSorter::
00046 getNTuple () const
00047 {
00048 return m_ntuple;
00049 }
00050
00051 void
00052 NTupleSorter::
00053 setSorting ( int column )
00054 {
00055 if ( column == m_column ) {
00056 m_increasing = ! m_increasing;
00057 return;
00058 }
00059 m_column = column;
00060 m_increasing = true;
00061 }
00062
00063 void
00064 NTupleSorter::
00065 rowwiseCopy ( std::vector < std::vector < double > * > & row_copy )
00066 {
00067 row_copy.clear();
00068 unsigned int rows = m_ntuple -> rows ();
00069
00070 for ( unsigned int row = 0; row < rows; row++ ) {
00071 const vector < double > & v = m_ntuple -> getRow ( row );
00072 vector < double > * p = new vector < double > ( v );
00073 row_copy.push_back ( p );
00074 }
00075 }
00076
00077 bool
00078 NTupleSorter::
00079 operator () ( std::vector < double > * x,
00080 std::vector < double > * y ) const
00081 {
00082 double left = x -> operator[] ( m_column );
00083 double right = y -> operator[] ( m_column );
00084
00085 return m_increasing ? left < right : right < left;
00086 }
00087
00088 void
00089 NTupleSorter::
00090 sort ( )
00091 {
00092 vector < vector < double > * > table;
00093 rowwiseCopy ( table );
00094
00095 std::sort ( table.begin(), table.end(), *this );
00096
00097 m_ntuple -> clear ();
00098
00099 vector < vector < double > * > :: iterator first = table.begin ();
00100 while ( first != table.end () ) {
00101 vector < double > * p = *first++;
00102 m_ntuple -> addRow ( *p );
00103 delete p;
00104 }
00105 m_ntuple ->notifyObservers();
00106 }
00107
00108 void
00109 NTupleSorter::
00110 clear ()
00111 {
00112 m_ntuple->clear();
00113 }
00114
00115 void
00116 NTupleSorter::
00117 addRow ( const std::vector < double > & row )
00118 {
00119 double sort_value = row[m_column];
00120
00121 const vector < double > & column = m_ntuple ->getColumn ( m_column );
00122 vector < double > ::const_iterator first;
00123
00124 if ( m_increasing ) {
00125 first = lower_bound ( column.begin(), column.end(), sort_value );
00126 }
00127 else {
00128 first = lower_bound ( column.begin(), column.end(),
00129 sort_value, greater< double >() );
00130 }
00131 unsigned int index = distance ( column.begin(), first );
00132
00133 m_ntuple->insertRow ( index, row );
00134 }
00135
00136 void
00137 NTupleSorter::
00138 eraseRow ( unsigned int index )
00139 {
00140 m_ntuple -> eraseRow ( index );
00141 }
00142
00143 unsigned int
00144 NTupleSorter::
00145 columns ( ) const
00146 {
00147 return m_ntuple->columns ();
00148 }
00149
00150 unsigned int
00151 NTupleSorter::
00152 rows ( ) const
00153 {
00154 return m_ntuple->rows ();
00155 }
00156
00157 const vector < double > &
00158 NTupleSorter::
00159 getRow ( unsigned int index ) const
00160 {
00161 return m_ntuple->getRow ( index );
00162 }
00163
00164 }
00165