TDSPFifo.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 TDSPFIFO_H
#define TDSPFIFO_H


#include <Rtypes.h>
#include <TError.h>
#include "TDSPSignal.h"

class TDSPSignal;
class TDSPFifo {

  
 protected:
  
  Int_t     fDepth; //  The Size/Depth of the Fifo
  Int_t     fIndex; //  The actual index in the Fifo (is the top value)
  Int_t     fFill;  //  The Fill Status of the Fifo

  TComplex *fBlock; 

  void   Fill(); // Update the Fill Status

  static UInt_t  fPerLine;

 public: 

  TDSPFifo(Int_t depth=0);
  virtual ~TDSPFifo();

  static void ValuesPerLine(UInt_t p) { fPerLine = p;}; // How many Values to Print per line (using cout...)
  Int_t GetIndex(Int_t); // Transform a index into a cyclic index

  Int_t GetDepth() const { return fDepth;}; // return the depth of the fifo
  Int_t GetFill() const { return fFill; }; // return the fill depth of the fifo
  TComplex* GetBlock() const { return fBlock; }; // return the Block address of the fifo
  
  Bool_t WasFull() {  return fFill>=fDepth;};  // Is and was the Fifo full (for requests after shifts)
  Bool_t IsFull()  { return fFill==fDepth-1;}; // Is the Fifo full now (for request before shifts)
  void  Reset(); // reset the fifo
 
  TComplex& operator()(); // Get/Set the Top Value of the Fifo
  TComplex& operator()(Int_t i); // Get/Set the Value at Depth of "i" of the Fifo
  TComplex& operator[](Int_t i); // Get/Set the Value at direct position in the fifo (not cycled)

  friend istream    &operator>>(istream&,TDSPFifo&);
  friend ostream    &operator<<(ostream&,TDSPFifo&);
  friend istream    &operator>>(istream&,TDSPFifo*);
  friend ostream    &operator<<(ostream&,TDSPFifo*);

  void      Print();
  void      Input();

  // Implementation of cyclic Index operations (next/back etc.)
  //
  Int_t GetIndex() const { return fIndex; };  // return the actual cyclic index (eq. to GetIndex(0))
  void  Next()   { if (fIndex++==fDepth) fIndex=0;} // next with intern cyclic Index
  Int_t Next(Int_t current) {return current++==fDepth ? 0 : current;} // next with extern cyclic Index

  void  Back()   { fIndex= fIndex ? fIndex-1 : fDepth;} // back with intern cyclic Index
  Int_t Back(Int_t current) {return current ? current-1 : fDepth;} // back with extern cyclic Index
  
  TComplex&   Shift(Double_t x) { return Shift(TComplex(x,0)); };
  TComplex&   Shift(TComplex c); // Put a new Value on the top of the  Fifo and return the lowest value 
  TDSPVector* Shift(TDSPVector *input, TDSPVector *output); // Fills from a vector, returns into a vector
  void        FillFrom(TDSPVector *input); // Fills the fifo from a vector
  TDSPVector* FillTo(TDSPVector* output=NULL); // Fills the content into a vector
  void        SetDepth(Int_t depth); // Set the Depth of the Fifo
  void        Set(const TComplex&);                      // Set all values of the fifo to c
  void        Set(Double_t);                             // Set all values of the fifo to c
  void        Zeros() { Set(0.0); };                     // Set all values of the fifo to 0
  void        Ones() { Set(1.0);};                       // Set all values of the fifo to 1
 
  TComplex    Dot(TComplex *fir_vec, Bool_t conj=kTRUE,Int_t l=0); // Dot-product (conj this?) <this fifo, compl.array> (l=length with 0=fifofill)
  TComplex    Dot(TDSPVector *fir, Bool_t conj=kTRUE);   // Dot-product (conj this?) <this fifo, TDSPVector> 
  TComplex    Dot(TDSPFifo   *fir, Bool_t conj=kTRUE);   // Dot-product (conj this?) <this fifo, other fifo>

  TDSPVector *filter(TDSPVector *out,
             TDSPVector *fir,
             TDSPVector *iir = NULL); // Use the fifo-content as a filter input

  TGraph*   Graph(Option_t* = "complex", TGraph *in=NULL, Double_t dx=1.0, Double_t xoff=0.0);
  void      Draw(Option_t* = "", Double_t dx=1.0, Double_t xoff=0.0); //*MENU*

  
  TDSPFifo &operator=(const Double_t x)  { Set(x); return *this;};
  TDSPFifo &operator=(const TComplex& c) { Set(c); return *this;};

  ClassDef(TDSPFifo,0)

};



// FIR/IIR - filtering using the fifo-content as input signal
//

TDSPVector *filter(TDSPFifo   *in,
           TDSPVector *out,
           TDSPVector *fir,
           TDSPVector *iir = NULL);

// FIR/IIR - filtering using the fifo-content as input signal
//

TComplex    filter(TDSPFifo   *in,
           TDSPFifo   *out,
           TDSPVector *fir,
           TDSPVector *iir = NULL);

inline TDSPVector *TDSPFifo::filter(TDSPVector *out,
                    TDSPVector *fir,
                    TDSPVector *iir) { // Use the fifo-content as a filter input

  return ::filter(this,out,fir,iir);

}
inline TComplex& TDSPFifo::operator()() {
  return fBlock[fIndex];
}


inline TComplex& TDSPFifo::operator[](Int_t i) {
  return fBlock[i];
}

inline Int_t TDSPFifo::GetIndex(Int_t i) {
  if (i<0) {
    i++;
    i%=fFill;
    i+=fFill-1;
  } else 
    i %= fFill;         // can be seen as periodic
  i += Next(fIndex);   // index "0" correspond to fIndex+1 (the place of then oldest entry ...)
  if (i>fFill) return i-fFill-1;
  return i;
}

inline TComplex& TDSPFifo::operator()(Int_t i) {
  return fBlock[GetIndex(i)];
}


inline void TDSPFifo::Fill() {
  if (!WasFull()) fFill++;
}


inline TComplex& TDSPFifo::Shift(TComplex c) {
  // Put the new Value on the Top
  //
  (*this)() = c;

  // Increase the cyclic index
  //
  Next();
  
  // Update the Fill Status
  //
  Fill();
  
  // Checking Fill Status of the Fifo
  //
  if (!WasFull())
    return ComplexZero;

  // Return the bottom value
  return (*this)();
}

inline TComplex TDSPFifo::Dot(TComplex *fir_vec, Bool_t conj, Int_t len) {
  
  TComplex      tmp = 0;

  if (!len) len=fFill;

  if (conj) 
    for(register Int_t j=0;j<len;++j) tmp += operator()(-j-1) % fir_vec[j];
  else 
    for(register Int_t j=0;j<len;++j) tmp += operator()(-j-1) * fir_vec[j];
  return tmp;
}

inline void TDSPFifo::Set(const TComplex& c) {
  for(register Int_t i=0;i<=fDepth;++i) fBlock[i] = c;
  fFill = fDepth;
}

inline void TDSPFifo::Set(Double_t d) {
  for(register Int_t i=0;i<=fDepth;++i) { fBlock[i].fRe = d; fBlock[i].fIm = 0; };
  fFill = fDepth;
}
#endif

---