00001
00013 #ifdef _MSC_VER
00014
00015 #include "msdevstudio/MSconfig.h"
00016 #endif
00017
00018 #include "Bins2DBase.h"
00019
00020 #include "BinnerAxis.h"
00021
00022 #include "datasrcs/NTuple.h"
00023
00024 #include <numeric>
00025
00026 #include <cassert>
00027
00028 using std::string;
00029 using std::vector;
00030
00031
00032 using namespace hippodraw;
00033
00034 Bins2DBase::Bins2DBase ( const char * name )
00035 : BinsBase ( name ),
00036 binner_axisX ( 0 ),
00037 binner_axisY ( 0 )
00038 {
00039 }
00040
00041 Bins2DBase::Bins2DBase ( const Bins2DBase & binner )
00042 : BinsBase( binner ),
00043 binner_axisX ( 0 ),
00044 binner_axisY ( 0 ),
00045 m_data ( binner.m_data )
00046 {
00047 if ( binner.binner_axisX != 0 ) {
00048 binner_axisX = binner.binner_axisX->clone ();
00049 }
00050
00051 if ( binner.binner_axisY != 0 ) {
00052 binner_axisY = binner.binner_axisY->clone ();
00053 }
00054
00055 m_values_dirty = true;
00056 }
00057
00058 Bins2DBase::~Bins2DBase ()
00059 {
00060 if ( binner_axisX ) delete binner_axisX;
00061 if ( binner_axisY ) delete binner_axisY;
00062 }
00063
00064 int
00065 Bins2DBase::
00066 getNumberOfAxes () const
00067 {
00068 return 2;
00069 }
00070
00071 void Bins2DBase::resize ()
00072 {
00073 int nbx = numberOfBins ( Axes::X );
00074 int nby = numberOfBins ( Axes::Y );
00075
00076 if ( nbx == 0 ||
00077 nby == 0 ) return;
00078
00079 resize ( nbx, nby );
00080 }
00081
00082 const BinnerAxis *
00083 Bins2DBase::
00084 getBinnerOn ( hippodraw::Axes::Type axis ) const
00085 {
00086 assert ( axis == Axes::X ||
00087 axis == Axes::Y );
00088
00089 if ( axis == Axes::X ) return binner_axisX;
00090
00091 return binner_axisY;
00092 }
00093
00094
00095 void
00096 Bins2DBase::
00097 setBinnerOn ( BinnerAxis * binner, hippodraw::Axes::Type axis )
00098 {
00099 assert ( axis == Axes::X || axis == Axes::Y );
00100
00101 if ( axis == Axes::X ) {
00102 if ( binner_axisX ) delete binner_axisX;
00103 binner_axisX = binner;
00104 }
00105 else {
00106 if ( binner_axisY ) delete binner_axisY;
00107 binner_axisY = binner;
00108 }
00109 resize ();
00110
00111 m_values_dirty = true;
00112 }
00113
00114 double
00115 Bins2DBase::
00116 getLow ( hippodraw::Axes::Type axis ) const
00117 {
00118 if ( axis == Axes::X ) return binner_axisX->axisGetLow();
00119 if ( axis == Axes::Y ) return binner_axisY->axisGetLow();
00120
00121 assert ( false );
00122 return 0.0;
00123 }
00124
00125 void
00126 Bins2DBase::
00127 setNumberOfBins ( hippodraw::Axes::Type axis, int nb )
00128 {
00129 assert ( axis == Axes::X || axis == Axes::Y );
00130
00131 if ( axis == Axes::X ) {
00132 binner_axisX->axisSetNumberOfBins( nb );
00133
00134 if ( numberOfBins ( Axes::Y ) > 0 ) {
00135 setNumberOfBins ( Axes::Y, numberOfBins ( Axes::Y ) );
00136 }
00137 }
00138 else {
00139 binner_axisY->axisSetNumberOfBins ( nb );
00140 }
00141
00142 m_num_bins = numberOfBins ( Axes::X ) * numberOfBins ( Axes::Y );
00143 }
00144
00145 int Bins2DBase::numberOfBins() const
00146 {
00147 return m_num_bins;
00148 }
00149
00150 int
00151 Bins2DBase::
00152 numberOfBins ( hippodraw::Axes::Type axis) const
00153 {
00154 assert ( axis == Axes::X || axis == Axes::Y );
00155
00156 if ( axis == Axes::X &&
00157 binner_axisX != 0 ) return binner_axisX->axisNumberOfBins();
00158
00159 if ( binner_axisY != 0 ) return binner_axisY->axisNumberOfBins();
00160
00161 return 0;
00162 }
00163
00164 int Bins2DBase::binNumberX( double x ) const
00165 {
00166 return binner_axisX->axisBinNumber( x );
00167 }
00168
00169 int Bins2DBase::binNumberY( double y ) const
00170 {
00171 return binner_axisY->axisBinNumber( y );
00172 }
00173
00174 double
00175 Bins2DBase::
00176 binWidth ( hippodraw::Axes::Type axis ) const
00177 {
00178 assert ( axis == Axes::X || axis == Axes::Y );
00179
00180 if ( axis == Axes::X ) return binner_axisX->getConstWid();
00181
00182 return binner_axisY->getConstWid ();
00183 }
00184
00185 double Bins2DBase::binWidthX ( int i ) const
00186 {
00187 return binner_axisX->axisBinWidth( i );
00188 }
00189
00190 double Bins2DBase::binWidthY ( int i ) const
00191 {
00192 return binner_axisY->axisBinWidth( i );
00193 }
00194
00195 bool
00196 Bins2DBase::hasEqualWidths () const
00197 {
00198 return binner_axisX->hasEqualWidths () && binner_axisY->hasEqualWidths ();
00199 }
00200
00201 double
00202 Bins2DBase::scaleFactor () const
00203 {
00204 if ( binner_axisX->hasEqualWidths () == false ||
00205 binner_axisY->hasEqualWidths () == false ) {
00206 return 1.0;
00207 }
00208
00209 double width_x = binner_axisX->axisBinWidth ( 1 );
00210 double width_y = binner_axisY->axisBinWidth ( 1 );
00211
00212 return width_x * width_y;
00213 }
00214
00215 const Range &
00216 Bins2DBase::
00217 setBinWidth ( hippodraw::Axes::Type axis, double width )
00218 {
00219 assert ( axis == Axes::X || axis == Axes::Y );
00220 assert ( width > 0.0 );
00221
00222 BinnerAxis * binner = 0;
00223 if ( axis == Axes::X ) binner = binner_axisX;
00224 else binner = binner_axisY;
00225
00226 const Range & range = binner->setBinWidth ( width );
00227
00228 resize ();
00229 m_values_dirty = true;
00230
00231 return range;
00232 }
00233
00234 double
00235 Bins2DBase::
00236 calcBinWidth ( Axes::Type axis, int parm, bool dragging ) const
00237 {
00238 double new_width = -1.0;
00239
00240 if ( axis == Axes::X ) {
00241 new_width = binner_axisX->calcBinWidth ( parm, dragging );
00242 }
00243 else {
00244 new_width = binner_axisY->calcBinWidth ( parm, dragging );
00245 }
00246
00247 return new_width;
00248 }
00249
00250 double
00251 Bins2DBase::calcOffset ( const std::string & axis,
00252 int parm,
00253 bool dragging ) const
00254 {
00255 if ( axis == "X" ) {
00256 return binner_axisX->calcOffset ( parm, dragging );
00257 }
00258
00259 return binner_axisY->calcOffset ( parm, dragging );
00260 }
00261
00262 double
00263 Bins2DBase::
00264 getOffset ( hippodraw::Axes::Type axis ) const
00265 {
00266 assert ( axis == Axes::X || axis == Axes::Y );
00267
00268 if( axis == Axes::X ) return binner_axisX->getOffset();
00269
00270 return binner_axisY->getOffset();
00271 }
00272
00273 void
00274 Bins2DBase::
00275 setOffset ( hippodraw::Axes::Type axis, double offset )
00276 {
00277 assert ( axis == Axes::X || axis == Axes::Y );
00278
00279 BinnerAxis * binner = 0;
00280 if ( axis == Axes::X ) binner = binner_axisX;
00281 else binner = binner_axisY;
00282
00283 binner->setOffset( offset );
00284
00285 m_values_dirty = true;
00286 }
00287
00288 const Range &
00289 Bins2DBase::
00290 setRange ( hippodraw::Axes::Type axis, const Range & range, bool hold_width )
00291 {
00292 assert ( axis == Axes::X || axis == Axes::Y );
00293
00294 BinnerAxis * binner = 0;
00295 if ( axis == Axes::X ) {
00296 binner = binner_axisX;
00297 } else {
00298 binner = binner_axisY;
00299 }
00300 const Range & new_range = binner->setRange ( range, hold_width );
00301 resize ();
00302
00303 return new_range;
00304 }
00305
00306
00307 const Range &
00308 Bins2DBase::
00309 getRange ( hippodraw::Axes::Type axis )
00310 {
00311 assert ( axis == Axes::X || axis == Axes::Y );
00312
00313 BinnerAxis * binner = 0;
00314 if ( axis == Axes::X ) {
00315 binner = binner_axisX;
00316 } else {
00317 binner = binner_axisY;
00318 }
00319
00320 return binner->getRange();
00321 }
00322
00323
00329 void
00330 Bins2DBase::resize ( int nx, int ny )
00331 {
00332
00333 Bins2DBase::setNumberOfBins ( Axes::Y, 0 );
00334
00335 setNumberOfBins ( Axes::X, nx );
00336 setNumberOfBins ( Axes::Y, ny );
00337
00338 m_values_dirty = true;
00339 }
00340
00341 int Bins2DBase::getNumberOfEntries () const
00342 {
00343 double sum = 0.0;
00344 for ( unsigned int i = 1; i < m_data.size () -1; i++ ) {
00345 sum += std::accumulate ( m_data[i].begin()+1, m_data[i].end()-1, 0.0 );
00346 }
00347
00348 return static_cast < int > ( sum );
00349 }
00350
00351 int Bins2DBase::getUnderflow () const
00352 {
00353 return -1;
00354 }
00355
00356 int Bins2DBase::getOverflow () const
00357 {
00358 return -1;
00359 }
00360
00361
00362 NTuple *
00363 Bins2DBase::
00364 prepareNTuple ( unsigned int rows ) const
00365 {
00366 unsigned int columns = 6;
00367 NTuple * ntuple = new NTuple ( columns );
00368 ntuple -> reserve ( rows );
00369
00370
00371 ntuple -> setLabelAt ( "X", 0 );
00372 ntuple -> setLabelAt ( "Y", 0 );
00373 ntuple -> setLabelAt ( "Value", 0 );
00374 ntuple -> setLabelAt ( "Width", 0 );
00375 ntuple -> setLabelAt ( "Height", 0 );
00376 ntuple -> setLabelAt ( "Error", 0 );
00377
00378 return ntuple;
00379 }