library: libGraf #include "TCutG.h"

# TCutG

class description - source file - inheritance tree (.pdf)

## class TCutG : public TGraph

| Inheritance Chart:
`TObject`
| <- | `TNamed`
`TAttLine`
`TAttFill`
`TAttMarker`
| <- | `TGraph`
| <- | `TCutG` |

        public:

                          TCutG()
                          TCutG(const TCutG& cutg)
                          TCutG(const char* name, Int_t n)
                          TCutG(const char* name, Int_t n, const Float_t* x, const Float_t* y)
                          TCutG(const char* name, Int_t n, const Double_t* x, const Double_t* y)
                  virtual ~TCutG()
           static TClass* Class()
                 TObject* GetObjectX() const
                 TObject* GetObjectY() const
              const char* GetVarX() const
              const char* GetVarY() const
                 Double_t Integral(TH2* h, Option_t* option = "") const
          virtual TClass* IsA() const
            virtual Int_t IsInside(Double_t x, Double_t y) const
                   TCutG& operator=(const TCutG&)
             virtual void SavePrimitive(ofstream& out, Option_t* option)
             virtual void SetObjectX(TObject* obj)
             virtual void SetObjectY(TObject* obj)
             virtual void SetVarX(const char* varx)
             virtual void SetVarY(const char* vary)
             virtual void ShowMembers(TMemberInspector& insp, char* parent)
             virtual void Streamer(TBuffer& b)
                     void StreamerNVirtual(TBuffer& b)

### Data Members

        protected:

           TString fVarX     X variable
           TString fVarY     Y variable
          TObject* fObjectX  !pointer to an object corresponding to X
          TObject* fObjectY  !pointer to an object corresponding to Y

## Class Description

     TCutG

      A Graphical cut.
      A TCutG object defines a closed polygon in a x,y plot.
      It can be created via the graphics editor option "CutG"
      or directly by invoking its constructor.
      To create a TCutG via the graphics editor, use the left button
      to select the points building the contour of the cut. Click on
      the right button to close the TCutG.
      When it is created via the graphics editor, the TCutG object
      is named "CUTG". It is recommended to immediatly change the name
      by using the context menu item "SetName".                           //
       When the graphics editor is used, the names of the variables X,Y
       are automatically taken from the current pad title.
      Example:
      Assume a TTree object T and:
         Root > T.Draw("abs(fMomemtum)%fEtot")
      the TCutG members fVarX, fVary will be set to:
         fVarx = fEtot
         fVary = abs(fMomemtum)

      A graphical cut can be used in a TTree selection expression:
        Root > T.Draw("fEtot","cutg1")
        where "cutg1" is the name of an existing graphical cut.

      Note that, as shown in the example above, a graphical cut may be
      used in a selection expression when drawing TTrees expressions
      of 1-d, 2-d or 3-dimensions.
      The expressions used in TTree::Draw can reference the variables
      in the fVarX, fVarY of the graphical cut plus other variables.

      When the TCutG object is created, it is added to the list of special
      objects in the main TROOT object pointed by gROOT. To retrieve a
      pointer to this object from the code or command line, do:
          TCutG *mycutg;
          mycutg = (TCutG*)gROOT->GetListOfSpecials()->FindObject("CUTG")
          mycutg->SetName("mycutg");

      Example of use of a TCutG in TTree::Draw:
           tree.Draw("x:y","mycutg && z>0 %% sqrt(x)>1")

      A Graphical cut may be drawn via TGraph::Draw.
      It can be edited like a normal TGraph.

      A Graphical cut may be saved to a file via TCutG::Write.            //

TCutG() : TGraph()

TCutG(const TCutG &cutg) :TGraph(cutg)

     TCutG copy constructor

TCutG(const char *name, Int_t n) :TGraph(n)

TCutG(const char *name, Int_t n, const Float_t *x, const Float_t *y) :TGraph(n,x,y)

TCutG(const char *name, Int_t n, const Double_t *x, const Double_t *y) :TGraph(n,x,y)

~TCutG()

Double_t Integral(TH2 *h, Option_t *option) const

     Compute the integral of 2-d histogram h for all bins inside the cut
     if option "width" is specified, the integral is the sum of
     the bin contents multiplied by the bin width in x and in y.

Int_t IsInside(Double_t x, Double_t y) const

    *.         Function which returns 1 if point x,y lies inside the
    *.              polygon defined by the graph points
    *.                                0 otherwise
    *.
    *.     The loop is executed with the end-point coordinates of a
    *.     line segment (X1,Y1)-(X2,Y2) and the Y-coordinate of a
    *.     horizontal line.
    *.     The counter inter is incremented if the line (X1,Y1)-(X2,Y2)
    *.     intersects the horizontal line.
    *.     In this case XINT is set to the X-coordinate of the
    *.     intersection point.
    *.     If inter is an odd number, then the point x,y is within
    *.     the polygon.
    *.
    *.         This routine is based on an original algorithm
    *.         developed by R.Nierhaus.
    *.

void SavePrimitive(ofstream &out, Option_t *option)

     Save primitive as a C++ statement(s) on output stream out

void SetVarX(const char *varx)

void SetVarY(const char *vary)

void Streamer(TBuffer &R__b)

     Stream an object of class TCutG.

### Inline Functions

               TObject* GetObjectX() const
               TObject* GetObjectY() const
            const char* GetVarX() const
            const char* GetVarY() const
                   void SetObjectX(TObject* obj)
                   void SetObjectY(TObject* obj)
                TClass* Class()
                TClass* IsA() const
                   void ShowMembers(TMemberInspector& insp, char* parent)
                   void StreamerNVirtual(TBuffer& b)
                 TCutG& operator=(const TCutG&)

Author: Rene Brun 16/05/97
Last update: root/graf:$Name: $:$Id: TCutG.cxx,v 1.16 2004/06/26 13:38:57 brun Exp $
Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *