BrTpcClusterModule

class description - source file - inheritance tree

class BrTpcClusterModule : public BrModule

    private:

             virtual Bool_t FindClusters()
      virtual BrTpcCluster* GetClusterById(Int_t id)
               virtual void ResetSequenceTable()
             virtual Bool_t SeqOverlap(BrTpcSequence* iseq, BrTpcSequence* jseq)

    public:

      BrTpcClusterModule BrTpcClusterModule()
      BrTpcClusterModule BrTpcClusterModule(const Char_t* name, const Char_t* title)
      BrTpcClusterModule BrTpcClusterModule(BrTpcClusterModule&)
            virtual void ~BrTpcClusterModule()
          static TClass* Class()
            virtual void DefineHistograms()
            virtual void Event(BrEventNode* inputNode, BrEventNode* outputNode)
          virtual Bool_t GetDoReset()
            virtual void Init()
         virtual TClass* IsA() const
            virtual void Print(Option_t* option = "B") const
            virtual void SetDoReset(Bool_t reset = kTRUE)
            virtual void ShowMembers(TMemberInspector& insp, char* parent)
            virtual void Streamer(TBuffer& b)
                    void StreamerNVirtual(TBuffer& b)

Data Members


    protected:

      BrDataTable* fSeqTable      pointer to the input data
      BrDataTable* fClusterTable  pointer to cluster output data
             Int_t fClusterId     For defining unique IDs.
            Bool_t fReset         If kTRUE reset sequence table at the end of Event()
             TH1F* hNpads         No of pads in good clusters
             TH1F* hNtime         No of time bins in good clusters            
             TH1F* hNclusters     No of good clusters
             TH1F* hMaxADC        Max ADC values in good clusters
             TH1F* hSumADC        Integrated ADC values in good clusters
             TH1F* hPadvar        Pad variance, good clusters
             TH1F* hTimevar       Pad variance, good clusters

Class Description

   The BrTpcClusterModule is used to group the sequences into
   clusters, and store the clusters in a cluster table.
   This Class has been taken from what M. Justice  started to put
   together in Oct 99

   It takes sequences that have been filtered with
   BrTPCPreProcess as input and groups the sequences into
   BrTpcCluster s

   Deconvolution has been moved to BrTpcDeconvoluteClusterModule

BrTpcClusterModule() : BrModule()

 This constructer is no good

BrTpcClusterModule(const Char_t *name, const Char_t *title) : BrModule(name, title)

 This is the constructor that should be used
 Name should be "T1", "T2", "TPM1", "TPM2"

~BrTpcClusterModule()

 empty

void DefineHistograms()

 Define the histograms used to monitor performance
 This method is usually called by BrModule::Book().

void Init()

 Initialize module. Empty.

Event(BrEventNode *inputNode, BrEventNode *outputNode)

 Main method
 Gets the TPCSequence data from the inputNode
 Group the sequences into clusters.
 Output the clusters on outputNode

void ResetSequenceTable()

 Reset BrTpcSequence::fClustNum to -1, as this variable is modified in FindClusters.

Bool_t FindClusters()

 **************************************************************
 *                                                            *
 *  The algorithm used here is to group together sequences    *
 *  on adjacent pads which overlap in the temporal direction  *
 *  as determined by the SeqOverlap function                  *
 *                                                            *
 **************************************************************

BrTpcCluster* GetClusterById(Int_t id)

 Loop over fClusterTable and return cluster with matching id
 If cluster is not found return 0

void Print(Option_t* option) const

 Module Information method

 Options: (see also BrModule::Print)

Bool_t SeqOverlap(BrTpcSequence *iseq, BrTpcSequence *jseq)

   ***************************************************************
   *                                                             *
   * Overlap criteria:                                           *
   *                                                             *
   *                  |                    |                     *
   *                  |                    |                     *
   *        TRUE      |           FALSE    |                     *
   *                  | |                  |                     *
   *                  | |                  | |                   *
   *                    |                    |                   *
   *                    |                    |                   *
   *                                         |                   *
   *                                         |                   *
   *                                                             *
   *     This could be made more flexible by introduction        *
   *     of a parameter controlling the amount of overlap        *
   *     required.                                               *
   *                                                             *
   ***************************************************************

 Maybe this method should be in the BrTpcSequence

Inline Functions

                    Bool_t GetDoReset()
                      void SetDoReset(Bool_t reset = kTRUE)
                   TClass* Class()
                   TClass* IsA() const
                      void ShowMembers(TMemberInspector& insp, char* parent)
                      void Streamer(TBuffer& b)
                      void StreamerNVirtual(TBuffer& b)
        BrTpcClusterModule BrTpcClusterModule(BrTpcClusterModule&)

This page automatically generated by script docBrat by Christian Holm

Validate HTML
Validate CSS