DataRep.cxx

Go to the documentation of this file.

// for truncation warning in debug mode
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif

#include "DataRep.h"

#include "datasrcs/NTuple.h"
#include "datasrcs/TupleCut.h"
#include "projectors/ProjectorBase.h"
#include "reps/CutRangeRep.h"

#include <algorithm>
#include <stdexcept>

using namespace hippodraw;

using std::string;
using std::vector;


DataRep::DataRep ( )
  : m_title ( "%t" ),
    m_projector ( 0 ),
    m_rep ( 0 ),
    m_parent_datarep ( 0 ),
    m_cut_rep ( 0 )
{
}

DataRep::DataRep ( const DataRep & rep )
  : m_name ( rep.m_name ),
    m_title ( rep.m_title ),
    m_cut_rep ( 0 )
{
  m_rep = rep.m_rep->clone ();
  m_projector = rep.m_projector->clone();
  m_parent_datarep = rep.m_parent_datarep;
  if ( rep.m_cut_rep != 0 ) {
    m_cut_rep = rep.m_cut_rep -> clone ();
  }
}

DataRep::~DataRep ()
{
  notifyObservers ( &Observer::willDelete );

  delete m_projector;
  delete m_rep;
  if ( m_cut_rep != 0 ) delete m_cut_rep;
}

void DataRep::update ( const Observable * )
{
  notifyObservers ();
}

const string & DataRep::name () const
{
  return m_name;
}

/* virtual */
DataRep * DataRep::getParentDataRep()
{
  return m_parent_datarep;
}

/* virtual */
void DataRep::setParentDataRep( DataRep * parent_datarep )
{
  m_parent_datarep =  parent_datarep;
}


bool DataRep:: hasErrorDisplay () const
{
  return false;
}

bool DataRep::hasNTupleBindings () const
{
  return true;
}

void
DataRep::
setAxisBinding ( const std::string & axis, 
                 const std::string & label )
{
  if ( hasNTupleBindings () ) {
    m_projector -> setAxisBinding ( axis, label );
  }
}

void
DataRep::
setAxisBindings ( const std::vector < std::string > & bindings )
{
  if ( hasNTupleBindings () ) {
    m_projector -> setAxisBindings ( bindings );
  }
}

void
DataRep::
matrixTranspose ( bool yes )
{
  m_projector -> matrixTranspose ( yes );
}

void DataRep::setRepSize ( float size )
{
 m_rep->setSize ( size );

 notifyObservers();
}

void DataRep::setDirty ( bool flag )
{
  m_projector->setDirty ( flag );
}

ProjectorBase * DataRep::getProjector ( ) const
{
  return m_projector;
}

void
DataRep::
setAxisModel ( hippodraw::Axes::Type axis, AxisModelBase * model )
{
  m_projector->setAxisModel ( axis, model );
}

void DataRep::setSelected ( bool yes )
{
  m_rep->setSelected ( yes );
}

bool
DataRep::
isSelected () const
{
  return m_rep ->isSelected ();
}

bool DataRep::isDirty ( ) const
{
  return m_projector->isDirty();
}

double
DataRep::
getPosRange ( hippodraw::Axes::Type axis )
{
  return m_projector->getPosOn ( axis );
}

Range
DataRep::
preferredRange ( hippodraw::Axes::Type axis )
{
  return m_projector->preferredRange ( axis );
}

void
DataRep::
setErrorDisplay ( hippodraw::Axes::Type axis, bool flag )
{
  assert ( axis == Axes::X || axis == Axes::Y );

  if ( axis == Axes::X ) {
    m_rep->setErrorOn ( "x", flag );
  }
  //else
  m_rep->setErrorOn ( "y", flag );

  notifyObservers ();
}

bool
DataRep::
isErrorDisplayed ( hippodraw::Axes::Type axis ) const
{
  assert ( axis == Axes::X || axis == Axes::Y );


  if ( axis == Axes::X ) {
    return m_rep->xError ( );
  }
  //else
  return m_rep->yError ( );
}


void
DataRep::
setRange ( hippodraw::Axes::Type axis, bool const_width )
{
  m_projector->setRange ( axis, const_width );
}

void DataRep::setRepresentation ( RepBase * rep )
{
  if ( m_rep != 0 ) {
    bool yes_x = m_rep -> xError ();
    bool yes_y = m_rep -> yError ();

    delete m_rep;

    rep -> setErrorOn ( "x", yes_x );
    rep -> setErrorOn ( "y", yes_y );
  }
  m_rep = rep;

  notifyObservers ();
}

RepBase * DataRep::getRepresentation () const
{
  return m_rep;
}

void DataRep::setRepColor ( const Color & color )
{
  m_rep->setColor ( color );

  notifyObservers ();
}

void DataRep::setRepStyle ( int style )
{
  m_rep->setStyle ( style );
  
  notifyObservers ();
}

const Color & DataRep::getRepColor () const
{
  return m_rep->color ();
}

const DataSource *
DataRep::
getProjectedValues () const
{
  m_projector->prepareValues();
  const DataSource * ntuple = m_projector -> getProjectedValues ();

  return ntuple;
}

void
DataRep::
drawProjectedValues ( TransformBase * transform, ViewBase * view )
{
  drawCuts ( transform, view );
  const DataSource * ntuple = getProjectedValues ();

  m_rep -> drawProjectedValues ( ntuple, transform, view );
}

void
DataRep::
drawCuts ( TransformBase * transform, ViewBase * view )
{
  if ( m_cut_list.empty () == false ) {
    if ( m_cut_rep == 0 ) {
      m_cut_rep = new CutRangeRep ();
    }
    const Range & x_range = m_projector -> getRange ( Axes::X );
    const Range & y_range = m_projector -> getRange ( Axes::Y );
    CutRangeRep * rep = dynamic_cast < CutRangeRep * > ( m_cut_rep );
    assert ( rep );

    rep -> drawRange ( x_range, y_range, m_cut_list, *transform, *view );
  }
}

bool DataRep::acceptFunction ( int num )
{
  return false;
}

bool DataRep::hasZeroRows ( )
{
  bool yes = true;
  if ( m_projector != 0 )  {
    yes = m_projector->isEmpty ();
  }

  return yes;
}

bool DataRep::hasZoomY ( ) const
{
  return true;
}

void
DataRep::
addValues  ( const std::vector < double > & v )
{
  if ( hasNTupleBindings () ) return;

  m_projector -> addValues ( v );
}

NTuple *
DataRep::
getNTupleAfterCuts () const
{
   return m_projector->getNTupleAfterCuts();
}

double
DataRep::
getMean ( const std::string & axis )
{
  Axes::Type type = Axes::convert ( axis );

  return m_projector -> getAverage ( type );
}

double
DataRep::
getRMS ( const std::string & axis )
{
  Axes::Type type = Axes::convert ( axis );

  return m_projector -> getRMS ( type );
}

bool
DataRep::
isAxisBinned ( hippodraw::Axes::Type axis ) const
{
  bool yes = false;
  if ( axis == Axes::X ) yes = m_projector -> isAxisBinned ( "X" );
  else if ( axis == Axes::Y ) yes = m_projector -> isAxisBinned ( "Y" );

  return yes;
}

void
DataRep::
update ()
{
  m_projector -> setDirty ( true );
}

void
DataRep::
 normalizeTo ( const DataRep * target )
{
  ProjectorBase * projector = target -> getProjector ();

  m_projector -> normalizeTo ( projector );
}

void
DataRep::
setBinWidth ( hippodraw::Axes::Type axis, double width )
{
  m_projector -> setBinWidth ( axis, width );
}

int
DataRep::
getNumberOfEntries () const
{
  return m_projector -> getNumberOfEntries ();
}

bool
DataRep::
isTargetable () const
{
  return true;
}

NTuple *
DataRep::
createNTuple () const
{
  m_projector->prepareValues();
  const DataSource * ds = m_projector -> createOldStyleNTuple ();
  NTuple * ntuple = new NTuple ( ds );

  return ntuple;
}

void
DataRep::
setTitle ( const std::string & title )
{
  m_title = title;
}

const std::string &
DataRep::
getTitle ( ) const
{
  if ( m_title == "%t" ) {
    return m_projector -> getTitle ();
  }
  //  else 
  return m_title;
}

bool
DataRep::
needColorRep () const
{
  return hasAxis ( Axes::Z );
}

bool
DataRep::
hasAxis ( hippodraw::Axes::Type axis ) const
{
  assert ( false );
  return false;
}

const DataRep::CutList_t &
DataRep::
getCuts () const
{
  return m_cut_list;
}

bool
DataRep::
hasCut () const
{
  return m_cut_list.empty () == false;
}

void
DataRep::
throwRangeException ()
{
  string what ( "DataRep::setCutRange: index out of range." );
  throw std::out_of_range ( what );
}

void
DataRep::
setCutRangeAt ( const Range & range, unsigned int i )
{
  if ( i >= m_cut_list.size () ) throwRangeException ();

  m_cut_list[i].setRange ( range );
}

void
DataRep::
toggleInverted ( unsigned int i )
{
  if ( i >= m_cut_list.size () ) throwRangeException ();

  m_cut_list[i].toggleInverted ();
}

void
DataRep::
setEnabled ( unsigned int i, bool yes )
{
  if ( i >= m_cut_list.size () ) throwRangeException ();

  m_cut_list[i].setEnabled ( yes );
}

RepBase *
DataRep::
getCutRep ()
{
  return m_cut_rep;
}

void
DataRep::
setCutRep ( RepBase * rep )
{
  if ( m_cut_rep != 0 ) delete m_cut_rep;
  m_cut_rep = rep;
}

---