---

ExtraHits.h

Go to the documentation of this file.

// $Id: ExtraHits.h,v 1.2 2001/05/23 13:19:47 burnett Exp $
// 
//  Original author: Sawyer Gillespie
//                   hgillesp@u.washington.edu
//

#ifndef _H_ExtraHits_reconstruction_
#define _H_ExtraHits_reconstruction_

// include super-class
#include "reconstruction/ReconAnalysis.h"

// forward declarations
class   GFTrack;

// class ExtraHits
class   ExtraHits : public ReconAnalysis {
public:
    
    // class Result
    //  This encapsulates the result for the ExtraHits
    //  analysis.
    class   Result : public ReconAnalysis::Result {
    public:
        // constructor
        Result ( double _sumHits, double _norma, double _istHitCount
               , double _outHits, double _shwHits1, double shwHits2 );
        
        // destructor
        virtual ~Result () {}
        
        // total number of hits in the shower
        double  sumHits () const;

        // hit normalization
        double  normalization () const;

        // first hit count
        double  firstHitCount () const;

        // number of outside hits
        double  outsideHits () const;

        // number of hits in first prong of the shower
        double  showerHits1 () const;

        // number of hits in second pronf of the shower
        double  showerHits2 () const;

    protected:
        // set the sumHits
        void    sumHits ( double );

        // set the normalization
        void    normalization ( double );

        // set the first hit count
        void    firstHitCount ( double );

        // set the number of hits outside
        void    outsideHits ( double );

        // set the number of hits in the first prong
        void    showerHits1 ( double );

        // set the number of hits in the second prong
        void    showerHits2 ( double );

        // declare ExtraHits a friend
        friend class ExtraHits;
        
    private:
        double  m_sumHits;       // sum of all hits in the shower
        double  m_norma;         // normalization
        double  m_istHitCount;   // first-hit-count
        double  m_outHits;       // num hits outside ?
        double  m_shwHits1;      // shower hits from prong 1 ?
        double  m_shwHits2;      // shower hits from prong 2 ?
    };
    
    // construction
    ExtraHits (GlastRecon*);
    
    // destructor
    virtual ~ExtraHits ();
    
    // perform the computation
    virtual void    compute ();

    // access the Result
    const Result*   result () const;
        
protected:
    // set up data storage iterators
    virtual void    setUpData ();
        
private:
    // data members
    
    LbldData::iterator i_1st_count;    // first-hit-count
    LbldData::iterator i_srp_hit_rat;  // surplus-hit-ratio
    LbldData::iterator i_out_hit_rat;  // outside-hit-ratio
    LbldData::iterator i_No_SHits;     // number of hits in the shower
    LbldData::iterator i_ShowerHits1;  // number of hits in prong 1 ?
    LbldData::iterator i_ShowerHits2;  // number of hits in prong 2 ?
};

// inline declarations

// ExtraHits::Result class

inline ExtraHits::Result::Result ( double _sumHits, double _norma, double _istHitCount
                                 , double _outHits, double _shwHits1, double _shwHits2 )
: m_sumHits(_sumHits), m_norma(_norma), m_istHitCount(_istHitCount)
, m_outHits(_outHits), m_shwHits1(_shwHits1), m_shwHits2(_shwHits2)
{
}

inline double ExtraHits::Result::sumHits () const 
{
    return m_sumHits;
}

inline double ExtraHits::Result::normalization () const
{
    return m_norma;
}

inline double ExtraHits::Result::firstHitCount () const
{
    return m_istHitCount;
}

inline double ExtraHits::Result::outsideHits () const
{
    return m_outHits;
}

inline double ExtraHits::Result::showerHits1 () const
{
    return m_shwHits1;
}

inline double ExtraHits::Result::showerHits2 () const
{
    return m_shwHits2;
}

inline void ExtraHits::Result::sumHits ( double s )
{
    m_sumHits = s;
}

inline void ExtraHits::Result::normalization ( double s )
{
    m_norma = s;
}

inline void ExtraHits::Result::firstHitCount ( double s )
{
    m_istHitCount = s;
}

inline void ExtraHits::Result::outsideHits ( double s )
{
    m_outHits = s;
}

inline void ExtraHits::Result::showerHits1 ( double s )
{
    m_shwHits1 = s;
}

inline void ExtraHits::Result::showerHits2 ( double s )
{
    m_shwHits2 = s;
}

// ExtraHits class

inline const ExtraHits::Result*  ExtraHits::result () const
{
    return static_cast<const Result*>(ReconAnalysis::result());
}

#endif  // _H_ExtraHits_reconstruction_

---