TDSPBlockMap.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 TDSPBLOCKMAP_H
#define TDSPBLOCKMAP_H

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

class TDSPBlockMap : public TDSPOperator, public TDSPBlockOperation  {

 protected:

  // Method

  eMatrixApplyMode fMAMode;        // How to apply the Matrix
  eMatrixApplyMode fMAModeInverse; // How to apply the Inverse Matrix

  // 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

  TDSPMatrix*   fMatrix;  // The Matrix to multiply on the input stream
  TDSPMatrix*   fPseudoInverseMatrix; // The Matrix to multiply on the return stream

 public: 

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

  TDSPSignal*   GetSignal() const { return fSignal; };
  TDSPSignal*   GetInverseSignal() const { return fInverseSignal;};
  void          SetMatrix(TDSPMatrix *m) { fMatrix = m;};
  void          SetInverseMatrix(TDSPMatrix *m) { fPseudoInverseMatrix = m;};

  Double_t      TestError(UInt_t num=1); // multiply n random vectors with Matrix and inverse and return the Error

  Int_t         GetBlockLen();

  TDSPMatrix*   GetMatrix() const { return fMatrix;};
  TDSPMatrix*   GetInverseMatrix() const { return fPseudoInverseMatrix;};

  TDSPSignal*   Apply(TDSPSignal *input);
  TDSPSignal*   InverseApply(TDSPSignal *input);

  void          SetApplyMode(eMatrixApplyMode m)  { fMAMode = m;}; // Set Mode for Apply
  void          SetApplyMode(eMatrixApplyMode m1,                  // Set Modes for Apply and InverseApply
                 eMatrixApplyMode m2) { fMAMode = m1;fMAModeInverse = m2;};
  void          SetInverseApplyMode(eMatrixApplyMode m)  { fMAModeInverse = m;};// Set Mode for InverseApply
                 
  
  eMatrixApplyMode GetApplyMode() const { return fMAMode;};
  eMatrixApplyMode GetInverseApplyMode() const { return fMAModeInverse;};
  

  // Slots

  TDSPSignal*        Update(TDSPSignal *input); // Calls Apply and Emits "Update(TDSPSignal*)"
  TDSPSignal* InverseUpdate(TDSPSignal *input); // Calls InverseApply and Emits "InverseUpdate(TDSPSignal*)"

  ClassDef(TDSPBlockMap,1)

};

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

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



#endif

---