TDSPFilterBank.h

Go to the documentation of this file.

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef TDSPFILTERBANK_H
#define TDSPFILTERBANK_H

#include <TNamed.h>
#include <TH2.h>
#include <TDSPRating.h>
#include <TDSPVector.h>
#include <TDSPMatrix.h>

#define OPT_MY_FILTERMATRIX 0x1
#define OPT_DFT_FILTERBANK  0x2

class TDSPFilterBank : public TNamed, virtual public TDSPRating  {

 private:

  Bool_t  _isMyMatrix() { return fOpt&OPT_MY_FILTERMATRIX;};
  void    _enableMyMatrix() { fOpt|=OPT_MY_FILTERMATRIX;};
  void    _disableMyMatrix() { fOpt&=(!OPT_MY_FILTERMATRIX);};


  Bool_t  _isDFT() { return fOpt&OPT_DFT_FILTERBANK;};
  void    _enableDFT() { fOpt|=OPT_DFT_FILTERBANK;};
  void    _disableDFT() { fOpt&=(!OPT_DFT_FILTERBANK);};

  Bool_t  _IsReady(); 
  void    _CleanMe(); 
  void    _MinMaxSubSampling(); 

  void    _reset_options(); 
  Int_t    fZero; 
  UInt_t   fNumActive; 

 protected:

  UInt_t      fOpt; 
  TDSPMatrix* fFilterBank; 
  TArrayI     fSubSamplings; 
  UInt_t      fMinSubSampling; 
  UInt_t      fMaxSubSampling; 
  TArrayI     fFilterOptions; 
  TString     fMethodStr; 

  // members used for DFT-Filterbank

  UInt_t      fFreqPad; 

 public: 
  TDSPFilterBank(UInt_t N=0, UInt_t L=0); 
  ~TDSPFilterBank();

  void           SetFilter(UInt_t n, TDSPVector *f); 
  TDSPVector*    GetFilter(UInt_t n, TDSPVector *f=NULL); 

  void           SetMatrix(TDSPMatrix *a); 
  TDSPMatrix*    GetMatrix() const { return fFilterBank;}; 
  void           LoadMatrix(char *fname, char *key); 

  void           SetSize(UInt_t N, UInt_t L); 
  void           SetSubSampling(UInt_t n, UInt_t T); 
  void           SetSubSamplings(UInt_t T); 
  void           SetTimePad(UInt_t T) { SetSubSamplings(T);}; 
  void           SetFilterOption(UInt_t opt); 
  void           SetFilterOption(UInt_t n, UInt_t opt); 
  UInt_t         GetFilterOption(UInt_t n); 
  Bool_t         IsActive(UInt_t n); 
  void           Activate(UInt_t n); 
  void           Deactivate(UInt_t n); 

  Bool_t         IsCommonSubSampling(); 
  UInt_t         GetSubSampling(UInt_t n); 
  UInt_t         GetSubSamplings(); 
  UInt_t         GetMaxSubSampling() const { return fMaxSubSampling;}; 
  UInt_t         GetMinSubSampling() const { return fMinSubSampling;}; 

  UInt_t         GetLength(); 
  UInt_t         GetNum(); 
  void           SetLength(UInt_t); 
  void           SetNum(UInt_t); 
  void           SetZero(Int_t z) { fZero=z;}; 
  Int_t          GetZero() const { return fZero;}; 


  TDSPVector*    Synthesize(TDSPVector *input, TDSPVector *output=NULL);  
  TDSPVector*    Analyze( TDSPVector *input, TDSPVector *output=NULL);  

  // Automatic filters
  //
  virtual void   InitFromProtoType(Option_t* method, TDSPVector *input); 
  virtual void   LoadAndInitFromProtoType(Option_t* method,char *fname,char*key=NULL); 

  // methods used for DFT-Filterbank
  //
  UInt_t         GetFreqPad() const { return fFreqPad;}; 
  void           SetFreqPad(UInt_t f) { fFreqPad=f;};
  UInt_t         GetNumActiveFilters() const { return fNumActive;}; 
  

  void           Print(); 
  //TH2*           Draw(Option_t *option = "hist surf4"); ///< Draw the filtermatrix 


  Double_t       GetBandWidthEfficiency();

  // Calculate the Dual Filterbank specified by a method

  TDSPMatrix*    GetDualMatrix(Option_t *method="pseudoinverse");

  ClassDef(TDSPFilterBank,1)

};

#endif

---