Commit 40f46768 authored by PIACIBELLO Cyrille's avatar PIACIBELLO Cyrille

Change FComplexe to FComplex in all files and name of files

parent 077ce97b
......@@ -24,7 +24,7 @@
#include "../../Components/FBasicCell.hpp"
#include "../../Extensions/FExtendCellType.hpp"
#include "../../Utils/FComplexe.hpp"
#include "../../Utils/FComplex.hpp"
/**
* @author Pierre Blanchard (pierre.blanchard@inria.fr)
......@@ -51,17 +51,17 @@ class FInterpCell : public FBasicCell
FReal multipole_exp[NRHS * NVALS * VectorSize]; //< Multipole expansion
FReal local_exp[NLHS * NVALS * VectorSize]; //< Local expansion
// PB: Store multipole and local expansion in Fourier space
FComplexe transformed_multipole_exp[NRHS * NVALS * TransformedVectorSize];
FComplexe transformed_local_exp[NLHS * NVALS * TransformedVectorSize];
FComplex transformed_multipole_exp[NRHS * NVALS * TransformedVectorSize];
FComplex transformed_local_exp[NLHS * NVALS * TransformedVectorSize];
public:
FInterpCell(){
memset(multipole_exp, 0, sizeof(FReal) * NRHS * NVALS * VectorSize);
memset(local_exp, 0, sizeof(FReal) * NLHS * NVALS * VectorSize);
memset(transformed_multipole_exp, 0,
sizeof(FComplexe) * NRHS * NVALS * TransformedVectorSize);
sizeof(FComplex) * NRHS * NVALS * TransformedVectorSize);
memset(transformed_local_exp, 0,
sizeof(FComplexe) * NLHS * NVALS * TransformedVectorSize);
sizeof(FComplex) * NLHS * NVALS * TransformedVectorSize);
}
~FInterpCell() {}
......@@ -90,20 +90,20 @@ public:
}
/** Get Transformed Multipole */
const FComplexe* getTransformedMultipole(const int inRhs) const{
const FComplex* getTransformedMultipole(const int inRhs) const{
return this->transformed_multipole_exp + inRhs*TransformedVectorSize;
}
/** Get Transformed Local */
const FComplexe* getTransformedLocal(const int inRhs) const{
const FComplex* getTransformedLocal(const int inRhs) const{
return this->transformed_local_exp + inRhs*TransformedVectorSize;
}
/** Get Transformed Multipole */
FComplexe* getTransformedMultipole(const int inRhs){
FComplex* getTransformedMultipole(const int inRhs){
return this->transformed_multipole_exp + inRhs*TransformedVectorSize;
}
/** Get Transformed Local */
FComplexe* getTransformedLocal(const int inRhs){
FComplex* getTransformedLocal(const int inRhs){
return this->transformed_local_exp + inRhs*TransformedVectorSize;
}
......@@ -117,9 +117,9 @@ public:
memset(multipole_exp, 0, sizeof(FReal) * NRHS * NVALS * VectorSize);
memset(local_exp, 0, sizeof(FReal) * NLHS * NVALS * VectorSize);
memset(transformed_multipole_exp, 0,
sizeof(FComplexe) * NRHS * NVALS * TransformedVectorSize);
sizeof(FComplex) * NRHS * NVALS * TransformedVectorSize);
memset(transformed_local_exp, 0,
sizeof(FComplexe) * NLHS * NVALS * TransformedVectorSize);
sizeof(FComplex) * NLHS * NVALS * TransformedVectorSize);
}
///////////////////////////////////////////////////////
......@@ -171,7 +171,7 @@ public:
}
static constexpr int GetSize(){
return (NRHS+NLHS)*NVALS*VectorSize * (int) sizeof(FReal) + (NRHS+NLHS)*NVALS*TransformedVectorSize * (int) sizeof(FComplexe);
return (NRHS+NLHS)*NVALS*VectorSize * (int) sizeof(FReal) + (NRHS+NLHS)*NVALS*TransformedVectorSize * (int) sizeof(FComplex);
}
......
......@@ -822,7 +822,7 @@ inline void MutualParticlesRIJK(const FReal sourceX,const FReal sourceY,const FR
#ifdef ScalFMM_USE_SSE
#include "FP2PSse.hpp"
#elif defined(ScalFMM_USE_AVX)
#include "FP2PAvx.hpp"
#include "FP2PAvx.h"
#else
#include "FP2PClassic.hpp"
#endif //Includes
......
......@@ -16,7 +16,7 @@
#ifndef FROTATIONCELL_HPP
#define FROTATIONCELL_HPP
#include "../../Utils/FComplexe.hpp"
#include "../../Utils/FComplex.hpp"
#include "../../Utils/FMemUtils.hpp"
#include "../../Extensions/FExtendCellType.hpp"
......@@ -43,9 +43,9 @@ protected:
static const int LocalSize = ((P+2)*(P+1))/2; // Artimethique suite (n+1)*n/2
//< Multipole vector (static memory)
FComplexe multipole_exp[MultipoleSize]; //< For multipole extenssion
FComplex multipole_exp[MultipoleSize]; //< For multipole extenssion
//< Local vector (static memory)
FComplexe local_exp[LocalSize]; //< For local extenssion
FComplex local_exp[LocalSize]; //< For local extenssion
public:
/** Default constructor
......@@ -75,20 +75,20 @@ public:
}
/** Get Multipole array */
const FComplexe* getMultipole() const {
const FComplex* getMultipole() const {
return multipole_exp;
}
/** Get Local array */
const FComplexe* getLocal() const {
const FComplex* getLocal() const {
return local_exp;
}
/** Get Multipole array */
FComplexe* getMultipole() {
FComplex* getMultipole() {
return multipole_exp;
}
/** Get Local array */
FComplexe* getLocal() {
FComplex* getLocal() {
return local_exp;
}
......@@ -145,7 +145,7 @@ public:
buffer.fillArray(local_exp, LocalSize);
}
static constexpr int GetSize(){
return ((int) sizeof(FComplexe)) * (MultipoleSize + LocalSize);
return ((int) sizeof(FComplex)) * (MultipoleSize + LocalSize);
}
};
......
......@@ -18,7 +18,7 @@
#include "Components/FAbstractKernels.hpp"
#include "Utils/FSmartPointer.hpp"
#include "Utils/FComplexe.hpp"
#include "Utils/FComplex.hpp"
#include "Utils/FMemUtils.hpp"
#include "Utils/FSpherical.hpp"
#include "Utils/FMath.hpp"
......@@ -71,11 +71,11 @@ class FRotationKernel : public FAbstractKernels<CellClass,ContainerClass> {
FSmartPointer<FReal[P+1]> L2LTranslationCoef; //< This contains some precalculated values for L2L translation
///////////// Rotation /////////////////////////////
FComplexe rotationExpMinusImPhi[8][SizeArray]; //< This is the vector use for the rotation around z for the M2M (multipole)
FComplexe rotationExpImPhi[8][SizeArray]; //< This is the vector use for the rotation around z for the L2L (taylor)
FComplex rotationExpMinusImPhi[8][SizeArray]; //< This is the vector use for the rotation around z for the M2M (multipole)
FComplex rotationExpImPhi[8][SizeArray]; //< This is the vector use for the rotation around z for the L2L (taylor)
FComplexe rotationM2LExpMinusImPhi[343][SizeArray]; //< This is the vector use for the rotation around z for the M2L (multipole)
FComplexe rotationM2LExpImPhi[343][SizeArray]; //< This is the vector use for the rotation around z for the M2L (taylor)
FComplex rotationM2LExpMinusImPhi[343][SizeArray]; //< This is the vector use for the rotation around z for the M2L (multipole)
FComplex rotationM2LExpImPhi[343][SizeArray]; //< This is the vector use for the rotation around z for the M2L (taylor)
///////////// Rotation /////////////////////////////
// First we compute the size of the d{l,m,k} matrix.
......@@ -802,11 +802,11 @@ class FRotationKernel : public FAbstractKernels<CellClass,ContainerClass> {
* multipole or local vector.
* The result is copyed in vec.
* Please see the structure of dlmk to understand this function.
* Warning we cast the vec FComplexe array into a FReal array
* Warning we cast the vec FComplex array into a FReal array
*/
static void RotationYWithDlmk(FComplexe vec[], const FReal* dlmkCoef){
static void RotationYWithDlmk(FComplex vec[], const FReal* dlmkCoef){
FReal originalVec[2*SizeArray];
FMemUtils::copyall((FComplexe*)originalVec,vec,SizeArray);
FMemUtils::copyall((FComplex*)originalVec,vec,SizeArray);
// index_lm == atLm(l,m) but progress iteratively to write the result
int index_lm = 0;
for(int l = 0 ; l <= P ; ++l){
......@@ -834,12 +834,12 @@ class FRotationKernel : public FAbstractKernels<CellClass,ContainerClass> {
}
/** This function is computing dest[:] *= src[:]
* it computes inSize FComplexe multiplication
* it computes inSize FComplex multiplication
* to do so we first proceed per 4 and the the inSize%4 rest
*/
static void RotationZVectorsMul(FComplexe* FRestrict dest, const FComplexe* FRestrict src, const int inSize = SizeArray){
const FComplexe*const FRestrict lastElement = dest + inSize;
const FComplexe*const FRestrict intermediateLastElement = dest + (inSize & ~0x3);
static void RotationZVectorsMul(FComplex* FRestrict dest, const FComplex* FRestrict src, const int inSize = SizeArray){
const FComplex*const FRestrict lastElement = dest + inSize;
const FComplex*const FRestrict intermediateLastElement = dest + (inSize & ~0x3);
// first the inSize - inSize%4 elements
for(; dest != intermediateLastElement ;) {
(*dest++) *= (*src++);
......@@ -911,7 +911,7 @@ public:
void P2M(CellClass* const inPole, const ContainerClass* const inParticles ) {
const FReal i_pow_m[4] = {0, FMath::FPiDiv2, FMath::FPi, -FMath::FPiDiv2};
// w is the multipole moment
FComplexe* FRestrict const w = inPole->getMultipole();
FComplex* FRestrict const w = inPole->getMultipole();
// Copying the position is faster than using cell position
const FPoint cellPosition = getLeafCenter(inPole->getCoordinate());
......@@ -975,7 +975,7 @@ public:
// Get the translation coef for this level (same for all child)
const FReal*const coef = M2MTranslationCoef[inLevel];
// A buffer to copy the source w allocated once
FComplexe source_w[SizeArray];
FComplex source_w[SizeArray];
// For all children
for(int idxChild = 0 ; idxChild < 8 ; ++idxChild){
// if child exists
......@@ -988,7 +988,7 @@ public:
RotationYWithDlmk(source_w,DlmkCoefOTheta[idxChild]);
// Translate it
FComplexe target_w[SizeArray];
FComplex target_w[SizeArray];
int index_lm = 0;
for(int l = 0 ; l <= P ; ++l ){
for(int m = 0 ; m <= l ; ++m, ++index_lm ){
......@@ -1029,7 +1029,7 @@ public:
*/
void M2L(CellClass* const FRestrict inLocal, const CellClass* inInteractions[], const int /*inSize*/, const int inLevel) {
// To copy the multipole data allocated once
FComplexe source_w[SizeArray];
FComplex source_w[SizeArray];
// For all children
for(int idxNeigh = 0 ; idxNeigh < 343 ; ++idxNeigh){
// if interaction exits
......@@ -1043,7 +1043,7 @@ public:
RotationYWithDlmk(source_w,DlmkCoefM2LOTheta[idxNeigh]);
// Transfer to u
FComplexe target_u[SizeArray];
FComplex target_u[SizeArray];
int index_lm = 0;
for(int l = 0 ; l <= P ; ++l ){
FReal minus_1_pow_m = 1.0;
......@@ -1089,7 +1089,7 @@ public:
// Get the translation coef for this level (same for all chidl)
const FReal*const coef = L2LTranslationCoef[inLevel];
// To copy the source local allocated once
FComplexe source_u[SizeArray];
FComplex source_u[SizeArray];
// For all children
for(int idxChild = 0 ; idxChild < 8 ; ++idxChild){
// if child exists
......@@ -1102,7 +1102,7 @@ public:
RotationYWithDlmk(source_u,DlmkCoefMTheta[idxChild]);
// Translate
FComplexe target_u[SizeArray];
FComplex target_u[SizeArray];
for(int l = 0 ; l <= P ; ++l ){
for(int m = 0 ; m <= l ; ++m ){
// u{l,m}(r-b) = sum(j=0:P, b^(j-l)/(j-l)! u{j,m}(r);
......@@ -1150,7 +1150,7 @@ public:
void L2P(const CellClass* const inLocal, ContainerClass* const inParticles){
const FReal i_pow_m[4] = {0, FMath::FPiDiv2, FMath::FPi, -FMath::FPiDiv2};
// Take the local value from the cell
const FComplexe* FRestrict const u = inLocal->getLocal();
const FComplex* FRestrict const u = inLocal->getLocal();
// Copying the position is faster than using cell position
const FPoint cellPosition = getLeafCenter(inLocal->getCoordinate());
......
......@@ -18,7 +18,7 @@
#include "../../Components/FAbstractKernels.hpp"
#include "../../Utils/FSmartPointer.hpp"
#include "../../Utils/FComplexe.hpp"
#include "../../Utils/FComplex.hpp"
#include "../../Utils/FMemUtils.hpp"
#include "../../Utils/FSpherical.hpp"
......@@ -192,12 +192,12 @@ class FRotationOriginalKernel : public FAbstractKernels<CellClass,ContainerClass
* The computation is simply a multiplication per a complex number \f$ e^{-i \phi m} \f$
* Phi should be in [0,2pi]
*/
void rotateMultipoleAroundZ(FComplexe vec[], const FReal phi){
FComplexe cell_rotate[SizeArray];
void rotateMultipoleAroundZ(FComplex vec[], const FReal phi){
FComplex cell_rotate[SizeArray];
for(int l = 0 ; l <= P ; ++l){
for(int m = 0 ; m <= l ; ++m ){
// O_{l,m}( \alpha, \beta + \phi ) = e^{-i \phi m} O_{l,m}( \alpha, \beta )
const FComplexe exp_minus_imphi(FMath::Cos(-phi * FReal(m)), FMath::Sin(-phi * FReal(m)));
const FComplex exp_minus_imphi(FMath::Cos(-phi * FReal(m)), FMath::Sin(-phi * FReal(m)));
cell_rotate[atLm(l,m)].equalMul(exp_minus_imphi , vec[atLm(l,m)]);
}
}
......@@ -214,12 +214,12 @@ class FRotationOriginalKernel : public FAbstractKernels<CellClass,ContainerClass
* The computation is simply a multiplication per a complex number \f$ e^{i \phi m} \f$
* Phi should be in [0,2pi]
*/
void rotateTaylorAroundZ(FComplexe vec[], const FReal phi){
FComplexe cell_rotate[SizeArray];
void rotateTaylorAroundZ(FComplex vec[], const FReal phi){
FComplex cell_rotate[SizeArray];
for(int l = 0 ; l <= P ; ++l){
for(int m = 0 ; m <= l ; ++m ){
// M_{l,m}( \alpha, \beta + \phi ) = e^{i \phi m} M_{l,m}( \alpha, \beta )
const FComplexe exp_imphi(FMath::Cos(phi * FReal(m)), FMath::Sin(phi * FReal(m)));
const FComplex exp_imphi(FMath::Cos(phi * FReal(m)), FMath::Sin(phi * FReal(m)));
cell_rotate[atLm(l,m)].equalMul(exp_imphi , vec[atLm(l,m)]);
}
}
......@@ -238,8 +238,8 @@ class FRotationOriginalKernel : public FAbstractKernels<CellClass,ContainerClass
* \f$ O_{l,-m} = \bar{ O_{l,m} } (-1)^m \f$
* Theta should be in [0,pi]
*/
void rotateMultipoleAroundY(FComplexe vec[], const FReal theta){
FComplexe cell_rotate[SizeArray];
void rotateMultipoleAroundY(FComplex vec[], const FReal theta){
FComplex cell_rotate[SizeArray];
for(int l = 0 ; l <= P ; ++l){
for(int m = 0 ; m <= l ; ++m ){
FReal w_lkm_real = 0.0;
......@@ -278,8 +278,8 @@ class FRotationOriginalKernel : public FAbstractKernels<CellClass,ContainerClass
* \f$ M_{l,-m} = \bar{ M_{l,m} } (-1)^m \f$
* Theta should be in [0,pi]
*/
void rotateTaylorAroundY(FComplexe vec[], const FReal theta){
FComplexe cell_rotate[SizeArray];
void rotateTaylorAroundY(FComplex vec[], const FReal theta){
FComplex cell_rotate[SizeArray];
for(int l = 0 ; l <= P ; ++l){
for(int m = 0 ; m <= l ; ++m ){
FReal w_lkm_real = 0.0;
......@@ -313,7 +313,7 @@ class FRotationOriginalKernel : public FAbstractKernels<CellClass,ContainerClass
*
* Rotation are not commutative so we have to do it in the right order
*/
void rotateMultipole(FComplexe vec[], const FReal azimuth, const FReal inclination){
void rotateMultipole(FComplex vec[], const FReal azimuth, const FReal inclination){
rotateMultipoleAroundZ(vec,(FMath::FPiDiv2 + azimuth));
rotateMultipoleAroundY(vec,inclination);
}
......@@ -324,7 +324,7 @@ class FRotationOriginalKernel : public FAbstractKernels<CellClass,ContainerClass
*
* Rotation are not commutative so we have to do it in the right order
*/
void deRotateMultipole(FComplexe vec[], const FReal azimuth, const FReal inclination){
void deRotateMultipole(FComplex vec[], const FReal azimuth, const FReal inclination){
rotateMultipoleAroundY(vec,-inclination);
rotateMultipoleAroundZ(vec,-(FMath::FPiDiv2 + azimuth));
}
......@@ -336,7 +336,7 @@ class FRotationOriginalKernel : public FAbstractKernels<CellClass,ContainerClass
*
* Rotation are not commutative so we have to do it in the right order
*/
void rotateTaylor(FComplexe vec[], const FReal azimuth, const FReal inclination){
void rotateTaylor(FComplex vec[], const FReal azimuth, const FReal inclination){
rotateTaylorAroundZ(vec,(FMath::FPiDiv2 + azimuth));
rotateTaylorAroundY(vec,inclination);
}
......@@ -347,7 +347,7 @@ class FRotationOriginalKernel : public FAbstractKernels<CellClass,ContainerClass
*
* Rotation are not commutative so we have to do it in the right order
*/
void deRotateTaylor(FComplexe vec[], const FReal azimuth, const FReal inclination){
void deRotateTaylor(FComplex vec[], const FReal azimuth, const FReal inclination){
rotateTaylorAroundY(vec,-inclination);
rotateTaylorAroundZ(vec,-(FMath::FPiDiv2 + azimuth));
}
......@@ -446,7 +446,7 @@ public:
void P2M(CellClass* const inPole, const ContainerClass* const inParticles ) {
const FReal i_pow_m[4] = {0, FMath::FPiDiv2, FMath::FPi, -FMath::FPiDiv2};
// w is the multipole moment
FComplexe* FRestrict const w = inPole->getMultipole();
FComplex* FRestrict const w = inPole->getMultipole();
// Copying the position is faster than using cell position
const FPoint cellPosition = getLeafCenter(inPole->getCoordinate());
......@@ -498,7 +498,7 @@ public:
*/
void M2M(CellClass* const FRestrict inPole, const CellClass*const FRestrict *const FRestrict inChildren, const int inLevel) {
// A buffer to copy the source w allocated once
FComplexe source_w[SizeArray];
FComplex source_w[SizeArray];
// For all children
for(int idxChild = 0 ; idxChild < 8 ; ++idxChild){
// if child exists
......@@ -512,7 +512,7 @@ public:
const FReal b = -sph.getR();
// Translate it
FComplexe target_w[SizeArray];
FComplex target_w[SizeArray];
for(int l = 0 ; l <= P ; ++l ){
for(int m = 0 ; m <= l ; ++m ){
// w{l,m}(a+b) = sum(j=m:l, b^(l-j)/(l-j)! w{j,m}(a)
......@@ -549,7 +549,7 @@ public:
*/
void M2L(CellClass* const FRestrict inLocal, const CellClass* inInteractions[], const int /*inSize*/, const int inLevel) {
// To copy the multipole data allocated once
FComplexe source_w[SizeArray];
FComplex source_w[SizeArray];
// For all children
for(int idxNeigh = 0 ; idxNeigh < 343 ; ++idxNeigh){
// if interaction exits
......@@ -563,7 +563,7 @@ public:
const FReal b = sph.getR();
// Transfer to u
FComplexe target_u[SizeArray];
FComplex target_u[SizeArray];
for(int l = 0 ; l <= P ; ++l ){
for(int m = 0 ; m <= l ; ++m ){
// u{l,m}(a-b) = sum(j=|m|:P-l, (j+l)!/b^(j+l+1) w{j,-m}(a)
......@@ -601,7 +601,7 @@ public:
*/
void L2L(const CellClass* const FRestrict inLocal, CellClass* FRestrict *const FRestrict inChildren, const int inLevel) {
// To copy the source local allocated once
FComplexe source_u[SizeArray];
FComplex source_u[SizeArray];
// For all children
for(int idxChild = 0 ; idxChild < 8 ; ++idxChild){
// if child exists
......@@ -615,7 +615,7 @@ public:
const FReal b = sph.getR();
// Translate
FComplexe target_u[SizeArray];
FComplex target_u[SizeArray];
for(int l = 0 ; l <= P ; ++l ){
for(int m = 0 ; m <= l ; ++m ){
// u{l,m}(r-b) = sum(j=0:P, b^(j-l)/(j-l)! u{j,m}(r);
......@@ -660,7 +660,7 @@ public:
void L2P(const CellClass* const inLocal, ContainerClass* const inParticles){
const FReal i_pow_m[4] = {0, FMath::FPiDiv2, FMath::FPi, -FMath::FPiDiv2};
// Take the local value from the cell
const FComplexe* FRestrict const u = inLocal->getLocal();
const FComplex* FRestrict const u = inLocal->getLocal();
// Copying the position is faster than using cell position
const FPoint cellPosition = getLeafCenter(inLocal->getCoordinate());
......
......@@ -17,7 +17,7 @@
#define FHARMONIC_HPP
#include "../../Utils/FGlobal.hpp"
#include "../../Utils/FComplexe.hpp"
#include "../../Utils/FComplex.hpp"
#include "../../Utils/FSpherical.hpp"
#include "../../Utils/FNoCopyable.hpp"
......@@ -30,11 +30,11 @@ class FHarmonic : public FNoAssignement {
const int expSize; //< Number of elements in the expansion expSize = (p+1)^2
const int nExpSize; //<
FComplexe* harmonic;//< Harmonic Result
FComplexe* cosSin; //< Cos/Sin precomputed values
FComplex* harmonic;//< Harmonic Result
FComplex* cosSin; //< Cos/Sin precomputed values
FReal* legendre;//< Legendre results
FComplexe* thetaDerivatedResult; //< the theta derivated result
FComplex* thetaDerivatedResult; //< the theta derivated result
FReal* sphereHarmoInnerCoef; //< sphere innter pre computed coefficients
FReal* sphereHarmoOuterCoef; //< sphere outer pre computed coefficients
//!
......@@ -45,10 +45,10 @@ class FHarmonic : public FNoAssignement {
/** Allocate and init */
void allocAndInit(){
harmonic = new FComplexe[expSize];
cosSin = new FComplexe[devP + 1];
harmonic = new FComplex[expSize];
cosSin = new FComplex[devP + 1];
legendre = new FReal[expSize];
thetaDerivatedResult = new FComplexe[expSize];
thetaDerivatedResult = new FComplex[expSize];
// Pre compute coef
sphereHarmoOuterCoef = new FReal[devP + 1];
......@@ -176,35 +176,35 @@ public:
return nExpSize;
}
FComplexe* result(){
FComplex* result(){
return harmonic;
}
const FComplexe* result() const {
const FComplex* result() const {
return harmonic;
}
FComplexe& result(const int index){
FComplex& result(const int index){
return harmonic[index];
}
const FComplexe& result(const int index) const{
const FComplex& result(const int index) const{
return harmonic[index];
}
FComplexe* resultThetaDerivated(){
FComplex* resultThetaDerivated(){
return thetaDerivatedResult;
}
const FComplexe* resultThetaDerivated() const {
const FComplex* resultThetaDerivated() const {
return thetaDerivatedResult;
}
FComplexe& resultThetaDerivated(const int index){
FComplex& resultThetaDerivated(const int index){
return thetaDerivatedResult[index];
}
const FComplexe& resultThetaDerivated(const int index) const{
const FComplex& resultThetaDerivated(const int index) const{
return thetaDerivatedResult[index];
}
......
......@@ -34,8 +34,8 @@ protected:
const int FF_MATRIX_COLUMN_DIM; //< The blas matrix number of columns
const int FF_MATRIX_SIZE; //< The blas matrix size
FComplexe* temporaryMultiSource; //< To perform the M2L without allocating at each call
FSmartPointer<FComplexe**> preM2LTransitions; //< The pre-computation for the M2L based on the level and the 189 possibilities
FComplex* temporaryMultiSource; //< To perform the M2L without allocating at each call
FSmartPointer<FComplex**> preM2LTransitions; //< The pre-computation for the M2L based on the level and the 189 possibilities
/** To access te precomputed M2L transfer matrixes */
int indexM2LTransition(const int idxX,const int idxY,const int idxZ) const {
......@@ -48,17 +48,17 @@ protected:
FHarmonic blasHarmonic(Parent::devP * 2);
// Matrix to fill and then transposed
FComplexe*const workMatrix = new FComplexe[FF_MATRIX_SIZE];
FComplex*const workMatrix = new FComplex[FF_MATRIX_SIZE];
// M2L transfer, there is a maximum of 3 neighbors in each direction,
// so 6 in each dimension
FReal treeWidthAtLevel = Parent::boxWidth;
preM2LTransitions = new FComplexe**[Parent::treeHeight];
memset(preM2LTransitions.getPtr(), 0, sizeof(FComplexe**) * (Parent::treeHeight));
preM2LTransitions = new FComplex**[Parent::treeHeight];
memset(preM2LTransitions.getPtr(), 0, sizeof(FComplex**) * (Parent::treeHeight));
for(int idxLevel = 0 ; idxLevel < Parent::treeHeight ; ++idxLevel ){
preM2LTransitions[idxLevel] = new FComplexe*[(7 * 7 * 7)];
memset(preM2LTransitions[idxLevel], 0, sizeof(FComplexe*) * (7*7*7));
preM2LTransitions[idxLevel] = new FComplex*[(7 * 7 * 7)];
memset(preM2LTransitions[idxLevel], 0, sizeof(FComplex*) * (7*7*7));
for(int idxX = -3 ; idxX <= 3 ; ++idxX ){
for(int idxY = -3 ; idxY <= 3 ; ++idxY ){
......@@ -69,8 +69,8 @@ protected:
blasHarmonic.computeOuter(FSpherical(relativePos));
// Reset Matrix
FMemUtils::setall<FComplexe>(workMatrix, FComplexe(), FF_MATRIX_SIZE);
FComplexe* FRestrict fillTransfer = workMatrix;
FMemUtils::setall<FComplex>(workMatrix, FComplex(), FF_MATRIX_SIZE);
FComplex* FRestrict fillTransfer = workMatrix;
for(int M = 0 ; M <= Parent::devP ; ++M){
for (int m = 0 ; m <= M ; ++m){
......@@ -92,7 +92,7 @@ protected:
}
// Transpose and copy result
FComplexe*const matrix = new FComplexe[FF_MATRIX_SIZE];
FComplex*const matrix = new FComplex[FF_MATRIX_SIZE];
for(int idxRow = 0 ; idxRow < FF_MATRIX_ROW_DIM ; ++idxRow){
for(int idxCol = 0 ; idxCol < FF_MATRIX_COLUMN_DIM ; ++idxCol){
matrix[idxCol * FF_MATRIX_ROW_DIM + idxRow] = workMatrix[idxCol + idxRow * FF_MATRIX_COLUMN_DIM];
......@@ -101,8 +101,8 @@ protected:
//
// Single Layer
//
std::cout << std::endl ;
FComplexe Czero(0.,0.);
// std::cout << std::endl ;
FComplex Czero(0.,0.);
int idxRow = 0 ;
for(int j =0 ; j<= Parent::devP ; ++j ){ // Row
for(int k=0; k<=j ; ++k){ // Row
......@@ -148,7 +148,7 @@ public:
: Parent(inDevP, inTreeHeight, inBoxWidth, inBoxCenter),
FF_MATRIX_ROW_DIM(Parent::harmonic.getExpSize()), FF_MATRIX_COLUMN_DIM(Parent::harmonic.getNExpSize()),
FF_MATRIX_SIZE(FF_MATRIX_ROW_DIM * FF_MATRIX_COLUMN_DIM),
temporaryMultiSource(new FComplexe[FF_MATRIX_COLUMN_DIM]),
temporaryMultiSource(new FComplex[FF_MATRIX_COLUMN_DIM]),
preM2LTransitions(nullptr){
allocAndInit();
}
......@@ -158,7 +158,7 @@ public:
: Parent(other),
FF_MATRIX_ROW_DIM(other.FF_MATRIX_ROW_DIM), FF_MATRIX_COLUMN_DIM(other.FF_MATRIX_COLUMN_DIM),
FF_MATRIX_SIZE(other.FF_MATRIX_SIZE),
temporaryMultiSource(new FComplexe[FF_MATRIX_COLUMN_DIM]),
temporaryMultiSource(new FComplex[FF_MATRIX_COLUMN_DIM]),
preM2LTransitions(other.preM2LTransitions) {
}
......@@ -186,7 +186,7 @@ public:
// For all neighbors compute M2L
for(int idxNeigh = 0 ; idxNeigh < 343 ; ++idxNeigh){
if( distantNeighbors[idxNeigh] ){
const FComplexe* const transitionVector = preM2LTransitions[inLevel][idxNeigh];
const FComplex* const transitionVector = preM2LTransitions[inLevel][idxNeigh];
multipoleToLocal(pole->getLocal(), distantNeighbors[idxNeigh]->getMultipole(), transitionVector);
}
}
......@@ -196,7 +196,7 @@ public:
/** preExpNExp
* @param exp an exponent vector to create an computable vector
*/
void preExpNExp(FComplexe* const exp) const {
void preExpNExp(FComplex* const exp) const {
for(int j = Parent::devP; j>= 0 ; --j){
// Position in 'exp': (j*(j+1)*0.5) + k
// Position in 'nexp': j*(j+1) + k
......@@ -241,10 +241,10 @@ public:
* }
* }
*/
void multipoleToLocal(FComplexe*const FRestrict local_exp, const FComplexe* const FRestrict multipole_exp_src,
const FComplexe* const FRestrict M2L_Outer_transfer){
void multipoleToLocal(FComplex*const FRestrict local_exp, const FComplex* const FRestrict multipole_exp_src,
const FComplex* const FRestrict M2L_Outer_transfer){
// Copy original vector and compute exp2nexp
FMemUtils::copyall<FComplexe>(temporaryMultiSource, multipole_exp_src, CellClass::GetPoleSize());
FMemUtils::copyall<FComplex>(temporaryMultiSource, multipole_exp_src, CellClass::GetPoleSize());
// Get a computable vector
preExpNExp(temporaryMultiSource);
......@@ -254,41 +254,41 @@ public:
FF_MATRIX_ROW_DIM,
FF_MATRIX_COLUMN_DIM,
one,
FComplexe::ToFReal(M2L_Outer_transfer),
FComplexe::ToFReal(temporaryMultiSource),
FComplexe::ToFReal(local_exp));
FComplex::ToFReal(M2L_Outer_transfer),
FComplex::ToFReal(temporaryMultiSource),
FComplex::ToFReal(local_exp));
#ifdef DEBUG_SPHERICAL_M2L
// #ifdef DEBUG_SPHERICAL_M2L
std::cout << "\n ====== Multipole expansion ====== \n"<<std::endl;
// std::cout << "\n ====== Multipole expansion ====== \n"<<std::endl;
for(int idxCol =0 ;idxCol< FF_MATRIX_COLUMN_DIM ; ++idxCol ){ // Col
std::cout << temporaryMultiSource[idxCol] <<" ";
}
std::cout << std::endl ;
// for(int idxCol =0 ;idxCol< FF_MATRIX_COLUMN_DIM ; ++idxCol ){ // Col
// std::cout << temporaryMultiSource[idxCol] <<" ";
// }
// std::cout << std::endl ;
std::cout << "\n ====== MultipolToLocal MatrixTransfer ====== \n"<<std::endl;
std::cout << " FF_MATRIX_ROW_DIM: " << FF_MATRIX_ROW_DIM<<std::endl;
std::cout << " FF_MATRIX_COLUMN_DIM: " << FF_MATRIX_COLUMN_DIM<<std::endl;
for(int idxRow =0 ;idxRow< FF_MATRIX_ROW_DIM ; ++idxRow ){ // Row
std::cout << "Row="<<idxRow<<" : " ;
for(int idxCol =0 ;idxCol< FF_MATRIX_COLUMN_DIM ; ++idxCol ){ // Col
std::cout << M2L_Outer_transfer[idxCol * FF_MATRIX_ROW_DIM + idxRow] <<" ";
}
std::cout << std::endl ;
}
std::cout << std::endl ;
// std::cout << "\n ====== MultipolToLocal MatrixTransfer ====== \n"<<std::endl;
// std::cout << " FF_MATRIX_ROW_DIM: " << FF_MATRIX_ROW_DIM<<std::endl;
// std::cout << " FF_MATRIX_COLUMN_DIM: " << FF_MATRIX_COLUMN_DIM<<std::endl;
// for(int idxRow =0 ;idxRow< FF_MATRIX_ROW_DIM ; ++idxRow ){ // Row
// std::cout << "Row="<<idxRow<<" : " ;
// for(int idxCol =0 ;idxCol< FF_MATRIX_COLUMN_DIM ; ++idxCol ){ // Col
// std::cout << M2L_Outer_transfer[idxCol * FF_MATRIX_ROW_DIM + idxRow] <<" ";
// }
// std::cout << std::endl ;
// }
// std::cout << std::endl ;
std::cout << "\n ====== Local expansion ====== \n"<<std::endl;
// std::cout << "\n ====== Local expansion ====== \n"<<std::endl;
for(int idxCol =0 ;idxCol< FF_MATRIX_ROW_DIM ; ++idxCol ){ // Col
std::cout << local_exp[idxCol] <<" ";
}
std::cout << std::endl ;
// for(int idxCol =0 ;idxCol< FF_MATRIX_ROW_DIM ; ++idxCol ){ // Col
// std::cout << local_exp[idxCol] <<" ";
// }
// std::cout << std::endl ;
std::cout << "============================ \n"<<std::endl;
// std::cout << "============================ \n"<<std::endl;
#endif
// #endif
}
};
......
......@@ -33,9 +33,9 @@ protected:
/** A interaction properties */