TDSPFilterMap.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 TDSPFILTERMAP_H
#define TDSPFILTERMAP_H

#include <TDSPMatrix.h>
#include <TDSPSignal.h>
#include <TDSPOperator.h>
#include <TDSPBlockOperation.h>
#include <TDSPFilterBank.h>

#define OPT_MY_SYNTHESIS_FILTERBANK 0x1
#define OPT_MY_ANALYSIS_FILTERBANK 0x2

class TDSPFilterMap : public TDSPOperator, public TDSPBlockOperation  {

 private:
  Bool_t  _isMySynthesisBank() { return fOpt&OPT_MY_SYNTHESIS_FILTERBANK;};
  Bool_t  _isMyAnalysisBank()  { return fOpt&OPT_MY_ANALYSIS_FILTERBANK;};
  void    _enableMySynthesisBank() { fOpt|=OPT_MY_SYNTHESIS_FILTERBANK;};
  void    _enableMyAnalysisBank()  { fOpt|=OPT_MY_ANALYSIS_FILTERBANK;};
  void    _disableMySynthesisBank() { fOpt&=(!OPT_MY_SYNTHESIS_FILTERBANK);};
  void    _disableMyAnalysisBank()  { fOpt&=(!OPT_MY_ANALYSIS_FILTERBANK);};
  void    _cleanSynthesisBank();
  void    _cleanAnalysisBank();
  void    _createMySynthesisBank();
  void    _createMyAnalysisBank();
  void    _provideBanks();
  
 protected:

  UInt_t          fOpt;           // Options

  // Filterbanks

  TDSPFilterBank* fSynthesisBank; 
  TDSPFilterBank* fAnalysisBank;  

  // My Signals
  
  TString       Signal_Update;
  TString       Signal_InverseUpdate;

  // My Slots

  TString       Slot_Update;
  TString       Slot_InverseUpdate;
  

  TDSPSignal*   fSignal;  // The Output Signal return by a Apply-Call
  TDSPSignal*   fInverseSignal; // The Output Signal return by a InverseApply-Call

 public: 

  TDSPFilterMap(char *name = NULL);
  ~TDSPFilterMap();

  TDSPSignal*       GetSignal() const { return fSignal; };
  TDSPSignal*       GetInverseSignal() const { return fInverseSignal;};

  // Configure the filterbank
  
  void              SetNumFilters(UInt_t n);
  UInt_t            GetNumFilters();

  void              SetSubSamplings(UInt_t s);
  void              SetTimePad(UInt_t s) { SetSubSamplings(s);};
  UInt_t            GetTimePad() { return GetSubSamplings();};
  void              SetFreqPad(UInt_t); 
  UInt_t            GetFreqPad();  
  Double_t          GetBandWidthEfficiency();
  UInt_t            GetSubSamplings();
  void              Activate(UInt_t s); 
  void              Deactivate(UInt_t s); 
  TDSPVector*       GetSynthesisFilter(UInt_t s);
  TDSPVector*       GetAnalysisFilter(UInt_t s);
  UInt_t            GetNumActiveSynthesisFilters();
  UInt_t            GetNumActiveAnalysisFilters();

  // Get/Set the filterbank

  void              SetAnalysisBank(TDSPFilterBank *m);
  void              SetSynthesisBank(TDSPFilterBank *m);
  TDSPFilterBank*   GetAnalysisBank()  const { return fAnalysisBank;};
  TDSPFilterBank*   GetSynthesisBank() const { return fSynthesisBank;};

  Int_t             GetBlockLen() { return GetNumActiveSynthesisFilters();}; 
  
  // Get/Set the filtermatrix directly

  void              SetMatrix(TDSPMatrix *a);
  TDSPMatrix*       GetMatrix();
  void              SetInverseMatrix(TDSPMatrix *a);
  TDSPMatrix*       GetInverseMatrix();

  TDSPVector*       Synthesize(TDSPVector *input, TDSPVector *output=NULL);
  TDSPVector*       Analyze(TDSPVector *input,    TDSPVector *output=NULL);
  
  void              LoadAndInitFromProtoType(Option_t *method, char *fname); 
  virtual void      Print(); 

  // Slots

  TDSPSignal*        Update(TDSPSignal *input); // Calls Synthesize and Emits "Update(TDSPSignal*)"
  TDSPSignal* InverseUpdate(TDSPSignal *input); // Calls Analyse and Emits "InverseUpdate(TDSPSignal*)"

  ClassDef(TDSPFilterMap,1)

};

inline TDSPSignal* TDSPFilterMap::Update(TDSPSignal *input) {
  CheckInitialization();
  Synthesize(input,fSignal);
  Emit(Signal_Update,fSignal);
  return fSignal;
}

inline TDSPSignal* TDSPFilterMap::InverseUpdate(TDSPSignal *input) {
  CheckInitialization();
  Analyze(input,fInverseSignal);
  Emit(Signal_InverseUpdate,fInverseSignal);
  return fInverseSignal;
}



#endif

---