PyDataRep.cxx

Go to the documentation of this file.

// for dll interface warning
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif

#include "PyDataRep.h"
#include "PyDataSource.h"
#include "QtCut.h"

#include "controllers/DisplayController.h"
#include "controllers/DataRepController.h"
#include "controllers/CutController.h"
#include "projectors/ProjectorBase.h"
#include "reps/RepBase.h"
#include "datasrcs/DataSourceException.h"
#include "datareps/DyHistogram.h"
#include "datasrcs/NTuple.h"
#include "plotters/Cut1DPlotter.h"

// with Python 2.3, include before qapplication.h to avoid conflict
// with symbol `slots'
#include <boost/python.hpp>

#include <qapplication.h>

#include <sstream>

using namespace hippodraw;

using std::string;

using namespace boost::python;

namespace hippodraw {
namespace Python {

void
export_DataRep()
{
  class_ < PyDataRep > ( "DataRep" )

     .def ( init < const std::string &,
            const DataSource *,
            const std::vector< std::string > & > () )

     .def ( init < const std::string &,
            const PyDataSource *,
            const std::vector< std::string > & > () )

     .def ( init < PyDataRep * > () )

     .def ( "setPointRep", &PyDataRep::setPointRep,
            "Sets the point representation." )

     .def ( "setAxisBinding", &PyDataRep::setAxisBinding,
            "Sets an axis binding." )

     .def ( "setAxisBindings", &PyDataRep::setAxisBindings,
            "Sets all the axes bindings." )

     .def ( "setWeight", &PyDataRep::setWeight,
            "Sets the weight option if DataRep is a type of histogram." )

     .def ( "name", &PyDataRep::name,
            return_value_policy < copy_const_reference > (),
            "Returns the name of type of DataRep." )

     .def ( "getBinWidth", &PyDataRep::getBinWidth,
            "Returns the bin width if DataRep is histogramming type." )

     .def ( "getMean", &PyDataRep::getMean,
           args ( "axis" ),
           "Returns the mean of the data along axis"  )

     .def ( "getRMS", &PyDataRep::getRMS,
           args( "axis" ),
           "Returns root mean squared of data along axis" )

     .def ( "numberOfEntries", &PyDataRep::numberOfEntries,
            "Returns the number of entries." )

     .def ( "applyCut", &PyDataRep::applyCut,
            "Applies a Cut." )

     .def ( "setColor", &PyDataRep::setColor,
            "Sets the color." )

     .def ( "setErrorDisplay", &PyDataRep::setErrorDisplay,
            "Turns on or off display of error bars." )

     .def ( "createNTuple", &PyDataRep::createNTuple,
            return_value_policy < manage_new_object > (),
            "Returns an NTuple representation of the DataRep." )

     .def ( "getNTupleWithCuts", &PyDataRep::getNTupleWithCuts,
            return_value_policy < manage_new_object > (),
            "Returns to NTuple being used, with cuts applied." )

     .def ( "setSymbol", &PyDataRep::setSymbol,
            "Sets the point symbol and size." )

     .def ( "setLineStyle", &PyDataRep::setLineStyle,
            "Sets the line style." )

    .def ( "normalizeTo", &PyDataRep::normalizeTo,
           "Sets the data rep to normalize itself to a target one" )

    .def ( "setBinWidth", &PyDataRep::setBinWidth,
           "Sets the width of the bins, if data representation is binned.\n"
           "Arguments:\n"
           "\t axis (string)\n"
           "\t width" )

    ;
}

} // namespace Python
} // namespace hippodraw

std::map< std::string, std::vector<int> > PyDataRep::s_colorMap;
std::map< std::string, hippodraw::Symbol::Type > PyDataRep::s_symbols;
std::map< std::string, hippodraw::Line::Style > PyDataRep::s_lineStyles;
bool PyDataRep::s_have_static_members(false);

PyDataRep::PyDataRep ( DataRep * rep ) 
{
   m_datarep = rep;
   init();
}

PyDataRep::PyDataRep ( const std::string & type,
                       const DataSource * ntuple,
                       const std::vector< std::string > & bindings )
{
   DataRepController * controller = DataRepController::instance ();
   m_datarep = controller->createDataRep ( type, ntuple, bindings );
   init();
}

PyDataRep::PyDataRep ( const std::string & type,
                       const PyDataSource * nt,
                       const std::vector< std::string > & bindings )
{
   DataRepController * controller = DataRepController::instance ();
   m_datarep = controller->createDataRep ( type, &(nt->dataSource()),
                                           bindings );
   init();
}

PyDataRep::PyDataRep ()
{
  m_datarep = 0;
  init();
}

PyDataRep::PyDataRep( PyDataRep * pyRep )
{
   m_datarep = pyRep->getDataRep()->clone();
}   

DataRep * PyDataRep::getDataRep()
{
  return m_datarep;
}

void PyDataRep::setPointRep ( RepBase * pointRep )
{
   if (qApp) qApp->lock();
   m_datarep->setRepresentation( pointRep );
   if (qApp) qApp->unlock();
}

void PyDataRep::setAxisBinding ( const std::string & axis,
                                 const std::string & label )
{
   if (qApp) qApp->lock();
   try {
     m_datarep->setAxisBinding ( axis, label );
   }
   catch ( DataSourceException & e ) {
     if (qApp) qApp->unlock();
     throw e;
   }
   if (qApp) qApp->unlock();
}

void PyDataRep::setAxisBindings ( const std::vector< std::string > & bindings)
{
   if (qApp) qApp->lock();
   try {
     m_datarep->setAxisBindings ( bindings );
   }
   catch ( DataSourceException & e ) {
     if (qApp) qApp->unlock();
     throw e;
   }
   if (qApp) qApp->unlock();
}

void PyDataRep::setWeight ( const std::string &label )
{
   if (qApp) qApp->lock();
   if ( m_datarep->name() == "Histogram" 
        || m_datarep->name() == "Color Plot"
        || m_datarep->name() == "Contour Plot") {
      m_datarep->setAxisBinding( std::string("Weight (optional)"),
                                 label );
   } else {
      // do nothing
   }
   if (qApp) qApp->unlock();
}

const std::string & PyDataRep::name () const 
{
   return m_datarep->name();
}

double PyDataRep::getBinWidth ( const std::string &axis )
{
   if (qApp) qApp->lock();
   Axes::Type at = Axes::convert ( axis );
   ProjectorBase * projector = m_datarep->getProjector ();
   if (qApp) qApp->unlock();
   return projector->getBinWidth ( at );
}

double
PyDataRep::
getMean ( const std::string & axis )
{
  if (qApp) qApp->lock();
  double mean = m_datarep -> getMean ( axis );
  if (qApp) qApp->unlock();

  return mean;
}

double
PyDataRep::
getRMS ( const std::string & axis )
{
  if (qApp) qApp->lock();
  double rms = m_datarep -> getRMS ( axis );
  if (qApp) qApp->unlock();

  return rms;
}

double PyDataRep::numberOfEntries() const 
{
   ProjectorBase * projector = m_datarep->getProjector();
   return projector -> getNumberOfEntries();
}

void PyDataRep::applyCut ( QtCut * cut )
{
   if (qApp) qApp->lock();
   CutController * controller = CutController::instance();
   controller -> linkCutAndRep( cut -> display(), m_datarep );
   if (qApp) qApp->unlock();
}

void PyDataRep::setColor ( const std::string & color )
{
   if (qApp) qApp->lock();
   if ( s_colorMap.count( color ) ) {
      Color colorObj( s_colorMap[color][0], 
                      s_colorMap[color][1], 
                      s_colorMap[color][2] );
      m_datarep -> setRepColor ( colorObj );
   } else {
      if (qApp) qApp->unlock();
      const std::string 
         what ( "PyDataRep::setColor: color not available.");
      throw DataSourceException( what );
   }
   if (qApp) qApp->unlock();
}

void PyDataRep::setErrorDisplay( const std::string &axis, bool flag )
{
   if (qApp) qApp->lock();

   Axes::Type at = Axes::convert ( axis );   
   m_datarep->setErrorDisplay( at, flag );

   if (qApp) qApp->unlock();
}

const NTuple * 
PyDataRep::
createNTuple () const
{
   if (qApp) qApp->lock();
   const NTuple * ntuple = m_datarep -> createNTuple ();
   if (qApp) qApp->unlock();

   return ntuple;
}

NTuple * PyDataRep::getNTupleWithCuts () const {
   if (qApp) qApp->lock();
   NTuple * ntuple = m_datarep->getNTupleAfterCuts();
   if (qApp) qApp->unlock();

   return ntuple;
}

void PyDataRep::makeColorMap() {

   int black[] = {0, 0, 0};
   s_colorMap["black"] = std::vector<int>(black, black+3);

   int red[] = {255, 0, 0};
   s_colorMap["red"] = std::vector<int>(red, red+3);

   int green[] = {0, 255, 0};
   s_colorMap["green"] = std::vector<int>(green, green+3);

   int blue[] = {0, 0, 255};
   s_colorMap["blue"] = std::vector<int>(blue, blue+3);

   int yellow[] = {255, 255, 0};
   s_colorMap["yellow"] = std::vector<int>(yellow, yellow+3);
   
   int cyan[] = {0, 255, 255};
   s_colorMap["cyan"] = std::vector<int>(cyan, cyan+3);
   
   int magenta[] = {255, 0, 255};
   s_colorMap["magenta"] = std::vector<int>(magenta, magenta+3);
}

void PyDataRep::makeSymbolMap() {
   s_symbols["square"] = hippodraw::Symbol::SQUARE;
   s_symbols["filled_square"] = hippodraw::Symbol::SOLIDSQUARE;
   s_symbols["plus"] = hippodraw::Symbol::PLUS;
   s_symbols["times"] = hippodraw::Symbol::TIMES;
   s_symbols["triangle"] = hippodraw::Symbol::TRIANGLE;
   s_symbols["filled_triangle"] = hippodraw::Symbol::FILLED_TRIANGLE;
   s_symbols["circle"] = hippodraw::Symbol::CIRCLE;
   s_symbols["filled_circle"] = hippodraw::Symbol::FILLED_CIRCLE;
}

void PyDataRep::setSymbol( const std::string &symbolName, float size) {
   if (qApp) qApp->lock();
   if ( s_symbols.count( symbolName ) ) {
      m_datarep -> setRepStyle ( s_symbols[symbolName] );
      m_datarep -> setRepSize ( size );
   } else {
      if (qApp) qApp->unlock();
      std::ostringstream what;
      what << "PyDataRep::setSymbol: symbol " 
           << symbolName << " is not available.\n"
           << "Valid symbol names:\n";
      std::map< std::string, hippodraw::Symbol::Type >
         ::const_iterator it = s_symbols.begin();
      for ( ; it != s_symbols.end(); it++) {
         what << "  " << it->first << "\n";
      }
      throw DataSourceException( what.str() );
   }
   if (qApp) qApp->unlock();
}

void PyDataRep::makeLineStyleMap() {
   s_lineStyles["Solid"] = hippodraw::Line::Solid;
   s_lineStyles["Dash"] = hippodraw::Line::Dash;
   s_lineStyles["Dot"] = hippodraw::Line::Dot;
   s_lineStyles["DashDot"] = hippodraw::Line::DashDot;
   s_lineStyles["DashDotDot"] = hippodraw::Line::DashDotDot;
   s_lineStyles["Invisible"] = hippodraw::Line::Invisible;
}

void PyDataRep::setLineStyle( const std::string &lineStyleName ) {
   if (qApp) qApp->lock();
   if ( s_lineStyles.count( lineStyleName ) ) {
      m_datarep->setRepStyle( s_lineStyles[lineStyleName] );
   } else {
      if (qApp) qApp->unlock();
      std::ostringstream what;
      what << "PyDataRep::setLineStyle: lineStyle " 
           << lineStyleName << " is not available.\n"
           << "Valid lineStyle names:\n";
      std::map< std::string, hippodraw::Line::Style >
         ::const_iterator it = s_lineStyles.begin();
      for ( ; it != s_lineStyles.end(); it++) {
         what << "  " << it->first << "\n";
      }
      throw DataSourceException( what.str() );
   }
   if (qApp) qApp->unlock();
}

void PyDataRep::init() {
   if (!s_have_static_members) {
      makeColorMap();
      makeSymbolMap();
      makeLineStyleMap();

      s_have_static_members = true;
   }
}

void
PyDataRep::
normalizeTo ( const PyDataRep * rep )
{
  if (qApp) qApp->lock();
  const DataRep * datarep = rep -> m_datarep;
  m_datarep -> normalizeTo ( datarep );
  if (qApp) qApp->unlock();
}

void
PyDataRep::
setBinWidth ( const std::string & axis, double width )
{
  if (qApp) qApp->lock();

  Axes::Type type = Axes::convert ( axis );
  DisplayController * controller = DisplayController::instance ();
  controller -> setBinWidth ( m_datarep, type, width );
  if (qApp) qApp->unlock();
}

---