DataUtils::Data Namespace Reference

Functions
std::vector< std::vector< double > >	create2DArrayfromDatafield (const Datafield &data)
	Creates a vector of vectors of double (2D Array) from Datafield. More...
std::unique_ptr< Datafield >	createFFT (const Datafield &data)
	Creates Fourier Transform (Datafield format) of intensity map (Datafield format). More...
std::unique_ptr< Datafield >	createRearrangedDataSet (const Datafield &data, int n)
	Returns new object with input data rotated by n*90 deg counterclockwise (n > 0) or clockwise (n < 0) Axes are swapped if the data is effectively rotated by 90 or 270 degrees Applicable to 2D arrays only. More...
std::vector< std::pair< double, double > >	FindPeaks (const Datafield &hist, double sigma=2, const std::string &option={}, double threshold=0.05)
	Returns vector of peak center coordinates, for peaks in given histogram. More...
Datafield *	importArrayToDatafield (const std::vector< double > &vec)
	Reads 1D array of doubles to Python, for use in persistence test. More...
Datafield *	importArrayToDatafield (const std::vector< std::vector< double >> &vec)
	Reads 2D array of doubles to Python, for use in persistence test. More...
std::unique_ptr< Datafield >	vecvecToDatafield (const std::vector< std::vector< double >> &array_2d)
	Creates Datafield from a 2D Array. More...

Function Documentation

create2DArrayfromDatafield()

std::vector< std::vector< double > > DataUtils::Data::create2DArrayfromDatafield

(

const Datafield &

data

)

Creates a vector of vectors of double (2D Array) from Datafield.

Definition at line 83 of file DataUtils.cpp.

{
    if (data.rank() != 2)
        throw std::runtime_error("DataUtils::Data::create2DArrayfromDatafield() -> "
                                 "Error! Works only on two-dimensional data");
 
    std::vector<std::vector<double>> array_2d;
    std::vector<double> row_vec; // row vector for constructing each row of 2D array
 
    size_t nrows = data.axis(0).size();
    size_t ncols = data.axis(1).size();
 
    size_t it = 0; // iterator of 'data'
    for (size_t row = 0; row < nrows; row++) {
        row_vec.clear();
        for (size_t col = 0; col < ncols; col++) {
            row_vec.push_back(data[it]);
            it++;
        }
        array_2d.push_back(row_vec);
    }
 
    return array_2d;
}

References Datafield::axis(), Datafield::rank(), and IAxis::size().

Referenced by createFFT().

Here is the call graph for this function:

createFFT()

std::unique_ptr< Datafield > DataUtils::Data::createFFT

(

const Datafield &

data

)

Creates Fourier Transform (Datafield format) of intensity map (Datafield format).

Definition at line 130 of file DataUtils.cpp.

{
    auto array_2d = DataUtils::Data::create2DArrayfromDatafield(data);
    auto fft_array_2d = FT2DArray(array_2d);
    return DataUtils::Data::vecvecToDatafield(fft_array_2d);
}

References create2DArrayfromDatafield(), and vecvecToDatafield().

Here is the call graph for this function:

createRearrangedDataSet()

std::unique_ptr< Datafield > DataUtils::Data::createRearrangedDataSet	(	const Datafield &	data,
		int	n
	)

Returns new object with input data rotated by n*90 deg counterclockwise (n > 0) or clockwise (n < 0) Axes are swapped if the data is effectively rotated by 90 or 270 degrees Applicable to 2D arrays only.

Definition at line 41 of file DataUtils.cpp.

{
    if (data.rank() != 2)
        throw std::runtime_error("DataUtils::Data::rotateDataByN90Deg()"
                                 " -> Error! Works only on two-dimensional data");
    n = (4 + n % 4) % 4;
    if (n == 0)
        return std::unique_ptr<Datafield>(data.clone());
 
    std::unique_ptr<Datafield> output;
    std::function<void(std::vector<int>&)> index_mapping;
 
    if (n == 2) {
        output.reset(new Datafield({data.axis(0).clone(), data.axis(1).clone()}));
        const int end_bin_x = static_cast<int>(data.axis(0).size()) - 1;
        const int end_bin_y = static_cast<int>(data.axis(1).size()) - 1;
        index_mapping = [end_bin_x, end_bin_y](std::vector<int>& inds) {
            inds[0] = end_bin_x - inds[0];
            inds[1] = end_bin_y - inds[1];
        };
 
    } else {
        output.reset(new Datafield({data.axis(1).clone(), data.axis(0).clone()}));
        const size_t rev_axis_i = n % 3;
        const size_t end_bin = data.axis(rev_axis_i).size() - 1;
        index_mapping = [rev_axis_i, end_bin](std::vector<int>& inds) {
            const int tm_index = inds[rev_axis_i];
            inds[rev_axis_i] = inds[rev_axis_i ^ 1];
            inds[rev_axis_i ^ 1] = static_cast<int>(end_bin) - tm_index;
        };
    }
 
    for (size_t i = 0, size = data.size(); i < size; ++i) {
        std::vector<int> axis_inds = data.frame().allIndices(i);
        index_mapping(axis_inds);
        size_t iout = output->frame().toGlobalIndex(
            {static_cast<unsigned>(axis_inds[0]), static_cast<unsigned>(axis_inds[1])});
        (*output)[iout] = data[i];
    }
    return output;
}

References Frame::allIndices(), Datafield::axis(), Datafield::clone(), IAxis::clone(), Datafield::frame(), Datafield::rank(), Datafield::size(), and IAxis::size().

Here is the call graph for this function:

FindPeaks()

std::vector< std::pair< double, double > > DataUtils::Data::FindPeaks	(	const Datafield &	hist,
		double	sigma = 2,
		const std::string &	option = {},
		double	threshold = 0.05
	)

Returns vector of peak center coordinates, for peaks in given histogram.

Definition at line 147 of file DataUtils.cpp.

{
    std::vector<std::vector<double>> arr = DataUtils::Array::createVector2D(field);
    tspectrum::Spectrum2D spec;
    auto peaks = spec.find_peaks(arr, sigma, option, threshold);
 
    // coordinates of peaks in histogram axes units
    std::vector<std::pair<double, double>> result;
 
    for (const auto& p : peaks) {
        double row_value = p.first;
        double col_value = p.second;
 
        auto xaxis_index = static_cast<size_t>(col_value);
        size_t yaxis_index = field.yAxis().size() - 1 - static_cast<size_t>(row_value);
 
        Bin1D xbin = field.xAxis().bin(xaxis_index);
        Bin1D ybin = field.yAxis().bin(yaxis_index);
 
        double dx = col_value - static_cast<size_t>(col_value);
        double dy = -1.0 * (row_value - static_cast<size_t>(row_value));
 
        double x = xbin.center() + xbin.binSize() * dx;
        double y = ybin.center() + ybin.binSize() * dy;
 
        result.emplace_back(x, y);
    }
    return result;
}

References IAxis::bin(), Bin1D::binSize(), Bin1D::center(), DataUtils::Array::createVector2D(), IAxis::size(), Datafield::xAxis(), and Datafield::yAxis().

Here is the call graph for this function:

importArrayToDatafield() [1/2]

Datafield * DataUtils::Data::importArrayToDatafield

(

const std::vector< double > &

vec

)

Reads 1D array of doubles to Python, for use in persistence test.

Definition at line 137 of file DataUtils.cpp.

{
    return DataUtils::Array::createPField1D(vec).release();
}

References DataUtils::Array::createPField1D().

Here is the call graph for this function:

importArrayToDatafield() [2/2]

Datafield * DataUtils::Data::importArrayToDatafield

(

const std::vector< std::vector< double >> &

vec

)

Reads 2D array of doubles to Python, for use in persistence test.

Definition at line 142 of file DataUtils.cpp.

{
    return DataUtils::Array::createPField2D(vec).release();
}

References DataUtils::Array::createPField2D().

Here is the call graph for this function:

vecvecToDatafield()

std::unique_ptr< Datafield > DataUtils::Data::vecvecToDatafield

(

const std::vector< std::vector< double >> &

array_2d

)

Creates Datafield from a 2D Array.

Definition at line 109 of file DataUtils.cpp.

{
    size_t nrows = array_2d.size();
    size_t ncols = array_2d[0].size();
 
    auto frame = new Frame(
        {new FixedBinAxis("x", nrows, 0.0, double(nrows)),
         new FixedBinAxis("y", ncols, 0.0, double(ncols))});
    std::vector<double> out(frame->size());
    std::vector<unsigned> axes_indices(2);
    for (unsigned row = 0; row < nrows; row++) {
        for (unsigned col = 0; col < ncols; col++) {
            axes_indices[0] = row;
            axes_indices[1] = col;
            size_t iout = frame->toGlobalIndex(axes_indices);
            out[iout] = array_2d[row][col];
        }
    }
    return std::make_unique<Datafield>(frame, out);
}

Referenced by createFFT().