CPyPlot.hpp

Go to the documentation of this file.

/* -*- c++ -*- */

#ifndef __CPYPLOT_HPP__
#define __CPYPLOT_HPP__

#include <Python.h>

#include <string>
using std::string;

#include <QWidget>
#include <QObject>

#include "Matrix.h"
#include "Cvals.h"

class QMdiSubWindow;

struct limit_data
{
  Cvals * limitType; 
  double  limitMin;  
  double  limitMax;  
};


//______________________________________________________________________________
class plotData
{
public:
  plotData();

  int plotType;                  
  double xmin;
  double xmax;
  double ymin;
  double ymax;
  std::string xname;
  std::string yname;
  std::string binname;
  std::string limitName;
  int nx;
  int ny;
  int type;
  int gridmethod;
  int pointSize;
  double limMin;
  double limMax;
  int run;
  int file;
}; // class plot_data

//______________________________________________________________________________
class CPyPlot : public QWidget
{
  Q_OBJECT

public:
  CPyPlot(QWidget * parent, string xname = "x", string yname = "y", 
          int type = 0);
  virtual ~CPyPlot();

  enum plotTypes  
    {
      PLOT_SCATTER,
      PLOT_GRID,
      PLOT_RENDER,
      PLOT_PARTDATA
    };

  static void createNewPlot(const plotData & pd);

  virtual void calculate(Matrix<float> * thedata = 0);
  void plot();

  void addLimitingValue(Cvals * limitType, double limMin, double limMax);

  void printArguments();

  void   setRun(int run);
  void   setFile(int file);
  int    getRun() const;
  int    getFile() const;
  int    getType() const;

  virtual string getWindowTitle();
  int    getNumPlots() const;
  string getXname() const;
  string getYname() const;
  
  void setXLimits(const double & xmin, const double & xmax);
  void setYLimits(const double & ymin, const double & ymax);
  void setLimits(const double & xmin, const double & xmax, 
                 const double & ymin, const double & ynax);

  double getXmin() const;
  double getXmax() const;
  double getYmin() const;
  double getYmax() const;
  void   xLimits(double & xmin, double & xmax);
  void   yLimits(double & ymin, double & ymax);
  void   limits(double & xmin, double & xmax, double & ymin, double & ymax);
  void   setNParticles(const int & npart);
  int    getNParticles() const;

  string getPlotType() const;
  static CPyPlot * getPlotPtr(const int & num);
  
  void emitsignal();

signals:
  void testsignal();

protected:
  virtual bool do_plotting();

  static void importArray();

  void addArgument(const string & name, const int     & value);
  void addArgument(const string & name, const double  & value);
  void addArgument(const string & name, const string  & value);
  void addArgument(const string & name, PyObject * ref);

  PyObject * getDict() const;
  void       setPlotType(string type);

  void resizeEvent(QResizeEvent * revent);

  int type_;                
  bool calculated_;

  string plotType_;         
  QWidget * pyWidget_;      
  QMdiSubWindow * mdiWin_;  
private:
  static int numPlots_;
  static vector<CPyPlot *> plots_;
  static bool _arraysImported;

  vector<struct limit_data> limitData; 
  int run_;                 
  int file_;                
  int number_;              
  int _nparticles;          
  string xname_;
  string yname_;

  double xmin_;
  double xmax_;
  double ymin_;
  double ymax_;

  PyObject * argDict_;   
};


/*------------------------------------------------------------------------------
 * CPyColorPlot
 *------------------------------------------------------------------------------*/

//______________________________________________________________________________
class CPyColorPlot : public CPyPlot
{
public:
  CPyColorPlot(string xname = "x", string yname = "y", 
               string binname = "mass", 
               int nx = 10, int ny = 10, int type = 0,
               int igridmethod = 1,
               QWidget * myparent = 0);
  ~CPyColorPlot();

  void calculate(Matrix<float> * thedata = 0);
  bool do_plotting();

  Matrix<float> * getDataPtr() const;
  PyObject *      getPyDataPtr() const;

  string getBinname() const;
  int    getNx() const;
  int    getNy() const;
  //double getSvenLow() const  { return svenLow_; };
  //double getSvenHigh() const { return svenHigh_; };

  void   setNxNy(int nx, int ny);
  //void   setSvenRange(double low, double high) {svenLow_ = low; svenHigh_ = high;};

private:
  Matrix<float> * data_;
  int dims_[2];           
  PyObject * pyData_;     
  string binname_;

  int nx_;
  int ny_;

  int igridmethod_;       
  //double svenLow_;        /*!< lower bound for the Sven plots */
  //double svenHigh_;       /*!< upper bound for the Sven plots*/
};


/*------------------------------------------------------------------------------
 * CPyScatterPlot
 *------------------------------------------------------------------------------*/

//______________________________________________________________________________
class CPyScatterPlot : public CPyPlot
{
public:
  CPyScatterPlot(string xname = "x", string yname = "y", int type = 0,
                 QWidget * myparent = 0);
  ~CPyScatterPlot();

  void calculate(Matrix<float> * thedata = 0);

  bool do_plotting();

  double getLimMin() const;
  double getLimMax() const;
  
  string getLimitName() const;
  int    getNumPoints() const;

  void   setLimitName(string name);
  void   setLimitRange(double low, double high);
  
  PyObject * getXDataPtr() const;
  PyObject * getYDataPtr() const;

private:
  int type_;              
  int numPoints_;

  int pointSize_;         
  string limName_;        
  double limMin_;
  double limMax_;

  Matrix<float> * data_;
  PyObject * pyXData_;
  PyObject * pyYData_;
};

#endif // __CPYPLOT_HPP__

---