Bins2DBase.cxx

Go to the documentation of this file.
00001 
00013 #ifdef _MSC_VER
00014 // Include max() and min() missing from MicroSoft Visual C++.
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   // else Y
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 { // else Y
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 { // Y
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   // else Y
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   // else Y
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 { // "Y"
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   //else "Y"
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   // else Y
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 /* virtual */
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   // The following is necessary in order to prevent a memory leak
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   // note: using setLabelAt instead of setLables(...) save 10KB of code
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 }

Generated for HippoDraw Class Library by doxygen