ECLWaveformData.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <cassert>
#include <vector>
#include <utility>
#include <TObject.h>
 
namespace Belle2 {
  class ECLWaveformData : public TObject {
  public:
 
    void setMatrixElement(size_t i, float value)
    {
      assert(i < c_nElements);
      m_matrixElement[i] = value;
    }
    float getMatrixElement(size_t i) const
    {
      assert(i < c_nElements);
      return m_matrixElement[i];
    }
 
    float getMatrixElement(size_t i, size_t j) const
    {
      if (i < j) std::swap(i, j);
      return m_matrixElement[ i * (i + 1) / 2 + j];
    }
 
    void getArray(float WF[136]) const  {for (int i = 0; i < 136; i++) { WF[i] = (float) m_matrixElement[i];}   }
 
    void getMatrix(float M[16][16]) const
    {
      const float* A = m_matrixElement;
      for (int i = 0; i < 16; i++) {
        for (int j = 0; j < i; j++) M[i][j] = M[j][i] = *A++;
        M[i][i] = *A++;
      }
    }
 
    void getMatrix(double M[16][16]) const
    {
      const float* A = m_matrixElement;
      for (int i = 0; i < 16; i++) {
        for (int j = 0; j < i; j++) M[i][j] = M[j][i] = *A++;
        M[i][i] = *A++;
      }
    }
 
    void storeMatrix(const std::array<std::array<float, 16>, 16>& M) // using std::array for intel compiler (TF)
    {
      float* A = m_matrixElement;
      for (int i = 0; i < 16; i++) {
        for (int j = 0; j < i; j++) *A++ = M[i][j];
        *A++ = M[i][i];
      }
    }
 
    void storeMatrix(const std::array<std::array<double, 16>, 16>& M) // using std::array for intel compiler (TF)
    {
      float* A = m_matrixElement;
      for (int i = 0; i < 16; i++) {
        for (int j = 0; j < i; j++) *A++ = static_cast<float>(M[i][j]);
        *A++ = M[i][i];
      }
    }
 
    void setWaveformPar(size_t i, float value)
    {
      assert(i < c_nParams);
      m_waveformPar[i] = value;
    }
 
 
    float getWaveformPar(size_t i) const
    {
      assert(i < c_nParams);
      return m_waveformPar[i];
    }
 
    void getWaveformParArray(float P[10]) const
    {
      for (int i = 0; i < 10; i++)
        P[i] = (float) m_waveformPar[i];
    }
 
    void getWaveformParArray(double P[10]) const
    {
      for (int i = 0; i < 10; i++)
        P[i] = m_waveformPar[i];
    }
 
    void print() const;
 
    static const size_t c_nElements = 136; 
    static const size_t c_nParams = 10; 
  private:
    Float_t m_matrixElement[c_nElements]; 
    Float_t m_waveformPar[c_nParams]; 
    ClassDef(ECLWaveformData, 1); 
  };
 
  class ECLWFAlgoParams : public TObject {
  public:
 
    Int_t ka;               
    Int_t kb;               
    Int_t kc;               
    Int_t y0Startr;         
    Int_t chiThresh;        
    Int_t k1Chi;            
    Int_t k2Chi;            
    Int_t hitThresh;        
    Int_t lowAmpThresh;     
    Int_t skipThresh;       
    int getka() const {return (int) ka;}            
    int getkb() const {return (int) kb;}            
    int getkc() const {return (int) kc;}            
    int gety0s()  const {return (int) y0Startr;}    
    int getcT() const {return (int) chiThresh;}     
    int getk1() const {return (int) k1Chi;}         
    int getk2() const {return (int) k2Chi;}         
    int gethT() const {return (int) hitThresh;}     
    int getlAT() const {return (int) lowAmpThresh;} 
    int getsT()  const {return (int) skipThresh;}   
    ClassDef(ECLWFAlgoParams, 1) 
  };
 
  class ECLNoiseData : public TObject {
  public:
    void setMatrixElement(size_t i, float value)
    {
      assert(i < c_nElements);
      m_matrixElement[i] = value;
    }
    float getMatrixElement(size_t i) const
    {
      assert(i < c_nElements);
      return m_matrixElement[i];
    }
 
    void getArray(float NoiseData[496]) const  {for (int i = 0; i < 496; i++) { NoiseData[i] = (float) m_matrixElement[i];}   }
 
    void getMatrix(float M[31][31]) const
    {
      const float* A = m_matrixElement;
      for (int i = 0; i < 31; i++) {
        for (int j = 0; j < 31; j++) {
          if (j > i) { // fill only the lower triangle
            M[i][j] = 0.f;
          } else {
            M[i][j] = *A++;
          }
        }
      }
    }
 
    void generateCorrelatedNoise(const float z[31], float x[31]) const
    {
      // z = (z0, ..., z30) is a inpute vector whose components are 31 independent standard normal variates
      // the output vector x is x0 + A*z, where x0 is 0 at the moment
      // A*A^T = C where C is a positive definite covariance matrix, A is a lower triangular matrix
      const float* A = m_matrixElement;
      for (int i = 0; i < 31; i++) {
        float sum = 0;
        for (int j = 0; j <= i; j++) sum += z[j] * (*A++);
        x[i] = sum;
      }
    }
 
    static const size_t c_nElements = 496; 
    Float_t m_matrixElement[c_nElements]; 
    ClassDef(ECLNoiseData, 1) 
  };
 
 
  class ECLLookupTable : public TObject {
  public:
    ECLLookupTable() : m_content(8736, 0) {}
 
    unsigned int operator[](unsigned int key) const
    { return m_content[ key - 1 ]; }
    unsigned int& operator[](unsigned int key)
    { return m_content[ key - 1 ]; }
 
  private:
    std::vector<unsigned int> m_content; 
    ClassDef(ECLLookupTable, 1); 
  };
 
}