ProjectorBase.cxx

Go to the documentation of this file.

#ifdef HAVE_CONFIG_H
#include "config.h"
#else
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif
#endif

#include "ProjectorBase.h"
#include "ProjectorHelper.h"

#include "axes/AxisModelBase.h"
#include "datasrcs/DataSource.h"

#include <algorithm>

#include <cassert>

using namespace hippodraw;

#ifdef ITERATOR_MEMBER_DEFECT
using namespace std;
#else
using std::find;
using std::string;
using std::vector;
using std::distance;
#endif

ProjectorBase::ProjectorBase ()
  : m_isDirty ( true ),
    m_proj_values ( 0 ),
    m_x_axis ( 0 ),
    m_y_axis ( 0 ),
    m_z_axis ( 0 )
{
}

ProjectorBase::ProjectorBase ( const ProjectorBase & p )
  : m_isDirty ( true ),
    m_proj_values ( 0 ),
    m_x_axis ( p.m_x_axis ),
    m_y_axis ( p.m_y_axis ),
    m_z_axis ( p.m_z_axis )
{
}

ProjectorBase::~ProjectorBase ()
{
  if ( m_proj_values != 0 ) delete m_proj_values;
}

/* virtual */
void ProjectorBase::prepareValues ()
{
  setDirty ( false );
}

bool ProjectorBase::isDirty () const
{
  return m_isDirty;
}

void ProjectorBase::setDirty ( bool value )
{
  m_isDirty = value;

  if ( value == true ) notifyObservers ();
}

void
ProjectorBase::
setAxisBinding ( const std::string & axis,
                 const std::string & label )
{
  assert ( false );
}

void
ProjectorBase::
setAxisBindings ( const std::vector < std::string > & bindings )
{
  assert ( false );
}

const vector < string > &
ProjectorBase::
getAxisBindings () const
{
  assert ( false );
  static vector < string > dummy;

  return dummy;
}

void
ProjectorBase::
matrixTranspose ( bool )
{
  // does nothing
}

int
ProjectorBase::
getNumberOfBins ( hippodraw::Axes::Type ) const
{
  return 0;
}

bool ProjectorBase::isAxisBinned ( const std::string & ) const
{
  return false;
}

bool ProjectorBase::isValueBinned () const
{
  return false;
}

void
ProjectorBase::
setRange ( hippodraw::Axes::Type axis, bool )
{
  // The only supported axis so far...
  assert ( axis == Axes::X || axis == Axes::Y || axis == Axes::Z );

  if ( axis == Axes::Z ) assert ( m_z_axis != 0 );

  setDirty ( true );
}

const Range &
ProjectorBase::
getRange ( hippodraw::Axes::Type axis ) const
{
  // All the axis supported so far  
  assert ( axis == Axes::X || axis == Axes::Y || axis == Axes::Z );
  
  if ( axis == Axes::X ) {
    return m_x_axis->getRange (false);
  }
  if ( axis == Axes::Y ) {
    return m_y_axis->getRange (false);
  }
  //else
  assert ( m_z_axis != 0 );
  return m_z_axis->getRange (false);
}

Range
ProjectorBase::
preferredRange ( hippodraw::Axes::Type axis ) const
{
  Range range = dataRangeOn ( axis );

  if ( range.length() == 0.0 ) {
    double low = range.low ();

    if ( axis == Axes::Y && 
         low == 0.0 ) {
        range.setHigh ( 1.0 );
    }
    else {
      range.setLow ( low - 1. );
      range.setHigh ( low + 1. );
    }
  }

  return range;
}

void
ProjectorBase::
setAxisModel ( hippodraw::Axes::Type axis,
               AxisModelBase * axis_model )
{
  assert ( axis == Axes::X || axis == Axes::Y || axis == Axes::Z );

  if ( axis == Axes::X ) {
    m_x_axis = axis_model;
  }
  if ( axis == Axes::Y ) {
    m_y_axis = axis_model;
  }

  if ( axis == Axes::Z ) {
    m_z_axis = axis_model;
  }
}

AxisModelBase *
ProjectorBase::
getAxisModel ( hippodraw::Axes::Type axis ) const
{
  assert ( axis == Axes::X || axis == Axes::Y || axis == Axes::Z );

  if ( axis == Axes::X ) {
    return m_x_axis;
  }
  
  if ( axis == Axes::Y ) {
    return m_y_axis;
  }

  return m_z_axis;
}

void
ProjectorBase::
setNumberOfBins ( hippodraw::Axes::Type axis, unsigned int number  )
{
}

void
ProjectorBase::
setBinWidth ( hippodraw::Axes::Type, double  )
{
}

/* virtual */
void ProjectorBase::setBinWidth ( const std::string & axis, 
                                  int parm, 
                                  bool dragging )
{
}
/* virtual */
void ProjectorBase::setOffset ( const std::string & axis, 
                                int parm, 
                                bool dragging )
{
}

void
ProjectorBase::
setOffset ( hippodraw::Axes::Type, double )
{
}

void 
ProjectorBase::
reset ( )
{
}

double
ProjectorBase::
getOffset ( hippodraw::Axes::Type ) const
{
  return 0.0;
}

double
ProjectorBase::
getAverage ( hippodraw::Axes::Type ) const
{
  // Never used as subclasses do the work.
  return 0.0;
}

double
ProjectorBase::
getRMS ( hippodraw::Axes::Type axis )
{
  ProjectorHelper helper( getProjectedValues() );
  
  double rms = 0.0;
  
  if ( axis == Axes::X ) 
    rms = helper.stdCoord();
  
  return rms;
}

const std::string & ProjectorBase::getZLabel () const
{
  return m_z_label;
}

double
ProjectorBase::
getBinWidth ( hippodraw::Axes::Type ) const
{
  return 0.0;
}

/* virtual */
double ProjectorBase::getZValue ( double x, double y ) const
{ 
  return 0.0;
}

void
ProjectorBase::
addValues ( const std::vector < double > & v )
{
  // do nothing
}

const vector <string> & ProjectorBase::getPointReps() const
{
  return m_pointreps;
}

NTuple *
ProjectorBase::
getNTupleAfterCuts() const
{
   return 0;
}

bool
ProjectorBase::
wantsScaleFactor ( const std::string &  ) const
{
  return false;
}

const DataSource * 
ProjectorBase::
getProjectedValues () const
{
  return m_proj_values;
}

const DataSource *
ProjectorBase::
createOldStyleNTuple () const
{
  ProjectorBase * projector = const_cast < ProjectorBase * > ( this );
  projector -> prepareValues ();

  return getProjectedValues ();
}

void
ProjectorBase::
normalizeTo ( double number )
{
  // does nothing
}

void
ProjectorBase::
setNormalizing ( bool on )
{
  // does nothing
}

void
ProjectorBase::
update ( const Observable * )
{
  // does nothing
}

void
ProjectorBase::
normalizeTo ( const ProjectorBase * )
{
  // des nothing
}

---