WireCell::Array Namespace Reference

Typedefs
typedef Eigen::ArrayXf	array_xf
typedef Eigen::ArrayXcf	array_xc
typedef Eigen::Array< short, Eigen::Dynamic, Eigen::Dynamic >	array_xxs
	A 16 bit short integer 2D array. More...
typedef Eigen::Array< int, Eigen::Dynamic, Eigen::Dynamic >	array_xxi
	Integer. More...
typedef Eigen::Array< long, Eigen::Dynamic, Eigen::Dynamic >	array_xxl
	Integer. More...
typedef Eigen::ArrayXXf	array_xxf
	A real, 2D array. More...
typedef Eigen::ArrayXXcf	array_xxc
	A complex, 2D array. More...

Functions
array_xxc	dft (const array_xxf &arr)
array_xxf	idft (const array_xxc &arr)
array_xxc	dft_rc (const array_xxf &arr, int dim=0)
array_xxc	dft_cc (const array_xxc &arr, int dim=1)
array_xxc	idft_cc (const array_xxc &arr, int dim=1)
array_xxf	idft_cr (const array_xxc &arr, int dim=0)
array_xxf	deconv (const array_xxf &arr, const array_xxc &filter)

Typedef Documentation

typedef Eigen::ArrayXcf WireCell::Array::array_xc

Definition at line 42 of file Array.h.

typedef Eigen::ArrayXf WireCell::Array::array_xf

Definition at line 41 of file Array.h.

typedef Eigen::ArrayXXcf WireCell::Array::array_xxc

A complex, 2D array.

Definition at line 57 of file Array.h.

typedef Eigen::ArrayXXf WireCell::Array::array_xxf

A real, 2D array.

Definition at line 54 of file Array.h.

typedef Eigen::Array<int, Eigen::Dynamic, Eigen::Dynamic> WireCell::Array::array_xxi

Integer.

Definition at line 48 of file Array.h.

typedef Eigen::Array<long, Eigen::Dynamic, Eigen::Dynamic> WireCell::Array::array_xxl

Integer.

Definition at line 51 of file Array.h.

typedef Eigen::Array<short, Eigen::Dynamic, Eigen::Dynamic> WireCell::Array::array_xxs

A 16 bit short integer 2D array.

Definition at line 45 of file Array.h.

Function Documentation

WireCell::Array::array_xxf WireCell::Array::deconv	(	const array_xxf &	arr,
		const array_xxc &	filter
	)

Perform 2D deconvolution.

This will perform a 2D forward DFT, do an element-by-element multiplication of that periodicity/frequency space matrix by the filter and then perform an 2D inverse DFT.

Definition at line 187 of file Array.cxx.

{
    const int nrows = arr.rows();
    const int ncols = arr.cols();

    Eigen::FFT< float > fft;

    Eigen::MatrixXcf matc(nrows, ncols);
    for (int irow = 0; irow < nrows; ++irow) {
        Eigen::VectorXcf fspec(ncols); // frequency spectrum 
        // fft wants vectors, also input arr is const
        Eigen::VectorXf tmp = arr.row(irow);
        fft.fwd(fspec, tmp);
        matc.row(irow) = fspec;
    }
    
    for (int icol = 0; icol < ncols; ++icol) {
        Eigen::VectorXcf pspec(nrows); // periodicity spectrum
        fft.fwd(pspec, matc.col(icol));
        matc.col(icol) = pspec;
    }

    // deconvolution via multiplication in frequency space
    Eigen::MatrixXcf filt = matc.array() * filter;

    for (int icol = 0; icol < ncols; ++icol) {
        Eigen::VectorXcf pspec(nrows); // wire spectrum
        fft.inv(pspec, filt.col(icol));
        filt.col(icol) = pspec;
    }

    array_xxf ret(nrows, ncols);

    for (int irow = 0; irow < nrows; ++irow) {
        Eigen::VectorXf wave(ncols); // back to real-valued time series
        fft.inv(wave, filt.row(irow));
        ret.row(irow) = wave;
    }

    return ret;
}

WireCell::Array::array_xxc WireCell::Array::dft

(

const array_xxf &

arr

)

Perform full, 2D discrete Fourier transform on a real 2D array.

The full 2D DFT first performs a 1D DFT (real->complex) on each individual row and then a 1D DFT (complex->complex) on each resulting column.

const_shared_array_xxf arr = ...; const_shared_array_xxc spec = dft(*arr);

...

        const_shared_array_xxf arr2 = idft(*spec);

Definition at line 15 of file Array.cxx.

{
    const int nrows = arr.rows();
    const int ncols = arr.cols();

    Eigen::FFT< float > fft;
    Eigen::MatrixXcf matc(nrows, ncols);

    for (int irow = 0; irow < nrows; ++irow) {
        Eigen::VectorXcf fspec(ncols); // frequency spectrum 
        // fft wants vectors, also input arr is const
        Eigen::VectorXf tmp = arr.row(irow);
        fft.fwd(fspec, tmp);
        matc.row(irow) = fspec;
    }

    for (int icol = 0; icol < ncols; ++icol) {
        Eigen::VectorXcf pspec(nrows); // periodicity spectrum
        fft.fwd(pspec, matc.col(icol));
        matc.col(icol) = pspec;
    }

    return matc;
}

WireCell::Array::array_xxc WireCell::Array::dft_cc	(	const array_xxc &	arr,
		int	dim = 1
	)

Definition at line 67 of file Array.cxx.

{
    const int nrows = arr.rows();
    const int ncols = arr.cols();

    Eigen::FFT< float > fft;
    Eigen::MatrixXcf matc(nrows, ncols);

    matc = arr.matrix();
    
    if (dim == 0) {
        for (int irow = 0; irow < nrows; ++irow) {
            Eigen::VectorXcf pspec(ncols);
            fft.fwd(pspec,matc.row(irow));
            matc.row(irow) = pspec;
        }
    }
    else {
        for (int icol = 0; icol < ncols; ++icol) {
            Eigen::VectorXcf pspec(nrows);
            fft.fwd(pspec, matc.col(icol));
            matc.col(icol) = pspec;
        }
    }
    return matc;
}

WireCell::Array::array_xxc WireCell::Array::dft_rc	(	const array_xxf &	arr,
		int	dim = 0
	)

Partial, 1D DFT and inverse DFT along one dimension of an array. Each row is transformed if dim=0, each column if dim=1. The transfer is either real->complex (rc), complex->complex(cc) or complex->real(cr).

The full 2D DFT should be used unless an intermediate filter is required as it will avoid producing some temporaries.

Conceptually:

auto xxc = dft(xxf);

is equivalent to

auto tmp = dft_rc(xxf, 0); auto xxc = dft_cc(tmp, 1);

and:

auto xxf = idft(xxc)

is equivalent to:

auto tmp = idft_cc(xxc, 1);
auto xxf = idft_rc(tmp, 0);

Definition at line 40 of file Array.cxx.

{
    const int nrows = arr.rows();
    const int ncols = arr.cols();

    Eigen::FFT< float > fft;
    Eigen::MatrixXcf matc(nrows, ncols);

    if (dim == 0) {
        for (int irow = 0; irow < nrows; ++irow) {
            Eigen::VectorXcf fspec(ncols);
            Eigen::VectorXf tmp = arr.row(irow);
            fft.fwd(fspec, tmp);
            matc.row(irow) = fspec;
        }
    }
    else if (dim == 1) {
        for (int icol = 0; icol < ncols; ++icol) {
            Eigen::VectorXcf fspec(nrows);
            Eigen::VectorXf tmp = arr.col(icol);
            fft.fwd(fspec, tmp);
            matc.col(icol) = fspec;
        }
    }        
    return matc;
}

WireCell::Array::array_xxf WireCell::Array::idft

(

const array_xxc &

arr

)

Definition at line 96 of file Array.cxx.

{
    const int nrows = arr.rows();
    const int ncols = arr.cols();

    // fft works on matrices, not arrays, also don't step on const input
    Eigen::MatrixXcf partial(nrows, ncols);
    partial = arr.matrix();

    Eigen::FFT< float > fft;

    for (int icol = 0; icol < ncols; ++icol) {
        Eigen::VectorXcf pspec(nrows); // wire spectrum
        fft.inv(pspec, partial.col(icol));
        partial.col(icol) = pspec;
    }

    //shared_array_xxf ret = std::make_shared<array_xxf> (nrows, ncols);
    array_xxf ret(nrows, ncols);

    for (int irow = 0; irow < nrows; ++irow) {
        Eigen::VectorXf wave(ncols); // back to real-valued time series
        fft.inv(wave, partial.row(irow));
        ret.row(irow) = wave;
    }

    return ret;
}

WireCell::Array::array_xxc WireCell::Array::idft_cc	(	const array_xxc &	arr,
		int	dim = 1
	)

Definition at line 125 of file Array.cxx.

{
    const int nrows = arr.rows();
    const int ncols = arr.cols();

    // fft works on matrices, not arrays, also don't step on const input
    Eigen::MatrixXcf ret(nrows, ncols);
    ret = arr.matrix();

    Eigen::FFT< float > fft;

    if (dim == 1) {
        for (int icol = 0; icol < ncols; ++icol) {
            Eigen::VectorXcf pspec(nrows);
            fft.inv(pspec, ret.col(icol));
            ret.col(icol) = pspec;
        }
    }
    else if (dim == 0) {
        for (int irow = 0; irow < nrows; ++irow) {
            Eigen::VectorXcf pspec(ncols);
            fft.inv(pspec, ret.row(irow));
            ret.row(irow) = pspec;
        }
    }
    return ret;
}

WireCell::Array::array_xxf WireCell::Array::idft_cr	(	const array_xxc &	arr,
		int	dim = 0
	)

Definition at line 153 of file Array.cxx.

{
    const int nrows = arr.rows();
    const int ncols = arr.cols();

    // fft works on matrices, not arrays, also don't step on const input
    Eigen::MatrixXcf partial(nrows, ncols);
    partial = arr.matrix();

    Eigen::FFT< float > fft;

    array_xxf ret(nrows, ncols);

    if (dim == 0) {
        for (int irow = 0; irow < nrows; ++irow) {
            Eigen::VectorXf wave(ncols); // back to real-valued time series
            fft.inv(wave, partial.row(irow));
            ret.row(irow) = wave;
        }
    }
    else if (dim == 1) {
        for (int icol = 0; icol < ncols; ++icol) {
            Eigen::VectorXf wave(nrows);
            fft.inv(wave, partial.col(icol));
            ret.col(icol) = wave;
        }
    }
    return ret;
}