BinningProjector.cxx

Go to the documentation of this file.
00001 
00013 #ifdef _MSC_VER
00014 #include "msdevstudio/MSconfig.h"
00015 #endif
00016 
00017 #include "BinningProjector.h"
00018 
00019 #include "axes/AxisModelBase.h"
00020 #include "binners/BinsBase.h"
00021 #include "datasrcs/NTuple.h"
00022 
00023 #include <cassert>
00024 
00025 #ifdef ITERATOR_MEMBER_DEFECT
00026 using namespace std;
00027 #else
00028 using std::string;
00029 using std::list;
00030 using std::vector;
00031 #endif
00032 
00033 using namespace hippodraw;
00034 
00035 BinningProjector::BinningProjector ( unsigned int axes )
00036   : m_binner_dim ( axes ),
00037     m_binner ( 0 )
00038 {
00039 }
00040 
00041 BinningProjector::BinningProjector ( const BinningProjector & projector )
00042   : ProjectorBase ( projector ),
00043     m_binner_dim ( projector.m_binner_dim ),
00044     m_binner ( 0 )
00045 {
00046   if ( projector.m_binner != 0 ) {
00047     m_binner = projector.m_binner->clone ();
00048     m_proj_values = m_binner -> createNTuple ();
00049     fillDataSource ( m_proj_values );
00050   } 
00051 }
00052 
00053 BinningProjector::~BinningProjector ()
00054 {
00055   if ( m_binner != 0 ) {
00056     delete m_binner;
00057   }
00058 }
00059 
00060 void
00061 BinningProjector::
00062 setAxisModel ( hippodraw::Axes::Type axis, AxisModelBase * model )
00063 {
00064   ProjectorBase::setAxisModel ( axis, model );
00065   checkScaling ();
00066 }
00067 
00068 void BinningProjector::prepareValues()
00069 {
00070   bool is_dirty = isDirty();
00071   if ( is_dirty ) {
00072     execute();
00073     fillDataSource ( m_proj_values );
00074     setDirty ( false );
00075   }
00076 }
00077 
00078 const BinsBase *
00079 BinningProjector::
00080 getBinner ( ) const
00081 {
00082   return m_binner;
00083 }
00084 
00085 void
00086 BinningProjector::
00087 setBinner ( BinsBase * bins )
00088 {
00089   if ( m_binner != 0 ) delete m_binner;
00090   m_binner = bins;
00091   if ( m_proj_values != 0 ) delete m_proj_values;
00092   m_proj_values = m_binner -> createNTuple ();
00093 }
00094 
00095 void
00096 BinningProjector::
00097 setBinnerOn ( BinnerAxis * binner,
00098               hippodraw::Axes::Type type )
00099 {
00100   string axis;
00101   if ( type == Axes::X ) axis = "X";
00102   else if ( type == Axes::Y ) axis = "Y";
00103   else axis = "Z";
00104 
00105   bool yes = isAxisBinned ( axis );
00106   if ( ! yes ) return;
00107 
00108   m_binner->setBinnerOn ( binner, type );
00109   checkScaling ();
00110 
00111   setDirty ( true );
00112 }
00113 
00114 int
00115 BinningProjector::
00116 getNumberOfBins ( hippodraw::Axes::Type axis ) const
00117 {
00118   assert ( m_binner );
00119 
00120   if ( axis == Axes::X || 
00121        ( m_binner_dim == 2 && axis == Axes::Y ) ) {
00122     return m_binner->numberOfBins ( axis );
00123   }
00124 
00125   return ProjectorBase::getNumberOfBins ( axis );
00126 }
00127 
00132 const Range &
00133 BinningProjector::
00134 setBinWidth ( hippodraw::Axes::Type axis, double width )
00135 {
00136   assert ( axis == Axes::X && width > 0. );
00137 
00138   const Range & range = m_binner->setBinWidth ( Axes::X, width );
00139   checkScaling ();
00140 
00141   setDirty ( true );
00142 
00143   return range;
00144 }
00145 
00146 const Range &
00147 BinningProjector::
00148 setBinWidth ( Axes::Type axis, 
00149               int parm, 
00150               bool dragging )
00151 {
00152   double new_width = m_binner->calcBinWidth ( axis, parm, dragging );
00153 
00154   return setBinWidth ( axis, new_width );
00155 }
00156 
00157 void BinningProjector::setOffset ( const std::string & axis, 
00158                                    int parm, 
00159                                    bool dragging )
00160 {
00161   if ( axis != "X" ) return;
00162   
00163   double new_offset = m_binner->calcOffset ( axis, parm, dragging );
00164   setOffset ( Axes::X, new_offset );
00165 
00166   setDirty ( true );
00167 }
00168 
00169 void
00170 BinningProjector::
00171 setOffset ( hippodraw::Axes::Type axis, double offset )
00172 {
00173   if ( axis == Axes::Y ) return;
00174 
00175   m_binner->setOffset ( Axes::X, offset );
00176   m_x_axis->setRange( m_binner->getRange ( Axes::X ), true );
00177 
00178   setDirty ( true );
00179 }
00180 
00181 
00182 void BinningProjector:: reset ( )
00183 {
00184 }
00185 
00186 double
00187 BinningProjector::
00188 getOffset ( hippodraw::Axes::Type axis ) const
00189 {
00190   assert ( axis == Axes::X || axis == Axes::Y || axis == Axes::Z );
00191 
00192   if ( axis == Axes::X ||
00193        ( axis == Axes::Y && m_binner_dim == 2 ) ) {
00194     return m_binner->getOffset ( axis );
00195   }
00196 
00197   // else Z
00198   return 0.0;
00199 }
00200 
00201 double
00202 BinningProjector::
00203 getBinWidth (hippodraw:: Axes::Type axis ) const
00204 {
00205   assert ( axis == Axes::X || axis == Axes::Y || axis == Axes::Z );
00206 
00207   if ( axis == Axes::X ||
00208        ( axis == Axes::Y && m_binner_dim == 2 ) ) {
00209     return m_binner->binWidth ( axis );
00210   }
00211 
00212   // else Z
00213   return 0.0;
00214 }
00215 
00217 void BinningProjector::execute ()
00218 {
00219 }
00220 
00221 void BinningProjector::checkScaling ()
00222 {
00223   // does nothing
00224 }
00225 
00226 double BinningProjector::getZValue ( double x, double y ) const
00227 {
00228   return m_binner->getZValue ( x, y );
00229 }
00230 
00231 DataSource *
00232 BinningProjector::
00233 createNTuple () const
00234 {
00235   return m_binner->createNTuple ();
00236 }
00237 
00238 void
00239 BinningProjector::
00240 fillDataSource ( DataSource * ntuple, bool ) const
00241 {
00242   m_binner -> fillDataSource ( ntuple );
00243 }
00244 
00245 void
00246 BinningProjector::
00247 normalizeTo ( double number )
00248 {
00249   m_binner -> scaleNumberOfEntries ( number );
00250 }
00251 
00252 void
00253 BinningProjector::
00254 setNormalizing ( bool on )
00255 {
00256   m_binner -> setEntriesScaling ( on );
00257 }
00258 
00261 void
00262 BinningProjector::
00263 normalizeTo ( const ProjectorBase * target )
00264 {
00265   if ( target != 0 ) {
00266     if ( target -> isValueBinned ( ) ) {
00267       m_target = target;
00268       ProjectorBase * t = const_cast < ProjectorBase * > ( target );
00269       t -> addObserver ( this );
00270       setNormalizing ( true );
00271       normalize ();
00272     }
00273   }
00274   else {
00275     if ( m_target != 0 ) {
00276       ProjectorBase * t = const_cast < ProjectorBase * > ( m_target );
00277       t -> removeObserver ( this );
00278       setNormalizing ( false );
00279     }
00280     m_target = 0;
00281   }
00282 }
00283 
00284 void
00285 BinningProjector::
00286 normalize ()
00287 {
00288   int number = m_target ->getNumberOfEntries ();
00289   double norm = number;
00290   normalizeTo ( norm );
00291 
00292   setDirty ( true );
00293 }
00294 
00295 void
00296 BinningProjector::
00297 update ( const Observable * object )
00298 {
00299   if ( object == m_target ) {
00300     normalize ();
00301   }
00302 
00303   else notifyObservers ();
00304 }
00305 
00306 void
00307 BinningProjector::
00308 willDelete ( const Observable * object )
00309 {
00310   if ( object == m_target ) {
00311     m_target = 0;
00312     setNormalizing ( false );
00313     setDirty ( true );
00314   }
00315 }
00316 
00317 void
00318 BinningProjector::
00319 setBinContents ( const DataSource * source )
00320 {
00321   m_binner -> setBinContents ( source );
00322 }
00323 
00324 void
00325 BinningProjector::
00326 setMinEntries ( int entries )
00327 {
00328   m_binner -> setMinEntries ( entries );
00329   setDirty ( true );
00330 }
00331 
00332 int
00333 BinningProjector::
00334 getMinEntries ()
00335 {
00336   return m_binner -> getMinEntries ();
00337 }
00338 
00339 bool
00340 BinningProjector::
00341 isImageConvertable () const
00342 {
00343   return m_binner_dim == 2 &&
00344          m_binner -> hasEqualWidths();
00345 }

Generated for HippoDraw Class Library by doxygen