How to extract real and imaginary parts of complex Eigen tensor? - c++

Question

I am fairly new with Eigen and I read about Eigen unsupported tensor, which I decided to give it a try. I am trying to copy the output of an array after taking the 3D FFT to a complex Eigen tensor and I am not sure how to do it correctly. Is this feature available for Eigen Tensor?
A simple working example:
static const int nx = 4;
static const int ny = 4;
static const int nz = 4;
double Lx = 2*EIGEN_PI;
double Ly = 2*EIGEN_PI;
double dx = Lx / nx;
double dy = Ly / ny;
Eigen::Tensor<double, 3> eXX(nx,ny,nz);
eXX.setZero();
Eigen::Tensor<double, 3> eYY(nx,ny,nz);
eYY.setZero();
Eigen::Tensor<double, 3> eZZ(nx,ny,nz);
eZZ.setZero();
for(int i = 0; i< nx; i++){
for(int j = 0; j< ny; j++){
for(int k = 0; k< nz; k++){
eXX(k,i,j) = i*dx;
eYY(j,i,k) = j*dy;
eZZ(j,i,k) = k*dz;
}
}
}
double A = (2 * EIGEN_PI)/Lx;
double B= (2 * EIGEN_PI)/ Ly;
Eigen::Tensor<double, 3> Fun(nx,ny,nz);
Fun.setZero();
for(int i = 0; i< nx; i++){
for(int j = 0; j< ny; j++){
for(int k = 0; k< nz; k++){
Fun(k,i,j) = pow(eZZ(k,i,j),2.0) * sin(A * eXX(k,i,j)) * sin(B * eYY(k,i,j));
}
}
}
#define IMAG 1
#define REAL 0
fftw_complex *input_array;
fftw_complex *output_array;
input_array = (fftw_complex*) fftw_malloc(nx*ny*nz * sizeof(fftw_complex));
output_array = (fftw_complex*) fftw_malloc(nx*ny*nz * sizeof(fftw_complex));
for (int i = 0; i < nx; ++i) {
for (int j = 0; j < ny; ++j) {
for (int k = 0; k < nz; ++k) {
{
input_array[k + nz * (j + ny * i)][REAL] = Fun(k,i,j);
input_array[k + nz * (j + ny * i)][IMAG] = 0;
}
}
}
}
fftw_plan forward = fftw_plan_dft_3d(nx, ny, nz, input_array, output_array, FFTW_FORWARD, FFTW_ESTIMATE);
fftw_execute(forward);
fftw_destroy_plan(forward);
fftw_cleanup();
I am trying to copy the output to a tensor with the definition:
Eigen::Tensor<std::complex<double>, 3> Test(nx,ny,nz);
Test.setZero();
My attempt:
Eigen::Tensor<double, 3> Re(nx,ny,nz);
Re.setZero();
Eigen::Tensor<std::complex<double>, 3> Im(nx,ny,nz);
Im.setZero();
for(int i=0; i < nx; ++i){
for(int j=0; j < ny; ++j) {
for(int k=0; k < nz; ++k) {
Re(k,i,j) = output_array[k + nz * (j + ny * i)][REAL];
Im(k,i,j) = output_array[k + nz * (j + ny * i)][IMAG];
}
}
}
Test.real() = Re;
Test.imag() = Im;
Unfortunately, this above attempt is not working. I get the error:
error: use of deleted function ‘Eigen::TensorCwiseUnaryOp<Eigen::internal::scalar_imag_op<std::complex<double> >, const Eigen::Tensor<std::complex<double>, 3> >& Eigen::TensorCwiseUnaryOp<Eigen::internal::scalar_imag_op<std::complex<double> >, const Eigen::Tensor<std::complex<double>, 3> >::operator=(Eigen::TensorCwiseUnaryOp<Eigen::internal::scalar_imag_op<std::complex<double> >, const Eigen::Tensor<std::complex<double>, 3> >&&)’
370 | Test.imag() = Im;
error: non-static reference member ‘const Eigen::Tensor<std::complex<double>, 3>& Eigen::TensorCwiseUnaryOp<Eigen::internal::scalar_imag_op<std::complex<double> >, const Eigen::Tensor<std::complex<double>, 3> >::m_xpr’, can’t use default assignment operator

Answer 1

No you can't assign the real or imaginary part of a Tensor using the real() or imag() operation. The unsupported Tensor interface does not perfectly match with the core Matrix or Array interface.(Unsupported modules are contribution from third party developers, not core developers.)
You can see the difference in the following sources, scrapped from the 3.4.0 version.
This is the implementation of the Matrix at Eigen/src/plugins/CommonCwiseUnaryOps.h.
typedef CwiseUnaryView<internal::scalar_imag_ref_op<Scalar>, Derived> NonConstImagReturnType;
...
NonConstImagReturnType
imag() { return NonConstImagReturnType(derived()); }
This is the implementation of Tensor at unsupported/Eigen/CXX11/src/Tensor/TensorBase.h.
... const TensorCwiseUnaryOp<internal::scalar_imag_op<Scalar>, const Derived>
imag() const { return unaryExpr(internal::scalar_imag_op<Scalar>()); }