20 #ifdef IPPL_PRINTDEBUG
35 template <
size_t Dim,
class T>
38 const bool transformTheseDims[
Dim],
39 const bool& compressTemps)
41 transformTheseDims, compressTemps)
45 size_t nTransformDims = this->numTransformDims();
46 int* lengths =
new int[nTransformDims];
48 for (d=0; d<nTransformDims; ++d)
49 lengths[d] = cdomain[this->activeDimension(d)].length();
52 int* transformTypes =
new int[nTransformDims];
53 T& normFact = this->getNormFact();
55 for (d=0; d<nTransformDims; ++d) {
57 normFact /= lengths[d];
61 this->getEngine().setup(nTransformDims, transformTypes, lengths);
62 delete [] transformTypes;
73 template <
size_t Dim,
class T>
85 serialParallel[0] =
SERIAL;
90 tempLayouts_m =
new Layout_t*[nTransformDims];
94 for (
size_t dim=0; dim<nTransformDims; ++dim) {
101 ndip[0] = ndic[activeDim];
102 for (d=1; d<
Dim; ++d) {
103 size_t nextDim = activeDim + d;
104 if (nextDim >= Dim) nextDim -=
Dim;
105 ndip[d] = ndic[nextDim];
112 if (!this->
compressTemps()) (*tempFields_m[dim]).Uncompress();
122 template <
size_t Dim,
class T>
135 for (
size_t d=0; d<nTransformDims; ++d) {
136 delete tempFields_m[d];
137 delete tempLayouts_m[d];
139 delete [] tempFields_m;
140 delete [] tempLayouts_m;
148 template <
size_t Dim,
class T>
154 const bool& constInput)
160 const Layout_t& in_layout = f.getLayout();
161 const Domain_t& in_dom = in_layout.getDomain();
162 const Layout_t& out_layout = g.getLayout();
163 const Domain_t& out_dom = out_layout.getDomain();
173 ComplexField_t* temp = &f;
175 Complex_t* localdata;
178 begdim = (direction == +1) ? 0 : static_cast<int>(nTransformDims-1);
179 enddim = (direction == +1) ? static_cast<int>(nTransformDims) : -1;
180 for (idim = begdim; idim != enddim; idim += direction) {
184 bool skipTranspose =
false;
187 if (idim == begdim && !constInput) {
189 const Domain_t& first_dom = tempLayouts_m[idim]->getDomain();
192 skipTranspose = ( (in_dom[0].sameBase(first_dom[0])) &&
193 (in_dom[0].length() == first_dom[0].length()) &&
194 (in_layout.getDistribution(0) ==
SERIAL) &&
200 if (idim == enddim-direction) {
202 const Domain_t& last_dom = tempLayouts_m[idim]->getDomain();
205 skipTranspose = ( (out_dom[0].sameBase(last_dom[0])) &&
206 (out_dom[0].length() == last_dom[0].length()) &&
207 (out_layout.getDistribution(0) ==
SERIAL) &&
211 if (!skipTranspose) {
213 (*tempFields_m[idim])[tempLayouts_m[idim]->
getDomain()] =
214 (*temp)[temp->getLayout().getDomain()];
218 temp = tempFields_m[idim];
220 else if (idim == enddim-direction && temp != &g) {
225 g[out_dom] = (*temp)[temp->getLayout().getDomain()];
233 typename ComplexField_t::const_iterator_if l_i, l_end = temp->end_if();
234 for (l_i = temp->begin_if(); l_i != l_end; ++l_i) {
237 ComplexLField_t* ldf = (*l_i).second.get();
241 localdata = ldf->getP();
244 int nstrips = 1, length = ldf->size(0);
245 for (d=1; d<
Dim; ++d) nstrips *= ldf->size(d);
246 for (
int istrip=0; istrip<nstrips; ++istrip) {
260 g[out_dom] = (*temp)[temp->getLayout().getDomain()];
272 template <
size_t Dim,
class T>
283 const Layout_t& in_layout = f.getLayout();
284 const Domain_t& in_dom = in_layout.getDomain();
293 ComplexField_t* temp = &f;
295 Complex_t* localdata;
298 begdim = (direction == +1) ? 0 : static_cast<int>(nTransformDims-1);
299 enddim = (direction == +1) ? static_cast<int>(nTransformDims) : -1;
300 for (idim = begdim; idim != enddim; idim += direction) {
304 bool skipTranspose =
false;
307 if (idim == begdim) {
309 const Domain_t& first_dom = tempLayouts_m[idim]->getDomain();
312 skipTranspose = ( (in_dom[0].sameBase(first_dom[0])) &&
313 (in_dom[0].length() == first_dom[0].length()) &&
314 (in_layout.getDistribution(0) ==
SERIAL) &&
320 if (idim == enddim-direction) {
322 const Domain_t& last_dom = tempLayouts_m[idim]->getDomain();
325 skipTranspose = ( (in_dom[0].sameBase(last_dom[0])) &&
326 (in_dom[0].length() == last_dom[0].length()) &&
327 (in_layout.getDistribution(0) ==
SERIAL) &&
331 if (!skipTranspose) {
333 (*tempFields_m[idim])[tempLayouts_m[idim]->
getDomain()] =
334 (*temp)[temp->getLayout().getDomain()];
338 temp = tempFields_m[idim];
340 else if (idim == enddim-direction && temp != &f) {
345 f[in_dom] = (*temp)[temp->getLayout().getDomain()];
353 typename ComplexField_t::const_iterator_if l_i, l_end = temp->end_if();
354 for (l_i = temp->begin_if(); l_i != l_end; ++l_i) {
357 ComplexLField_t* ldf = (*l_i).second.get();
361 localdata = ldf->getP();
364 int nstrips = 1, length = ldf->size(0);
365 for (d=1; d<
Dim; ++d) nstrips *= ldf->size(d);
366 for (
int istrip=0; istrip<nstrips; ++istrip) {
381 f[in_dom] = (*temp)[temp->getLayout().getDomain()];
405 const bool transformTheseDims[1U],
const bool& compressTemps)
407 transformTheseDims, compressTemps)
415 size_t nTransformDims = 1U;
418 length = cdomain[0].length();
424 normFact = 1.0 / length;
440 const bool& compressTemps)
448 length = cdomain[0].length();
454 normFact = 1.0 / length;
499 delete tempLayouts_m;
513 const bool& constInput)
520 const Layout_t& in_layout = f.getLayout();
521 const Domain_t& in_dom = in_layout.getDomain();
522 const Layout_t& out_layout = g.getLayout();
523 const Domain_t& out_dom = out_layout.getDomain();
528 ComplexField_t* temp = &f;
530 Complex_t* localdata;
536 const Domain_t& temp_dom = tempLayouts_m->getDomain();
538 bool skipTranspose =
false;
544 skipTranspose = ( (in_dom[0].sameBase(temp_dom[0])) &&
545 (in_dom[0].length() == temp_dom[0].length()) &&
546 (in_layout.numVnodes() == 1) &&
556 skipFinal = ( (out_dom[0].sameBase(temp_dom[0])) &&
557 (out_dom[0].length() == temp_dom[0].length()) &&
558 (out_layout.numVnodes() == 1) &&
561 if (!skipTranspose) {
563 (*tempFields_m) = (*temp);
582 typename ComplexField_t::const_iterator_if l_i = temp->begin_if();
583 if (l_i != temp->end_if()) {
585 ComplexLField_t* ldf = (*l_i).second.get();
589 localdata = ldf->getP();
628 const Layout_t& in_layout = f.getLayout();
629 const Domain_t& in_dom = in_layout.getDomain();
633 ComplexField_t* temp = &f;
635 Complex_t* localdata;
641 const Domain_t& temp_dom = tempLayouts_m->getDomain();
649 skipTranspose = ( (in_dom[0].sameBase(temp_dom[0])) &&
650 (in_dom[0].length() == temp_dom[0].length()) &&
651 (in_layout.numVnodes() == 1) &&
654 if (!skipTranspose) {
656 (*tempFields_m) = (*temp);
664 typename ComplexField_t::const_iterator_if l_i = temp->begin_if();
665 if (l_i != temp->end_if()) {
667 ComplexLField_t* ldf = (*l_i).second.get();
671 localdata = ldf->getP();
708 template <
size_t Dim,
class T>
712 const bool transformTheseDims[Dim],
const bool& compressTemps)
714 transformTheseDims, compressTemps),
715 complexDomain_m(cdomain), serialAxes_m(1)
719 int* lengths =
new int[nTransformDims];
721 for (d=0; d<nTransformDims; ++d)
725 int* transformTypes =
new int[nTransformDims];
729 normFact /= lengths[0];
730 for (d=1; d<nTransformDims; ++d) {
732 normFact /= lengths[d];
737 delete [] transformTypes;
749 template <
size_t Dim,
class T>
750 FFT<RCTransform,Dim,T>::FFT(
753 const bool& compressTemps,
756 complexDomain_m(cdomain), serialAxes_m(serialAxes)
763 for (d=0; d<
Dim; ++d)
764 lengths[d] = rdomain[d].length();
767 int transformTypes[
Dim];
771 normFact /= lengths[0];
772 for (d=1; d<
Dim; ++d) {
774 normFact /= lengths[d];
789 template <
size_t Dim,
class T>
801 size_t d, d2, activeDim;
810 for (d=0; d <
Dim; ++d) {
812 NserialParallel[d] = (d < (size_t) serialAxes_m ?
SERIAL :
PARALLEL);
819 for (d=0; d<
Dim; ++d) {
820 if (d == activeDim) {
822 if ( complexDomain_m[d].length() !=
823 (domain[d].length()/2 + 1) ) match =
false;
827 if (complexDomain_m[d].length() != domain[d].length()) match =
false;
831 "Domains provided for real and complex Fields are incompatible!");
834 tempLayouts_m =
new Layout_t*[nTransformDims];
842 ndip[0] = domain[activeDim];
843 ndipc[0] = complexDomain_m[activeDim];
844 for (d=1; d<
Dim; ++d) {
845 size_t nextDim = activeDim + d;
846 if (nextDim >= Dim) nextDim -=
Dim;
847 ndip[d] = domain[nextDim];
848 ndipc[d] = complexDomain_m[nextDim];
861 int fftorder[
Dim], tmporder[
Dim];
862 int nofft = nTransformDims;
863 for (d=0; d < nTransformDims; ++d)
865 for (d=0; d <
Dim; ++d) {
868 for (d2=0; d2 < nTransformDims; ++d2) {
877 fftorder[nofft++] = d;
883 for (d=0; d < (Dim - 1); ++d)
884 fftorder[d] = fftorder[d+1];
885 fftorder[Dim-1] = nofft;
891 while (dim < nTransformDims) {
894 for (sp=0; sp < serialAxes_m && dim < nTransformDims; ++sp, ++dim) {
897 for (d=0; d <
Dim; ++d)
898 ndip[d] = complexDomain_m[fftorder[d]];
905 if (serialAxes_m > 1) {
906 tmporder[0] = fftorder[0];
907 for (d=0; d < (size_t) (serialAxes_m-1); ++d)
908 fftorder[d] = fftorder[d+1];
909 fftorder[serialAxes_m - 1] = tmporder[0];
915 for (d=0; d <
Dim; ++d)
916 tmporder[d] = fftorder[d];
917 for (d=0; d <
Dim; ++d)
918 fftorder[d] = tmporder[(d + serialAxes_m) %
Dim];
927 template <
size_t Dim,
class T>
935 for (
size_t d=0; d<nTransformDims; ++d) {
936 delete tempFields_m[d];
937 delete tempLayouts_m[d];
939 delete [] tempFields_m;
940 delete [] tempLayouts_m;
942 delete tempRLayout_m;
955 template <
size_t Dim,
class T>
964 const bool& constInput)
967 const Layout_t& in_layout = f.getLayout();
968 const Domain_t& in_dom = in_layout.getDomain();
975 RealField_t* tempR = &f;
977 typename RealField_t::const_iterator_if rl_i = tempR->begin_if();
980 RealLField_t* rldf = (*rl_i).second.get();
984 T* localreal = rldf->getP();
989 for (
size_t d = 0; d <
Dim; d++) {
990 NR_l[d] = (int)rldf->size(d);
991 NR_g[d] = (int)tempR->getDomain()[d].length();
994 NC_g[0] = (NC_g[0] / 2) + 1;
997 int sizereal = NR_l[0]*NR_l[1]*NR_l[2];
998 int totalreal = tempR->getDomain().size();
1005 for (
typename Layout_t::const_iterator_iv i_s = tempR->getLayout().begin_iv(); i_s != tempR->getLayout().end_iv(); ++i_s) {
1006 Domain_t tmp = (*i_s).second->getDomain();
1007 int node = (*i_s).second->getNode();
1008 idx[node] = tmp[0].min();
1009 idy[node] = tmp[1].min();
1010 idz[node] = tmp[2].min();
1014 for (
typename Layout_t::iterator_dv remote = tempR->getLayout().begin_rdv(); remote != tempR->getLayout().end_rdv(); ++remote) {
1015 Domain_t tmp = (*remote).second->getDomain();
1016 int node = (*remote).second->getNode();
1017 idx[node] = tmp[0].min();
1018 idy[node] = tmp[1].min();
1019 idz[node] = tmp[2].min();
1029 if (streamId == -1) {
1031 dksbase.gather3DData( real_ptr, localreal, sizereal, MPI_DOUBLE, NR_g, NR_l,
1036 dksbase.gather3DDataAsync<
T>( real_ptr, localreal, NR_g, NR_l, id, streamId);
1038 dksbase.syncDevice();
1044 dksbase.writeDataAsync<
T>(real_ptr, localreal, totalreal, streamId);
1049 dksbase.callR2CFFT(real_ptr, comp_ptr, nTransformDims, (
int*)NR_g, streamId);
1052 if (direction == +1)
1053 dksbase.callNormalizeFFT(comp_ptr, nTransformDims, (
int*) NC_g, streamId);
1056 if (streamId == -1) {
1058 dksbase.gather3DData( NULL, localreal, sizereal, MPI_DOUBLE, NR_g, NR_l, idx, idy, idz,
1062 dksbase.gather3DDataAsync<
T>( real_ptr, localreal, NR_g, NR_l, id, streamId);
1064 dksbase.syncDevice();
1075 template <
size_t Dim,
class T>
1081 const bool& constInput)
1091 const Layout_t& in_layout = f.getLayout();
1092 const Domain_t& in_dom = in_layout.getDomain();
1093 const Layout_t& out_layout = g.getLayout();
1094 const Domain_t& out_dom = out_layout.getDomain();
1098 this->
checkDomain(complexDomain_m,out_dom),
true);
1108 RealField_t* tempR = tempRField_m;
1111 bool skipTemp =
true;
1114 if ( !(in_layout == *tempRLayout_m) ) {
1118 for (d=0; d<
Dim; ++d)
1119 if (in_layout.getDistribution(d) != tempRLayout_m->getDistribution(d))
1123 if (in_layout.numVnodes() != tempRLayout_m->numVnodes())
1144 FFTDBG(tmsg <<
"doing transpose of real field into temporary ");
1146 (*tempR)[tempR->getDomain()] = f[in_dom];
1151 ComplexField_t* temp = tempFields_m[0];
1155 if (nTransformDims == 1) {
1156 bool skipTemp =
true;
1159 if (!(out_layout == *tempLayouts_m[0])) {
1162 for (d=0; d<
Dim; ++d)
1163 if (out_layout.getDistribution(d) !=
1164 tempLayouts_m[0]->getDistribution(d))
1167 if ( out_layout.numVnodes() != tempLayouts_m[0]->numVnodes() )
1181 FFTDBG(tmsg <<
"doing real->complex fft of first dimension ..." <<
std::endl);
1184 typename RealField_t::const_iterator_if rl_i, rl_end = tempR->end_if();
1185 typename ComplexField_t::const_iterator_if cl_i = temp->begin_if();
1186 for (rl_i = tempR->begin_if(); rl_i != rl_end; ++rl_i, ++cl_i) {
1188 RealLField_t* rldf = (*rl_i).second.get();
1189 ComplexLField_t* cldf = (*cl_i).second.get();
1196 T* localreal = rldf->getP();
1197 Complex_t* localcomp = cldf->getP();
1200 int nstrips = 1, lengthreal = rldf->size(0), lengthcomp = cldf->size(0);
1201 for (d=1; d<
Dim; ++d)
1202 nstrips *= rldf->size(d);
1205 for (
int istrip=0; istrip<nstrips; ++istrip) {
1207 for (
int ilen=0; ilen<lengthreal; ilen+=2) {
1208 localcomp[ilen/2] = Complex_t(localreal[ilen],localreal[ilen+1]);
1216 localreal += lengthreal;
1217 localcomp += lengthcomp;
1229 Complex_t* localdata;
1232 for (idim = 1; idim < nTransformDims; ++idim) {
1234 bool skipTranspose =
false;
1238 if (idim == nTransformDims-1) {
1240 const Domain_t& last_dom = tempLayouts_m[idim]->getDomain();
1246 out_dom[0].sameBase(last_dom[0]) &&
1247 out_dom[0].length() == last_dom[0].length() &&
1248 out_layout.getDistribution(0) ==
SERIAL);
1251 if (!skipTranspose) {
1253 FFTDBG(tmsg <<
"doing complex->complex transpose into field ");
1254 FFTDBG(tmsg <<
"with layout = " << tempFields_m[idim]->getLayout());
1257 (*tempFields_m[idim])[tempLayouts_m[idim]->
getDomain()] =
1258 (*temp)[temp->getLayout().getDomain()];
1263 temp = tempFields_m[idim];
1265 }
else if (idim == nTransformDims-1) {
1270 FFTDBG(tmsg <<
"doing final complex->complex transpose ");
1271 FFTDBG(tmsg <<
"into return ");
1272 FFTDBG(tmsg <<
"with layout = " << g.getLayout());
1275 g[out_dom] = (*temp)[temp->getLayout().getDomain()];
1285 FFTDBG(tmsg <<
"doing complex->complex fft of other dimension .." <<
std::endl);
1288 typename ComplexField_t::const_iterator_if l_i, l_end = temp->end_if();
1289 for (l_i = temp->begin_if(); l_i != l_end; ++l_i) {
1291 ComplexLField_t* ldf = (*l_i).second.get();
1297 localdata = ldf->getP();
1300 int nstrips = 1, length = ldf->size(0);
1301 for (d=1; d<
Dim; ++d)
1302 nstrips *= ldf->size(d);
1304 for (
int istrip=0; istrip<nstrips; ++istrip) {
1310 localdata += length;
1322 FFTDBG(tmsg <<
"Doing cleanup complex->complex transpose ");
1323 FFTDBG(tmsg <<
"into return ");
1324 FFTDBG(tmsg <<
"with layout = " << g.getLayout());
1327 g[out_dom] = (*temp)[temp->getLayout().getDomain()];
1351 template <
size_t Dim,
class T>
1360 const bool& constInput)
1364 const Domain_t& out_dom = out_layout.getDomain();
1379 typename RealField_t::const_iterator_if rl_i = tempR->begin_if();
1382 RealLField_t* rldf = (*rl_i).second.get();
1387 T* localreal = rldf->getP();
1391 for (
size_t d=0; d<
Dim; d++) {
1392 NR_l[d] = (int)rldf->size(d);
1393 NR_g[d] = (int)tempR->getDomain()[d].length();
1396 NC_g[0] = (NC_g[0] / 2) + 1;
1399 int totalreal = tempR->getDomain().size();
1405 for (
typename Layout_t::const_iterator_iv i_s = tempR->getLayout().begin_iv(); i_s != tempR->getLayout().end_iv(); ++i_s) {
1406 Domain_t tmp = (*i_s).second->getDomain();
1407 int node = (*i_s).second->getNode();
1408 idx[node] = tmp[0].min();
1409 idy[node] = tmp[1].min();
1410 idz[node] = tmp[2].min();
1414 for (
typename Layout_t::iterator_dv remote = tempR->getLayout().begin_rdv(); remote != tempR->getLayout().end_rdv(); ++remote) {
1415 Domain_t tmp = (*remote).second->getDomain();
1416 int node = (*remote).second->getNode();
1417 idx[node] = tmp[0].min();
1418 idy[node] = tmp[1].min();
1419 idz[node] = tmp[2].min();
1428 dksbase.callC2RFFT(real_ptr, comp_ptr, nTransformDims, (
int*)NR_g, streamId);
1431 if (direction == +1)
1432 dksbase.callNormalizeC2RFFT(real_ptr, nTransformDims, (
int*)NR_g, streamId);
1435 dksbase.syncDevice();
1442 dksbase.scatter3DDataAsync<
T>(real_ptr, localreal, NR_g, NR_l, id);
1444 dksbase.syncDevice();
1448 dksbase.readDataAsync<
T>(real_ptr, localreal, totalreal, streamId);
1449 dksbase.syncDevice();
1461 dksbase.scatter3DDataAsync<
T>(real_ptr, localreal, NR_g, NR_l, id);
1463 dksbase.syncDevice();
1470 g[out_dom] = (*tempR)[tempR->getLayout().getDomain()];
1479 template <
size_t Dim,
class T>
1485 const bool& constInput)
1493 const Layout_t& in_layout = f.getLayout();
1494 const Domain_t& in_dom = in_layout.getDomain();
1495 const Layout_t& out_layout = g.getLayout();
1496 const Domain_t& out_dom = out_layout.getDomain();
1508 ComplexField_t* temp = &f;
1511 Complex_t* localdata;
1514 for (idim = nTransformDims-1; idim != 0; --idim) {
1518 bool skipTranspose =
false;
1521 if (idim == nTransformDims-1 && !constInput) {
1523 const Domain_t& first_dom = tempLayouts_m[idim]->getDomain();
1526 skipTranspose = ( (in_dom[0].sameBase(first_dom[0])) &&
1527 (in_dom[0].length() == first_dom[0].length()) &&
1528 (in_layout.getDistribution(0) ==
SERIAL) &&
1532 if (!skipTranspose) {
1534 FFTDBG(tmsg <<
"Doing complex->complex transpose into field ");
1535 FFTDBG(tmsg <<
"with layout = "<<tempFields_m[idim]->getLayout()<<
std::endl);
1536 (*tempFields_m[idim])[tempLayouts_m[idim]->
getDomain()] =
1537 (*temp)[temp->getLayout().getDomain()];
1542 temp = tempFields_m[idim];
1545 FFTDBG(tmsg <<
"Doing complex->complex fft of other dimension .." <<
std::endl);
1549 typename ComplexField_t::const_iterator_if l_i, l_end = temp->end_if();
1550 for (l_i = temp->begin_if(); l_i != l_end; ++l_i) {
1553 ComplexLField_t* ldf = (*l_i).second.get();
1559 localdata = ldf->getP();
1562 int nstrips = 1, length = ldf->size(0);
1563 for (d=1; d<
Dim; ++d)
1564 nstrips *= ldf->size(d);
1566 for (
int istrip=0; istrip<nstrips; ++istrip) {
1572 localdata += length;
1583 bool skipTemp =
true;
1586 if (!(out_layout == *tempRLayout_m)) {
1589 for (d=0; d<
Dim; ++d)
1590 if (out_layout.getDistribution(d) != tempRLayout_m->getDistribution(d))
1593 if ( out_layout.numVnodes() != tempRLayout_m->numVnodes() )
1604 tempR = tempRField_m;
1607 if (nTransformDims == 1 && !constInput) {
1611 if (!(in_layout == *tempLayouts_m[0])) {
1614 for (d=0; d<
Dim; ++d)
1615 if (in_layout.getDistribution(d) !=
1616 tempLayouts_m[0]->getDistribution(d))
1619 if ( in_layout.numVnodes() != tempLayouts_m[0]->numVnodes() )
1633 FFTDBG(tmsg <<
"Doing final complex->complex transpose into field ");
1634 FFTDBG(tmsg <<
"with layout = "<<tempFields_m[0]->getLayout()<<
std::endl);
1635 (*tempFields_m[0])[tempLayouts_m[0]->
getDomain()] =
1636 (*temp)[temp->getLayout().getDomain()];
1641 temp = tempFields_m[0];
1645 FFTDBG(tmsg <<
"Doing complex->real fft of final dimension ..." <<
std::endl);
1648 typename RealField_t::const_iterator_if rl_i, rl_end = tempR->end_if();
1649 typename ComplexField_t::const_iterator_if cl_i = temp->begin_if();
1650 for (rl_i = tempR->begin_if(); rl_i != rl_end; ++rl_i, ++cl_i) {
1652 RealLField_t* rldf = (*rl_i).second.get();
1653 ComplexLField_t* cldf = (*cl_i).second.get();
1660 T* localreal = rldf->getP();
1661 Complex_t* localcomp = cldf->getP();
1664 int nstrips = 1, lengthreal = rldf->size(0), lengthcomp = cldf->size(0);
1665 for (d=1; d<
Dim; ++d)
1666 nstrips *= rldf->size(d);
1668 for (
int istrip=0; istrip<nstrips; ++istrip) {
1674 for (
int ilen=0; ilen<lengthreal; ilen+=2) {
1675 localreal[ilen] =
real(localcomp[ilen/2]);
1676 localreal[ilen+1] =
imag(localcomp[ilen/2]);
1680 localreal += lengthreal;
1681 localcomp += lengthcomp;
1694 FFTDBG(tmsg <<
"Doing cleanup real->real transpose into return ");
1696 g[out_dom] = (*tempR)[tempR->getLayout().getDomain()];
1724 const bool transformTheseDims[1U],
const bool& compressTemps)
1726 transformTheseDims, compressTemps),
1727 complexDomain_m(cdomain)
1729 size_t nTransformDims = 1U;
1732 length = rdomain[0].length();
1738 normFact = 1.0 / length;
1741 this->
getEngine().
setup(nTransformDims, &transformType, &length);
1755 const bool& compressTemps)
1757 complexDomain_m(cdomain)
1766 length = rdomain[0].length();
1772 normFact = 1.0 / length;
1798 if ( complexDomain_m[0].length() !=
1799 (domain[0].length()/2 + 1) ) match =
false;
1801 "Domains provided for real and complex Fields are incompatible!");
1806 this->tempRField_m =
new RealField_t(*tempRLayout_m);
1808 if (!this->
compressTemps()) this->tempRField_m->Uncompress();
1815 if (!this->
compressTemps()) this->tempFields_m->Uncompress();
1833 delete tempFields_m;
1834 delete tempLayouts_m;
1835 delete this->tempRField_m;
1836 delete tempRLayout_m;
1849 const bool& constInput)
1856 const Layout_t& in_layout = f.getLayout();
1857 const Domain_t& in_dom = in_layout.getDomain();
1858 const Layout_t& out_layout = g.getLayout();
1859 const Domain_t& out_dom = out_layout.getDomain();
1861 this->
checkDomain(complexDomain_m,out_dom),
true);
1864 RealField_t* tempR = this->tempRField_m;
1867 bool skipTemp =
true;
1869 if ( !(in_layout == *tempRLayout_m) ) skipTemp =
false;
1870 if ( in_layout.getDistribution(0) !=
1871 tempRLayout_m->getDistribution(0) ) skipTemp =
false;
1872 if ( in_layout.numVnodes() != tempRLayout_m->numVnodes() )
1876 if (skipTemp) tempR = &f;
1887 ComplexField_t* temp = tempFields_m;
1889 bool skipFinal =
true;
1891 if ( !(out_layout == *tempLayouts_m) ) skipFinal =
false;
1892 if ( out_layout.getDistribution(0) !=
1893 tempLayouts_m->getDistribution(0) ) skipFinal =
false;
1894 if ( out_layout.numVnodes() != tempLayouts_m->numVnodes() )
1898 if (skipFinal) temp = &g;
1902 typename RealField_t::const_iterator_if rl_i = tempR->begin_if();
1903 typename ComplexField_t::const_iterator_if cl_i = temp->begin_if();
1904 if (rl_i != tempR->end_if() && cl_i != temp->end_if()) {
1906 RealLField_t* rldf = (*rl_i).second.get();
1907 ComplexLField_t* cldf = (*cl_i).second.get();
1912 T* localreal = rldf->getP();
1913 Complex_t* localcomp = cldf->getP();
1915 int lengthreal = rldf->size(0);
1917 for (
int ilen=0; ilen<lengthreal; ilen+=2)
1918 localcomp[ilen/2] = Complex_t(localreal[ilen],localreal[ilen+1]);
1955 const bool& constInput)
1962 const Layout_t& in_layout = f.getLayout();
1963 const Domain_t& in_dom = in_layout.getDomain();
1964 const Layout_t& out_layout = g.getLayout();
1965 const Domain_t& out_dom = out_layout.getDomain();
1970 ComplexField_t* temp = &f;
1974 bool skipFinal =
true;
1976 if ( !(out_layout == *tempRLayout_m) ) skipFinal =
false;
1977 if ( out_layout.getDistribution(0) !=
1978 tempRLayout_m->getDistribution(0) ) skipFinal =
false;
1979 if ( out_layout.numVnodes() != tempRLayout_m->numVnodes() )
1986 tempR = this->tempRField_m;
1988 bool skipTemp =
true;
1993 if ( !(in_layout == *tempLayouts_m) ) skipTemp =
false;
1994 if ( in_layout.getDistribution(0) !=
1995 tempLayouts_m->getDistribution(0) ) skipTemp =
false;
1996 if ( in_layout.numVnodes() != tempLayouts_m->numVnodes() )
2008 (*tempFields_m) = (*temp);
2011 temp = tempFields_m;
2017 typename RealField_t::const_iterator_if rl_i = tempR->begin_if();
2018 typename ComplexField_t::const_iterator_if cl_i = temp->begin_if();
2019 if (rl_i != tempR->end_if() && cl_i != temp->end_if()) {
2021 RealLField_t* rldf = (*rl_i).second.get();
2022 ComplexLField_t* cldf = (*cl_i).second.get();
2027 T* localreal = rldf->getP();
2028 Complex_t* localcomp = cldf->getP();
2030 int lengthreal = rldf->size(0);
2035 for (
int ilen=0; ilen<lengthreal; ilen+=2) {
2036 localreal[ilen] =
real(localcomp[ilen/2]);
2037 localreal[ilen+1] =
imag(localcomp[ilen/2]);
2075 template <
size_t Dim,
class T>
2079 const bool transformTheseDims[Dim],
const bool sineTransformDims[Dim],
2080 const bool& compressTemps)
2082 transformTheseDims, compressTemps),
2083 complexDomain_m(&cdomain)
2088 numSineTransforms_m = 0;
2089 for (d=0; d<
Dim; ++d) {
2090 sineTransformDims_m[d] = sineTransformDims[d];
2091 if (sineTransformDims[d]) {
2093 ++numSineTransforms_m;
2099 int* lengths =
new int[nTransformDims];
2100 for (d=0; d<nTransformDims; ++d)
2104 int* transformTypes =
new int[nTransformDims];
2107 bool foundRC =
false;
2108 for (d=0; d<nTransformDims; ++d) {
2111 normFact /= (2.0 * (lengths[d] + 1));
2113 else if (!foundRC) {
2115 normFact /= lengths[d];
2120 normFact /= lengths[d];
2125 this->
getEngine().
setup(nTransformDims, transformTypes, lengths);
2126 delete [] transformTypes;
2137 template <
size_t Dim,
class T>
2138 FFT<SineTransform,Dim,T>::FFT(
2141 const bool sineTransformDims[Dim],
const bool& compressTemps)
2143 complexDomain_m(&cdomain)
2148 numSineTransforms_m = 0;
2149 for (d=0; d<
Dim; ++d) {
2150 sineTransformDims_m[d] = sineTransformDims[d];
2151 if (sineTransformDims[d]) ++numSineTransforms_m;
2156 for (d=0; d<
Dim; ++d)
2157 lengths[d] = rdomain[d].length();
2160 int transformTypes[
Dim];
2163 bool foundRC =
false;
2164 for (d=0; d<
Dim; ++d) {
2165 if (sineTransformDims_m[d]) {
2167 normFact /= (2.0 * (lengths[d] + 1));
2169 else if (!foundRC) {
2171 normFact /= lengths[d];
2176 normFact /= lengths[d];
2192 template <
size_t Dim,
class T>
2193 FFT<SineTransform,Dim,T>::FFT(
2195 const bool sineTransformDims[Dim],
const bool& compressTemps)
2197 sineTransformDims, compressTemps)
2207 for (d=0; d<
Dim; ++d)
2208 sineTransformDims_m[d] = sineTransformDims[d];
2211 int* lengths =
new int[numSineTransforms_m];
2212 for (d=0; d<numSineTransforms_m; ++d)
2216 int* transformTypes =
new int[numSineTransforms_m];
2219 for (d=0; d<numSineTransforms_m; ++d) {
2221 normFact /= (2.0 * (lengths[d] + 1));
2225 this->
getEngine().
setup(numSineTransforms_m, transformTypes, lengths);
2226 delete [] transformTypes;
2237 template <
size_t Dim,
class T>
2238 FFT<SineTransform,Dim,T>::FFT(
2250 for (d=0; d<
Dim; ++d)
2251 sineTransformDims_m[d] =
true;
2255 for (d=0; d<
Dim; ++d)
2256 lengths[d] = rdomain[d].length();
2259 int transformTypes[
Dim];
2262 for (d=0; d<
Dim; ++d) {
2264 normFact /= (2.0 * (lengths[d] + 1));
2278 template <
size_t Dim,
class T>
2287 size_t d, dim, activeDim = 0;
2296 serialParallel[0] =
SERIAL;
2298 for (d=1; d<
Dim; ++d)
2302 if (nTransformDims > numSineTransforms_m) {
2308 while (d<Dim && !match) {
2309 if (this->
transformDim(d) && !sineTransformDims_m[d]) {
2317 for (d=0; d<
Dim; ++d) {
2318 if (d == activeDim) {
2320 if ( (*complexDomain_m)[d].length() !=
2321 (domain[d].length()/2 + 1) ) match =
false;
2325 if ( (*complexDomain_m)[d].length() !=
2326 domain[d].length() ) match =
false;
2330 "Domains provided for real and complex Fields are incompatible!");
2334 tempRLayouts_m =
new Layout_t*[numSineTransforms_m+1];
2335 tempRFields_m =
new RealField_t*[numSineTransforms_m+1];
2338 for (dim=0; dim<numSineTransforms_m; ++dim, ++icount) {
2340 while (!sineTransformDims_m[icount]) ++icount;
2343 ndip[0] = domain[icount];
2344 for (d=1; d<
Dim; ++d) {
2345 size_t nextDim = icount + d;
2346 if (nextDim >= Dim) nextDim -=
Dim;
2347 ndip[d] = domain[nextDim];
2352 tempRFields_m[dim] =
new RealField_t(*tempRLayouts_m[dim]);
2354 if (!this->
compressTemps()) (*tempRFields_m[dim]).Uncompress();
2358 ndip[0] = domain[activeDim];
2359 for (d=1; d<
Dim; ++d) {
2360 size_t nextDim = activeDim + d;
2361 if (nextDim >= Dim) nextDim -=
Dim;
2362 ndip[d] = domain[nextDim];
2365 tempRLayouts_m[numSineTransforms_m] =
new Layout_t(ndip, serialParallel,
2368 tempRFields_m[numSineTransforms_m] =
2369 new RealField_t(*tempRLayouts_m[numSineTransforms_m]);
2371 if (!this->
compressTemps()) (*tempRFields_m[numSineTransforms_m]).Uncompress();
2374 size_t numComplex = nTransformDims - numSineTransforms_m;
2376 tempLayouts_m =
new Layout_t*[numComplex];
2379 for (dim=0; dim<numComplex; ++dim, ++icount) {
2381 while (!this->
transformDim(icount) || sineTransformDims_m[icount]) ++icount;
2384 ndip[0] = (*complexDomain_m)[icount];
2385 for (d=1; d<
Dim; ++d) {
2386 size_t nextDim = icount + d;
2387 if (nextDim >= Dim) nextDim -=
Dim;
2388 ndip[d] = (*complexDomain_m)[nextDim];
2395 if (!this->
compressTemps()) (*tempFields_m[dim]).Uncompress();
2403 tempRLayouts_m =
new Layout_t*[numSineTransforms_m];
2404 tempRFields_m =
new RealField_t*[numSineTransforms_m];
2406 for (dim=0; dim<numSineTransforms_m; ++dim) {
2410 ndip[0] = domain[activeDim];
2411 for (d=1; d<
Dim; ++d) {
2412 size_t nextDim = activeDim + d;
2413 if (nextDim >= Dim) nextDim -=
Dim;
2414 ndip[d] = domain[nextDim];
2419 tempRFields_m[dim] =
new RealField_t(*tempRLayouts_m[dim]);
2421 if (!this->
compressTemps()) (*tempRFields_m[dim]).Uncompress();
2433 template <
size_t Dim,
class T>
2444 if (nTransformDims > numSineTransforms_m) {
2445 for (d=0; d<numSineTransforms_m+1; ++d) {
2446 delete tempRFields_m[d];
2447 delete tempRLayouts_m[d];
2449 size_t numComplex = nTransformDims - numSineTransforms_m;
2450 for (d=0; d<numComplex; ++d) {
2451 delete tempFields_m[d];
2452 delete tempLayouts_m[d];
2454 delete [] tempFields_m;
2455 delete [] tempLayouts_m;
2458 for (d=0; d<numSineTransforms_m; ++d) {
2459 delete tempRFields_m[d];
2460 delete tempRLayouts_m[d];
2463 delete [] tempRFields_m;
2464 delete [] tempRLayouts_m;
2471 template <
size_t Dim,
class T>
2477 const bool& constInput)
2484 const Layout_t& in_layout = f.getLayout();
2485 const Domain_t& in_dom = in_layout.getDomain();
2486 const Layout_t& out_layout = g.getLayout();
2487 const Domain_t& out_dom = out_layout.getDomain();
2489 this->
checkDomain(*complexDomain_m,out_dom),
true );
2493 int icount, activeDim;
2497 PInsist(nTransformDims>numSineTransforms_m,
2498 "Wrong output Field type for real-to-real transform!!");
2503 RealField_t* tempR = &f;
2510 for (idim = 0; idim != numSineTransforms_m; ++idim, ++icount, ++activeDim) {
2513 while (!sineTransformDims_m[icount]) {
2520 bool skipTranspose =
false;
2523 if (idim == 0 && !constInput) {
2525 const Domain_t& first_dom = tempRLayouts_m[idim]->getDomain();
2528 skipTranspose = ( (in_dom[0].sameBase(first_dom[0])) &&
2529 (in_dom[0].length() == first_dom[0].length()) &&
2530 (in_layout.getDistribution(0) ==
SERIAL) &&
2534 if (!skipTranspose) {
2536 (*tempRFields_m[idim])[tempRLayouts_m[idim]->
getDomain()] =
2537 (*tempR)[tempR->getLayout().getDomain()];
2541 tempR = tempRFields_m[idim];
2547 typename RealField_t::const_iterator_if l_i, l_end = tempR->end_if();
2548 for (l_i = tempR->begin_if(); l_i != l_end; ++l_i) {
2551 RealLField_t* ldf = (*l_i).second.get();
2555 localdataR = ldf->getP();
2558 int nstrips = 1, length = ldf->size(0);
2559 for (d=1; d<
Dim; ++d) nstrips *= ldf->size(d);
2560 for (
int istrip=0; istrip<nstrips; ++istrip) {
2564 localdataR += length;
2575 while (!this->
transformDim(icount) || sineTransformDims_m[icount]) {
2576 if (sineTransformDims_m[icount]) ++activeDim;
2583 int last = numSineTransforms_m;
2584 (*tempRFields_m[last])[tempRLayouts_m[last]->
getDomain()] =
2585 (*tempR)[tempR->getLayout().getDomain()];
2589 tempR = tempRFields_m[last];
2593 ComplexField_t* temp = tempFields_m[0];
2595 int numComplex = nTransformDims-numSineTransforms_m;
2596 if (numComplex == 1) {
2597 bool skipTemp =
true;
2599 if ( !(out_layout == *tempLayouts_m[0]) ) skipTemp =
false;
2600 for (d=0; d<
Dim; ++d) {
2601 if ( out_layout.getDistribution(d) !=
2602 tempLayouts_m[0]->getDistribution(d) ) skipTemp =
false;
2604 if ( out_layout.numVnodes() != tempLayouts_m[0]->numVnodes() )
2608 if (skipTemp) temp = &g;
2614 typename RealField_t::const_iterator_if rl_i, rl_end = tempR->end_if();
2615 typename ComplexField_t::const_iterator_if cl_i = temp->begin_if();
2616 for (rl_i = tempR->begin_if(); rl_i != rl_end; ++rl_i, ++cl_i) {
2618 RealLField_t* rldf = (*rl_i).second.get();
2619 ComplexLField_t* cldf = (*cl_i).second.get();
2624 T* localreal = rldf->getP();
2625 Complex_t* localcomp = cldf->getP();
2627 int nstrips = 1, lengthreal = rldf->size(0), lengthcomp = cldf->size(0);
2629 for (d=1; d<
Dim; ++d) nstrips *= rldf->size(d);
2630 for (
int istrip=0; istrip<nstrips; ++istrip) {
2632 for (
int ilen=0; ilen<lengthreal; ilen+=2)
2633 localcomp[ilen/2] = Complex_t(localreal[ilen],localreal[ilen+1]);
2638 localreal += lengthreal;
2639 localcomp += lengthcomp;
2647 Complex_t* localdata;
2652 for (idim = 1; idim != numComplex; ++idim, ++icount, ++activeDim) {
2655 while (!this->
transformDim(icount) || sineTransformDims_m[icount]) {
2656 if (sineTransformDims_m[icount]) ++activeDim;
2662 bool skipTranspose =
false;
2665 if (idim == numComplex-1) {
2667 const Domain_t& last_dom = tempLayouts_m[idim]->getDomain();
2670 skipTranspose = ( (out_dom[0].sameBase(last_dom[0])) &&
2671 (out_dom[0].length() == last_dom[0].length()) &&
2672 (out_layout.getDistribution(0) ==
SERIAL) &&
2676 if (!skipTranspose) {
2678 (*tempFields_m[idim])[tempLayouts_m[idim]->
getDomain()] =
2679 (*temp)[temp->getLayout().getDomain()];
2683 temp = tempFields_m[idim];
2685 else if (idim == numComplex-1) {
2690 g[out_dom] = (*temp)[temp->getLayout().getDomain()];
2700 typename ComplexField_t::const_iterator_if l_i, l_end = temp->end_if();
2701 for (l_i = temp->begin_if(); l_i != l_end; ++l_i) {
2704 ComplexLField_t* ldf = (*l_i).second.get();
2708 localdata = ldf->getP();
2711 int nstrips = 1, length = ldf->size(0);
2712 for (d=1; d<
Dim; ++d) nstrips *= ldf->size(d);
2713 for (
int istrip=0; istrip<nstrips; ++istrip) {
2717 localdata += length;
2727 g[out_dom] = (*temp)[temp->getLayout().getDomain()];
2742 template <
size_t Dim,
class T>
2748 const bool& constInput)
2755 const Layout_t& in_layout = f.getLayout();
2756 const Domain_t& in_dom = in_layout.getDomain();
2757 const Layout_t& out_layout = g.getLayout();
2758 const Domain_t& out_dom = out_layout.getDomain();
2764 int icount, activeDim;
2771 ComplexField_t* temp = &f;
2773 Complex_t* localdata;
2776 int numComplex = nTransformDims - numSineTransforms_m;
2778 activeDim = nTransformDims-1;
2779 for (idim = numComplex-1; idim != 0; --idim, --icount, --activeDim) {
2782 while (!this->
transformDim(icount) || sineTransformDims_m[icount]) {
2783 if (sineTransformDims_m[icount]) --activeDim;
2789 bool skipTranspose =
false;
2792 if (idim == numComplex-1 && !constInput) {
2794 const Domain_t& first_dom = tempLayouts_m[idim]->getDomain();
2797 skipTranspose = ( (in_dom[0].sameBase(first_dom[0])) &&
2798 (in_dom[0].length() == first_dom[0].length()) &&
2799 (in_layout.getDistribution(0) ==
SERIAL) &&
2803 if (!skipTranspose) {
2805 (*tempFields_m[idim])[tempLayouts_m[idim]->
getDomain()] =
2806 (*temp)[temp->getLayout().getDomain()];
2810 temp = tempFields_m[idim];
2816 typename ComplexField_t::const_iterator_if l_i, l_end = temp->end_if();
2817 for (l_i = temp->begin_if(); l_i != l_end; ++l_i) {
2820 ComplexLField_t* ldf = (*l_i).second.get();
2824 localdata = ldf->getP();
2827 int nstrips = 1, length = ldf->size(0);
2828 for (d=1; d<
Dim; ++d) nstrips *= ldf->size(d);
2829 for (
int istrip=0; istrip<nstrips; ++istrip) {
2833 localdata += length;
2842 while (!this->
transformDim(icount) || sineTransformDims_m[icount]) {
2843 if (sineTransformDims_m[icount]) --activeDim;
2849 RealField_t* tempR = tempRFields_m[numSineTransforms_m];
2851 bool skipTemp =
true;
2852 if (numComplex == 1 && !constInput) {
2856 if ( !(in_layout == *tempLayouts_m[0]) ) skipTemp =
false;
2857 for (d=0; d<
Dim; ++d) {
2858 if ( in_layout.getDistribution(d) !=
2859 tempLayouts_m[0]->getDistribution(d) ) skipTemp =
false;
2861 if ( in_layout.numVnodes() != tempLayouts_m[0]->numVnodes() )
2873 (*tempFields_m[0])[tempLayouts_m[0]->
getDomain()] =
2874 (*temp)[temp->getLayout().getDomain()];
2877 temp = tempFields_m[0];
2883 typename RealField_t::const_iterator_if rl_i, rl_end = tempR->end_if();
2884 typename ComplexField_t::const_iterator_if cl_i = temp->begin_if();
2885 for (rl_i = tempR->begin_if(); rl_i != rl_end; ++rl_i, ++cl_i) {
2887 RealLField_t* rldf = (*rl_i).second.get();
2888 ComplexLField_t* cldf = (*cl_i).second.get();
2893 T* localreal = rldf->getP();
2894 Complex_t* localcomp = cldf->getP();
2896 int nstrips = 1, lengthreal = rldf->size(0), lengthcomp = cldf->size(0);
2898 for (d=1; d<
Dim; ++d) nstrips *= rldf->size(d);
2899 for (
int istrip=0; istrip<nstrips; ++istrip) {
2904 for (
int ilen=0; ilen<lengthreal; ilen+=2) {
2905 localreal[ilen] =
real(localcomp[ilen/2]);
2906 localreal[ilen+1] =
imag(localcomp[ilen/2]);
2909 localreal += lengthreal;
2910 localcomp += lengthcomp;
2927 activeDim = nTransformDims - 1;
2928 for (idim = numSineTransforms_m-1; idim != -1;
2929 --idim, --icount, --activeDim) {
2932 while (!sineTransformDims_m[icount]) {
2939 bool skipTranspose =
false;
2944 const Domain_t& last_dom = tempRLayouts_m[idim]->getDomain();
2947 skipTranspose = ( (out_dom[0].sameBase(last_dom[0])) &&
2948 (out_dom[0].length() == last_dom[0].length()) &&
2949 (out_layout.getDistribution(0) ==
SERIAL) &&
2953 if (!skipTranspose) {
2955 (*tempRFields_m[idim])[tempRLayouts_m[idim]->
getDomain()] =
2956 (*tempR)[tempR->getLayout().getDomain()];
2960 tempR = tempRFields_m[idim];
2962 else if (idim == 0) {
2967 g[out_dom] = (*tempR)[tempR->getLayout().getDomain()];
2977 typename RealField_t::const_iterator_if l_i, l_end = tempR->end_if();
2978 for (l_i = tempR->begin_if(); l_i != l_end; ++l_i) {
2981 RealLField_t* ldf = (*l_i).second.get();
2985 localdataR = ldf->getP();
2988 int nstrips = 1, length = ldf->size(0);
2989 for (d=1; d<
Dim; ++d) nstrips *= ldf->size(d);
2990 for (
int istrip=0; istrip<nstrips; ++istrip) {
2994 localdataR += length;
3004 g[out_dom] = (*tempR)[tempR->getLayout().getDomain()];
3019 template <
size_t Dim,
class T>
3025 const bool& constInput)
3032 const Layout_t& in_layout = f.getLayout();
3033 const Domain_t& in_dom = in_layout.getDomain();
3034 const Layout_t& out_layout = g.getLayout();
3035 const Domain_t& out_dom = out_layout.getDomain();
3045 PInsist(nTransformDims==numSineTransforms_m,
3046 "Wrong output Field type for real-to-complex transform!!");
3051 RealField_t* tempR = &f;
3056 begdim = (direction == +1) ? 0 : static_cast<int>(nTransformDims-1);
3057 enddim = (direction == +1) ? static_cast<int>(nTransformDims) : -1;
3058 for (idim = begdim; idim != enddim; idim+=direction) {
3062 bool skipTranspose =
false;
3065 if (idim == begdim && !constInput) {
3067 const Domain_t& first_dom = tempRLayouts_m[idim]->getDomain();
3070 skipTranspose = ( (in_dom[0].sameBase(first_dom[0])) &&
3071 (in_dom[0].length() == first_dom[0].length()) &&
3072 (in_layout.getDistribution(0) ==
SERIAL) &&
3078 if (idim == enddim-direction) {
3080 const Domain_t& last_dom = tempRLayouts_m[idim]->getDomain();
3083 skipTranspose = ( (out_dom[0].sameBase(last_dom[0])) &&
3084 (out_dom[0].length() == last_dom[0].length()) &&
3085 (out_layout.getDistribution(0) ==
SERIAL) &&
3089 if (!skipTranspose) {
3091 (*tempRFields_m[idim])[tempRLayouts_m[idim]->
getDomain()] =
3092 (*tempR)[tempR->getLayout().getDomain()];
3096 tempR = tempRFields_m[idim];
3098 else if (idim == enddim-direction && tempR != &g) {
3103 g[out_dom] = (*tempR)[tempR->getLayout().getDomain()];
3113 typename RealField_t::const_iterator_if l_i, l_end = tempR->end_if();
3114 for (l_i = tempR->begin_if(); l_i != l_end; ++l_i) {
3117 RealLField_t* ldf = (*l_i).second.get();
3121 localdataR = ldf->getP();
3124 int nstrips = 1, length = ldf->size(0);
3125 for (d=1; d<
Dim; ++d) nstrips *= ldf->size(d);
3126 for (
int istrip=0; istrip<nstrips; ++istrip) {
3130 localdataR += length;
3140 g[out_dom] = (*tempR)[tempR->getLayout().getDomain()];
3155 template <
size_t Dim,
class T>
3165 const Layout_t& in_layout = f.getLayout();
3166 const Domain_t& in_dom = in_layout.getDomain();
3175 PInsist(nTransformDims==numSineTransforms_m,
3176 "Cannot perform real-to-complex transform in-place!!");
3181 RealField_t* tempR = &f;
3186 begdim = (direction == +1) ? 0 : static_cast<int>(nTransformDims-1);
3187 enddim = (direction == +1) ? static_cast<int>(nTransformDims) : -1;
3188 for (idim = begdim; idim != enddim; idim+=direction) {
3192 bool skipTranspose =
false;
3195 if (idim == begdim) {
3197 const Domain_t& first_dom = tempRLayouts_m[idim]->getDomain();
3200 skipTranspose = ( (in_dom[0].sameBase(first_dom[0])) &&
3201 (in_dom[0].length() == first_dom[0].length()) &&
3202 (in_layout.getDistribution(0) ==
SERIAL) &&
3208 if (idim == enddim-direction) {
3210 const Domain_t& last_dom = tempRLayouts_m[idim]->getDomain();
3213 skipTranspose = ( (in_dom[0].sameBase(last_dom[0])) &&
3214 (in_dom[0].length() == last_dom[0].length()) &&
3215 (in_layout.getDistribution(0) ==
SERIAL) &&
3219 if (!skipTranspose) {
3221 (*tempRFields_m[idim])[tempRLayouts_m[idim]->
getDomain()] =
3222 (*tempR)[tempR->getLayout().getDomain()];
3226 tempR = tempRFields_m[idim];
3228 else if (idim == enddim-direction && tempR != &f) {
3233 f[in_dom] = (*tempR)[tempR->getLayout().getDomain()];
3243 typename RealField_t::const_iterator_if l_i, l_end = tempR->end_if();
3244 for (l_i = tempR->begin_if(); l_i != l_end; ++l_i) {
3247 RealLField_t* ldf = (*l_i).second.get();
3251 localdataR = ldf->getP();
3254 int nstrips = 1, length = ldf->size(0);
3255 for (d=1; d<
Dim; ++d) nstrips *= ldf->size(d);
3256 for (
int istrip=0; istrip<nstrips; ++istrip) {
3260 localdataR += length;
3270 f[in_dom] = (*tempR)[tempR->getLayout().getDomain()];
3295 const bool sineTransformDims[1U],
const bool& compressTemps)
3297 sineTransformDims, compressTemps)
3306 length = rdomain[0].length();
3312 normFact = 1.0 / (2.0 * (length + 1));
3328 const bool& compressTemps)
3338 length = rdomain[0].length();
3344 normFact = 1.0 / (2.0 * (length + 1));
3391 delete tempRFields_m;
3392 delete tempRLayouts_m;
3405 const bool& constInput)
3411 const Layout_t& in_layout = f.getLayout();
3412 const Domain_t& in_dom = in_layout.getDomain();
3413 const Layout_t& out_layout = g.getLayout();
3414 const Domain_t& out_dom = out_layout.getDomain();
3419 RealField_t* tempR = &f;
3427 const Domain_t& temp_dom = tempRLayouts_m->getDomain();
3428 bool skipTranspose =
false;
3434 skipTranspose = ( (in_dom[0].sameBase(temp_dom[0])) &&
3435 (in_dom[0].length() == temp_dom[0].length()) &&
3436 (in_layout.numVnodes() == 1) &&
3440 bool skipFinal =
false;
3446 skipFinal = ( (out_dom[0].sameBase(temp_dom[0])) &&
3447 (out_dom[0].length() == temp_dom[0].length()) &&
3448 (out_layout.numVnodes() == 1) &&
3451 if (!skipTranspose) {
3453 (*tempRFields_m) = (*tempR);
3454 tempR = tempRFields_m;
3471 typename RealField_t::const_iterator_if l_i = tempR->begin_if();
3472 if (l_i != tempR->end_if()) {
3475 RealLField_t* ldf = (*l_i).second.get();
3479 localdataR = ldf->getP();
3515 const Layout_t& in_layout = f.getLayout();
3516 const Domain_t& in_dom = in_layout.getDomain();
3520 RealField_t* tempR = &f;
3528 const Domain_t& temp_dom = tempRLayouts_m->getDomain();
3529 bool skipTranspose =
false;
3535 skipTranspose = ( (in_dom[0].sameBase(temp_dom[0])) &&
3536 (in_dom[0].length() == temp_dom[0].length()) &&
3537 (in_layout.numVnodes() == 1) &&
3540 bool skipFinal =
false;
3546 skipFinal = ( (in_dom[0].sameBase(temp_dom[0])) &&
3547 (in_dom[0].length() == temp_dom[0].length()) &&
3548 (in_layout.numVnodes() == 1) &&
3551 if (!skipTranspose) {
3553 (*tempRFields_m) = (*tempR);
3555 tempR = tempRFields_m;
3572 typename RealField_t::const_iterator_if l_i = tempR->begin_if();
3573 if (l_i != tempR->end_if()) {
3576 RealLField_t* ldf = (*l_i).second.get();
3580 localdataR = ldf->getP();
void setup(unsigned numTransformDims, const int *transformTypes, const int *axisLengths)
RegionLayout< T, Dim, Mesh > & getLayout()
unsigned activeDimension(unsigned d) const
get dimension number from list of transformed dimensions
const Domain_t & getDomain(void) const
get our domain
bool transformDim(unsigned d) const
query whether this dimension is to be transformed
FFTBase< 1U, T >::Domain_t Domain_t
FLieGenerator< T, N > real(const FLieGenerator< std::complex< T >, N > &)
Take real part of a complex generator.
FFTBase< 1U, T >::Domain_t Domain_t
unsigned numTransformDims(void) const
query number of transform dimensions
FFTBase< 1U, T >::Domain_t Domain_t
InternalFFT_t & getEngine(void)
access the internal FFT Engine
static MPI_Comm getComm()
Precision_t & getNormFact(void)
get the FFT normalization factor
void callFFT(unsigned transformDim, int direction, Complex_t *data)
bool compressTemps(void) const
do we compress temps?
bool checkDomain(const Domain_t &dom1, const Domain_t &dom2) const
compare indexes of two domains
ParticleSpatialLayout< double, 3, Mesh_t > Layout_t
FLieGenerator< T, N > imag(const FLieGenerator< std::complex< T >, N > &)
Take imaginary part of a complex generator.
Inform & endl(Inform &inf)