CutController.cxx

Go to the documentation of this file.

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

#include "CutController.h"

#include "DisplayController.h"
#include "DataRepController.h"
#include "FunctionController.h"

#include "datareps/DataRep.h"
#include "datareps/DataRepFactory.h"
#include "datasrcs/DataSource.h"
#include "datasrcs/TupleCut.h"

#include "graphics/ViewBase.h"

#include "plotters/PlotterBase.h"
#include "plotters/Cut1DPlotter.h"
#include "plotters/Cut2DPlotter.h"
#include "plotters/PlotterFactory.h"

#include "projectors/NTupleProjector.h"

#include <algorithm>
#include <stdexcept>
#include <utility>

#include <cassert>

using std::find;
using std::list;
using std::map;
using std::string;
using std::vector;
using std::make_pair;
using std::pair;

class TupleCut;

CutController * CutController::s_instance = 0;

CutController::CutController ( )
{
}

CutController * CutController::instance ( )
{
  if ( s_instance == 0 ) {
    s_instance = new CutController ( );
  }
  return s_instance;
}

Cut1DPlotter *
CutController::
addCut ( PlotterBase * plotter, const std::string & label )
{
  vector < string > bindings;
  bindings.push_back ( label );
  PlotterBase * cut = addCut ( plotter, bindings );

  return dynamic_cast < Cut1DPlotter * > ( cut );
}

PlotterBase *
CutController::
addCut( PlotterBase * plotter,  std::vector < std::string > & bindings )
{
  DisplayController * controller = DisplayController::instance ();
  const DataSource * source = controller->getNTuple ( plotter );

  PlotterBase * cut_plotter = createCut ( "", source, bindings );
  addCut ( cut_plotter, plotter );
  
  return cut_plotter;
}


void CutController::addCut ( PlotterBase * cut_plotter,
                             PlotterBase * plotter )
  
{
  // This part first adds a cut to the plotter. Then it goes ahead and
  // if the plotter itself is a cut plotter it adds cuts to its master
  // plot recursively.
  int index = plotter->activePlotIndex ();
  if ( index < 0 )
    {
      FunctionController * controller = FunctionController::instance ();
      index = controller->getUniqueNonFunctionIndex ( plotter );
    }
  if ( index < 0 ) return;

  DataRep * targetrep = plotter->getDataRep ( index );
  if ( targetrep -> hasNTupleBindings() == false ) 
    assert ( false );
  
  linkCutAndRep( cut_plotter, targetrep);
}


void CutController::linkCutAndRep( PlotterBase * cut_plotter,
                                   DataRep * targetrep )
{
  CutPlotter * plotter = dynamic_cast < CutPlotter * > ( cut_plotter );
  assert ( plotter != 0 );

  linkCutAndRep ( plotter, targetrep );
}
  
void
CutController::
linkCutAndRep( CutPlotter * cut_plotter,
               DataRep * targetrep )
{
  const vector < TupleCut > & cuts = cut_plotter -> getCuts ();
  assert ( cuts.empty () == false );

  ProjectorBase * projbase = targetrep->getProjector ();
  NTupleProjector * projector 
    = dynamic_cast < NTupleProjector * > ( projbase );
  assert ( projector );

  for ( unsigned int i = 0; i < cuts.size(); i++ ) {
    projector->addCut ( &cuts[i] );
  }
  
  // For now we add the cutdisplay as the observer of datarep to keep the
  // java part working correctly.
  cut_plotter->addCutTarget ( targetrep );
  targetrep->setDirty ();
}

PlotterBase * 
CutController::
createCut ( const std::string & ,
            const DataSource * ntuple,
            const std::vector < std::string > & bindings,
            const Color & color ) const
{
  std::string datarepname, plottername;
  int ndims =  bindings.size();
  
  if( ndims == 1 )
    {
      datarepname = "Histogram";     // 1 D DyHistogram (Dynamic Histogram)
      plottername = "Cut1DPlotter";  // 1 D cut plotter
    }
  else if( ndims == 2 )
    {
      datarepname = "Color Plot";    // 2 D couterpart of DyHistogram
      plottername = "Cut2DPlotter";  // 2 D cut plotter
    }
  
  DataRepController * controller = DataRepController::instance ();
  DataRep * rep = controller->createDataRep ( datarepname,
                                              ntuple,
                                              bindings );
  assert( rep != 0 );
  
  PlotterFactory * pfactory = PlotterFactory::instance ();
  PlotterBase * pbase = pfactory->create ( plottername );
  
  if( ndims == 1 )
    {
      Cut1DPlotter * c1dplotter = dynamic_cast < Cut1DPlotter * > ( pbase );
      assert( c1dplotter );
      
      c1dplotter->addDataRep ( rep );
      c1dplotter -> setNTuple ( ntuple );
      c1dplotter -> setAxisBinding ( "X", bindings[0] );
      c1dplotter -> setCutRangeFull ();
      c1dplotter -> setCutColor ( color );
          
      return c1dplotter;
    }
  else if( ndims == 2 )
    {
      Cut2DPlotter * c2dplotter = dynamic_cast < Cut2DPlotter * > ( pbase );
      assert( c2dplotter );
      
      c2dplotter -> addDataRep ( rep );
      c2dplotter -> setNTuple ( ntuple );
      c2dplotter -> setAxisBinding ( "X", bindings[0] );
      c2dplotter -> setAxisBinding ( "Y", bindings[1] );
      c2dplotter -> setCutRangeFull ();
      c2dplotter -> setCutColor ( color );
      
      return c2dplotter;
    }
  
  return 0;
}

void CutController::removeCut ( PlotterBase * cplotter, 
                                PlotterBase * plotter )
{
  CutPlotter * cut_plotter = dynamic_cast < CutPlotter * > ( cplotter );

  if ( cut_plotter != 0 ) {
    DataRep * rep = plotter -> selectedDataRep (); 

    if ( rep != 0 ) {
      cut_plotter -> removeFromTarget ( rep );
      setZoomPan ( cut_plotter, Axes::X, false );
    }
  }
}
void
CutController::
fillCutList ( const std::vector < PlotterBase * > & plotter_list,
              vector < CutPlotter * > & cut_list )
{
  cut_list.clear ();
  vector < PlotterBase * >::const_iterator first = plotter_list.begin();
  while ( first != plotter_list.end() ) {
    PlotterBase * plotter = *first++;
    CutPlotter * cutter = dynamic_cast < CutPlotter * > ( plotter );
    if ( cutter != 0 ) {
      cut_list.push_back ( cutter );
    }
  }
}

typedef Observable::ObserverList_t ObserverList_t;

const std::vector < const TupleCut * > &
CutController::
getCutList ( const DataRep * datarep ) const
{
  ProjectorBase * pbase = datarep -> getProjector ();
  NTupleProjector * projector = dynamic_cast < NTupleProjector * > ( pbase );

  if ( projector == 0 ) { // then can't have cuts
    string what ( "CutController::getCutList: ");
    what += "DataRep does not have NTupleProjector.";
    throw std::logic_error ( what );
  }

  return projector -> getCutList();
}

void
CutController::
fillCutList ( const DataRep * datarep,
              std::vector < PlotterBase * > & cut_list )
{
  cut_list.clear ();

  const ObserverList_t & objects = datarep -> getObservers ();
  ObserverList_t::const_iterator first = objects.begin();

  while ( first != objects.end() ) {
    const hippodraw::Observer * obj = *first++;
    const CutPlotter * plotter = dynamic_cast < const CutPlotter * > ( obj );
    if ( plotter != 0 ) {
      const DataRep * rep = plotter -> getDataRep ( 0 );
      if ( rep != datarep ) {
        CutPlotter * cp = const_cast < CutPlotter * > ( plotter );
        cut_list.push_back ( cp );
      }
    }
  }
}

void
CutController::
fillCutWeb ( const std::vector < PlotterBase * > & plotters,
             std::vector < PlotterBase * > & web )
{
  web.clear ();
  vector < PlotterBase * > ::const_iterator first = plotters.begin ();

  while ( first != plotters.end () ) {
    PlotterBase * plotter = *first++;
    appendToWeb ( plotter, web );
  }
}


void
CutController::
appendToWeb ( PlotterBase * plotter, PlotterList_t & web )
{
  PlotterList_t::iterator first = find ( web.begin (), web.end(),
                                         plotter );
  if ( first == web.end () ) {
    web.push_back ( plotter );
    int index = plotter -> activePlotIndex ();
    if ( index < 0 ) {
      web.clear ();
      return;
    }
    DataRep * rep = plotter -> getDataRep ( index );
    vector < PlotterBase * > cut_list;
    fillCutList ( rep, cut_list );
    if ( cut_list.empty () == false ) {
      appendToWeb ( cut_list, web );
    }
  }
}

void
CutController::
appendToWeb ( CutPlotter * cutter,
              PlotterList_t & web )
{
  PlotterList_t::iterator first = find ( web.begin(), web.end(),
                                         cutter );
  if ( first == web.end () ) {
    web.push_back ( cutter );
    // get the targets and make recurive call
    const list < DataRep * > & targets = cutter -> getCutTargets ();
    list < DataRep * > ::const_iterator it = targets.begin ();

    while ( it != targets.end () ) {
      DataRep * rep = *it++;
      PlotterBase * plotter = findPlotter ( rep );
      assert ( plotter );
      appendToWeb ( plotter, web );
    }
  }
}

void
CutController::
appendToWeb ( const std::vector < PlotterBase * > & cutters,
//            std::vector < PlotterBase * > & web )
              PlotterList_t & web )
{
  PlotterList_t::const_iterator first = cutters.begin ();
  while ( first != cutters.end () ) {
    PlotterBase * pb = *first++;
    CutPlotter * cutter = dynamic_cast < CutPlotter * > ( pb );
    appendToWeb ( cutter, web );
  }
}

PlotterBase *
CutController::
findPlotter ( const DataRep * datarep )
{
  const PlotterBase * plotter = 0;
  const ObserverList_t & objects = datarep -> getObservers ();
  ObserverList_t::const_iterator first = objects.begin();

  while ( first != objects.end () ) {
    const hippodraw::Observer * obj = *first++;
    const CutPlotter * cutter = dynamic_cast < const CutPlotter * > ( obj );
    if ( cutter != 0 ) {
      DataRep * plotter_rep = cutter -> getDataRep ( 0 );
      if ( plotter_rep == datarep ) {
        plotter = cutter;
        break;
      }
      continue; 
    }
    const XyPlotter * xyplotter = dynamic_cast < const XyPlotter * > ( obj );
    if ( xyplotter != 0 ) {
      plotter = xyplotter;
      break;
    }
  }

  return const_cast < PlotterBase * > ( plotter );
}

void 
CutController::
fillTupleCutList ( const std::vector < const ViewBase * > & views,
                   std::vector < const TupleCut * > & cut_list )
{
  cut_list.clear();

#ifdef ITERATOR_MEMBER_DEFECT
  std::
#endif
  vector < const ViewBase * >::const_iterator first = views.begin ();
  while ( first != views.end() ) {
    const ViewBase * view = *first++;
    PlotterBase * pbase = view->getPlotter ();
    Cut1DPlotter * plotter = dynamic_cast < Cut1DPlotter * > ( pbase );
    if ( plotter == 0 ) continue;

    const vector < TupleCut > & cuts = plotter -> getCuts ();
    for ( unsigned int i = 0; i < cuts.size(); i++ ) {
      cut_list.push_back ( &cuts[i] );
    }
  }
}

void 
CutController::
connectDataRep ( const std::list < ViewBase * > & targets,
                 const std::vector < const ViewBase * > & views )
{
#ifdef ITERATOR_MEMBER_DEFECT
  std::
#endif
  list < ViewBase * > :: const_iterator first = targets.begin ();
  while( first != targets.end () )
    {
      ViewBase * view = *first++;
      PlotterBase * plotter = view->getPlotter ();
      int number = plotter -> getNumDataReps ();

      for( int i = 0; i < number; i++ )
        {
          DataRep * rep = plotter->getDataRep ( i );
          
          if ( rep->hasNTupleBindings () == false )
            continue;
          
          connectDataRep ( rep, views );
        }
    }
}

void 
CutController::
connectDataRep( DataRep * rep, 
                const std::vector < const ViewBase * > & views )
{
  ProjectorBase * pbase = rep->getProjector ();
  NTupleProjector * projector = dynamic_cast < NTupleProjector * > ( pbase );

  if ( projector == 0 ) return; // no cuts possible.

  const vector < const TupleCut * > & cuts = projector->getCutList ();
  if ( cuts.empty() == true ) return;

#ifdef ITERATOR_MEMBER_DEFECT
  std::
#endif
    vector < const TupleCut * > ::const_iterator first = cuts.begin ();
  while ( first != cuts.end() ) {
    const TupleCut * cut = *first++;
    connectDataRep ( cut, rep, views );
  }
}

void 
CutController::
connectDataRep ( const TupleCut * cut, 
                 DataRep * rep,
                 const std::vector < const ViewBase * > & views )
{
#ifdef ITERATOR_MEMBER_DEFECT
  std::
#endif
    vector < const ViewBase * >::const_iterator first = views.begin();
  while ( first != views.end() )
    {
      const ViewBase * view = *first++;
      PlotterBase * pbase = view->getPlotter ();
      
      Cut1DPlotter * plotter = dynamic_cast < Cut1DPlotter * > ( pbase );
      if ( plotter == 0 ) continue;
      
      const vector < TupleCut > & cuts = plotter -> getCuts ();
      for ( unsigned int i = 0; i < cuts.size(); i++ ) {
        if ( &cuts[i] == cut ) {
          plotter->addCutTarget ( rep );
        }
      }
    }
}

const vector < PlotterBase * > &
CutController::
getCutList ( const std::vector < PlotterBase * > & plotters,
             const DataSource * ntuple ) const
{
  DisplayController * dc = DisplayController::instance ();

  m_cut_list.clear ();
  std::vector < PlotterBase * >::const_iterator it = plotters.begin();

  for ( ; it != plotters.end(); ++it )
    {
      PlotterBase * plotter = *it;
      CutPlotter * cut_plotter = dynamic_cast < CutPlotter * > ( plotter );

      if ( cut_plotter != 0 ) {
        const DataSource * cut_tuple = dc ->getNTuple ( cut_plotter );
        if ( cut_tuple == ntuple ) {
          m_cut_list.push_back ( cut_plotter );
        }
      }
    }
  
  return m_cut_list;
}

void CutController::setAxisBinding ( PlotterBase * plotter,
                                     const std::string & axis,
                                     const std::string & label )
{
  CutPlotter * cut_plotter = dynamic_cast < CutPlotter * > ( plotter );

  if ( cut_plotter != 0 ) {
    cut_plotter -> setAxisBinding ( axis, label );
  }
}

void
CutController::
setZoomPan ( PlotterBase * cut_plotter,
             hippodraw::Axes::Type axis,
             bool yes )
{
  if ( yes ) 
    m_zoom_pan.push_back ( make_pair( cut_plotter, axis ) );
  else  // no
    m_zoom_pan.remove ( make_pair( cut_plotter, axis ) );
}

bool
CutController::
isZoomPan ( const PlotterBase * cut_plotter,
            hippodraw::Axes::Type axis ) const
{
  bool found = false;
  
  list< pair< PlotterBase *, Axes::Type > >::const_iterator iter; 
    
  for( iter = m_zoom_pan.begin(); iter != m_zoom_pan.end(); iter++ )
    if( iter -> first  == cut_plotter && iter -> second == axis )
      found = true;
  
  return found;
}

---