GETActarTpcAnalyser.hh

Go to the documentation of this file.

//======================================================================
/*! \file GETActarTpcAnalyser.hh
 *
 *  Header file for the GETActarTpcAnalyser class.
 */
//======================================================================

#ifndef GET_ACTAR_TPC_ANALYSER_HH
#define GET_ACTAR_TPC_ANALYSER_HH

// includes from current library
#include "GETActarTpc.hh"
#include "GETSystemAnalyser.hh"


//======================================================================
/*! \class GETActarTpcAnalyser
 *
 *  This class is a specialized analyser class (derived from GETSystemAnalyser)
 *  for GETActarTpc (derived from GETSystem).
 *
 *  The analysis available in addition to the ones of the base class are:
 *
 *  - single events analysis:
 *    - automatic histograms on events data:
 *      pads signal histograms (amplitude and time of the maximum
 *      channel signal)
 *    - OFF-track signal analysis (and optionally corresponding histograms
 *      if the functions to create these histograms have been called)
 *
 *  \section get_analyser_off_track Off-track signal analysis
 *
 *  The off-track signal analysis and correction has been developped in
 *  order to evaluate the mesh-induced signal on pads that are not
 *  supposed to collect charges, but that see a mirror signal from the
 *  charges on the mesh.
 *
 *  A copy of the pads mask is created to define pads around the real
 *  track.
 *  The signal from these pads in averaged to build the <B>off-track signal</B>,
 *  that is removed from all signal channels if the correction is set on
 *  (the off-track analysis can be set, without correction channels output).
 *
 *  \image html GETOffTrackAnalysisR.png
 *  The picture above shows a track from an event of the ACTAR TPC demonstrator.
 *  The top-left figure is the signal amplitude on the pads, that is used
 *  to determine the hit mask (in-track pads of bottom-left) picture and
 *  the pads that are used to compute off-track signal (off-track pads).
 *  The off track signal (bottom-right picture) can be compared to the
 *  average effective signal, by inversion and scaling (up-right picture).
 *
 */
class GETActarTpcAnalyser : public GETSystemAnalyser
{
  //------------------------------------------------------------
  /*! \object_doc */
  GObject(GETActarTpcAnalyser);
  //------------------------------------------------------------

  protected:
    GETActarTpc   * actar_ptr;      ///< Pointer to the GETActarTpc object (which is the GETSystem pointer of the base classe)

    //  - pad display of events
    TH2D          * h_xy_hits;        ///< Histogram with pads hits
    TH2D          * h_xy_time;        ///< Histogram with pads event time
    TH2D          * h_xy_ampl;        ///< Histogram with pads event amplitude
    TH2D          * h_xt_ampl;        ///< Histogram with pads event amplitude
    TH2D          * h_yt_ampl;        ///< Histogram with pads event amplitude
    TH3D          * h_xyt;            ///< Histogram with 2D signal with third T dimension
    TH1D          * h_x_proj;         ///< Histogram with pads event amplitude
    TH1D          * h_y_proj;         ///< Histogram with pads event amplitude
    TH1D          * h_t_proj;         ///< Histogram with pads event amplitude

    GETHitMaskXY  * pad_mask;         ///< Pointer to the hit mask (same as base class hit mask, but known as GETHitMaskXY)

    // variables to noise analysis
    TH2D          * h_xy_rms;         ///< Pointer to the pads RMS histogram

    // variables related to undershoot analysis
    bool            off_track_on;     ///< Whether off-track analysis is ON
    bool            off_track_cor;    ///< Whether to apply off-track correction to channels output signal
    int             off_space;        ///< Pads separation between track and off-track pads
    GETHitMaskXY    off_mask;         ///< Mask for X-Y off-track analysis
    GETSample       sum_in_track;     ///< Sample with the sum of hit pads
    GETSample       sum_off_track;    ///< Sample with the sum of pads out of track
    TH1D          * h_mean_in_track;  ///< Histogram with summed signals of track pads
    TH1D          * h_mean_off_track; ///< Histogram with summed signals of off-track pads
    TH2D          * h_mask_in;        ///< Pad histogram with track pattern
    TH2D          * h_mask_off;       ///< Pad histogram with off-track pattern

 public:
  //----------------------------------------------------------
  /** @name Constructors, affectation, destructor */
  //@{
    GETActarTpcAnalyser ( GETActarTpc * get = NULL );
    virtual ~GETActarTpcAnalyser ( );
  //@}

  //----------------------------------------------------------
  /** @name General functions */
  //@{
    virtual void  Reset ( );
    virtual int   SetSystem ( GETSystem * gptr );
  //@}

  //----------------------------------------------------------
  /** @name Main analysis functions, called by GETSystem */
  //@{
    virtual void  ClearAnalysis ( );

    virtual void  ClearEvent ( );
    virtual int   AnalyseRawEvent ( );
    virtual int   AnalyseCorEvent ( );
  //@}

  //----------------------------------------------------------
  /** @name Predefined analysis configuration files */
  //@{
    virtual bool  ConfigCommand  ( const GString & code, const GString & args = "", FILE * fptr = NULL );
  //@}

  //----------------------------------------------------------
  /** @name Pads signal automatic histograms */
  //@{
    virtual double  ComputeSumInt ( bool mask = true );
    virtual double  ComputeSumMax ( bool mask = true );

    TH2D  * CreateXYtimeHisto      ( const string & name = "GET_XY_Time" );      // inline
    TH2D  * CreateXYhitsHisto      ( const string & name = "GET_XY_Hits" );      // inline
    TH2D  * CreateXYamplitudeHisto ( const string & name = "GET_XY_Amplitude" ); // inline
    TH2D  * CreateXTamplitudeHisto ( const string & name = "GET_XT_Amplitude" ); // inline
    TH2D  * CreateYTamplitudeHisto ( const string & name = "GET_YT_Amplitude" ); // inline
    TH3D  * CreateXYTHisto         ( const string & name = "GET_XYT", int nt = 512, double t0 = 0., double t1 = 512. );      // inline
    TH1D  * CreateXprojectionHisto ( const string & name = "GET_X_Projection" ); // inline
    TH1D  * CreateYprojectionHisto ( const string & name = "GET_Y_Projection" ); // inline
    TH1D  * CreateTprojectionHisto ( const string & name = "GET_T_Projection" ); // inline

    TH2D  * GetXYhitsHisto      ( ) const;   // inline
    TH2D  * GetXYtimeHisto      ( ) const;   // inline
    TH2D  * GetXYamplitudeHisto ( ) const;   // inline
    TH2D  * GetXTamplitudeHisto ( ) const;   // inline
    TH2D  * GetYTamplitudeHisto ( ) const;   // inline
    TH3D  * GetXYTHisto         ( ) const;   // inline
    TH1D  * GetXprojectionHisto ( ) const;   // inline
    TH1D  * GetYprojectionHisto ( ) const;   // inline
    TH1D  * GetTprojectionHisto ( ) const;   // inline
  //@}

  //----------------------------------------------------------
  /** @name Noise analysis (redefined from GETSystemAnalyser) */
  //@{
    virtual void    SetNoiseRange ( u_int i0 = 2, u_int i1 = 509 );
    TH2D          * GetChannelsNoiseHistoXY ( ) const;  // inline

    virtual int     ProcessNoiseAnalysis ( );
  //@}

  //----------------------------------------------------------
  /** @name Off-track signal analysis */
  //@{
    virtual void        SetOffTrackCorrection ( int spc = 1 );
    virtual void        InitOffTrackAnalysis ( int spc = 1 );
    bool                IsOffTrackAnalysisON   ( ) const;     // inline
    bool                IsOffTrackCorrectionON ( ) const;     // inline
    virtual const GETHitMaskXY  & GetOffTrackMask ( ) const;  // inline
    virtual       GETHitMaskXY  & GetOffTrackMask ( );        // inline

    // the histograms are not created automatically
    TH1D *              CreateInTrackMeanHisto  ( const string & hname = "MeanInTrackSignal" );
    TH1D *              CreateOffTrackMeanHisto ( const string & hname = "MeanOffTrackSignal" );
    TH2D *              CreateInTrackPatternHisto  ( const string & hname = "PatternInTrack" );
    TH2D *              CreateOffTrackPatternHisto ( const string & hname = "PatternOffTrack" );

    virtual int   ProcessOffTrackAnalysis ( );
    virtual int   ApplyOffTrackCorrection ( );
    virtual int   GetOffTrackPadsCount    ( ) const;  // inline

    GETSample &   GetInTrackMeanSample    ( );        // inline
    GETSample &   GetOffTrackMeanSample   ( );        // inline
    TH1D *        GetInTrackMeanHisto     ( );        // inline
    TH1D *        GetOffTrackMeanHisto    ( );        // inline
    TH2D *        GetInTrackPatternHisto  ( );        // inline
    TH2D *        GetOffTrackPatternHisto ( );        // inline
  //@}

  //----------------------------------------------------------
  /** @name Pads signal histograms general functions */
  //@{
    TH2D  * CreatePadHistogram ( const string & name );
    TH3D  * CreateHistogram3D  ( const string & name, int nt, double t0, double t1 );
    TH2D  * CreateHistogramXT  ( const string & name, int nt, double t0, double t1 );
    TH2D  * CreateHistogramYT  ( const string & name, int nt, double t0, double t1 );
    TH2D  * CreateHistogramXT  ( const string & name );
    TH2D  * CreateHistogramYT  ( const string & name );
    TH1D  * CreateHistogramX   ( const string & name );
    TH1D  * CreateHistogramY   ( const string & name );
    TH1D  * CreateHistogramT   ( const string & name );

    int     FillPadHistogram    ( TH2 * hptr, u_short mode = GET::dataMaxSignal );
    int     FillHistogram3D     ( TH3 * hptr, double toffset = 0., u_short mode = 0 );
    int     FillHistogramXTmax  ( TH2 * hptr, double toffset = 0., u_short mode = 0 );
    int     FillHistogramYTmax  ( TH2 * hptr, double toffset = 0., u_short mode = 0 );

    virtual int FillAutoHistograms ( );

    int     Export3D_POV    ( const string & fname, u_short mode = 0 );
    int     ExportPads_POV  ( const string & fname, u_short mode = 0 );
    int     Export3D_POV    ( FILE * fptr, u_short mode = 0 );
    int     ExportPads_POV  ( FILE * fptr, u_short mode = 0 );
  //@}

  //----------------------------------------------------------
  /** @name ROOT related functions */
  //@{
  public:

    /*! for use within ROOT.*/
    ClassDef(GETActarTpcAnalyser,0);
  //@}
};


//----------------------------------------------------------------------
//  Inline functions
#include "icc/GETActarTpcAnalyser.icc"


//======================================================================
#endif