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);
}
......
This diff is collapsed.
......@@ -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);
}
};
......
This diff is collapsed.
......@@ -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];
}
......
......@@ -33,9 +33,9 @@ protected:
/** A interaction properties */
struct ComputationPair {
const FComplexe* FRestrict pole;
FComplexe* FRestrict local;
explicit ComputationPair(const FComplexe* const inPole = 0, FComplexe*const inLocal = 0)
const FComplex* FRestrict pole;
FComplex* FRestrict local;
explicit ComputationPair(const FComplex* const inPole = 0, FComplex*const inLocal = 0)
: pole(inPole), local(inLocal) {}
};
......@@ -45,9 +45,9 @@ protected:
const int BlockSize; //< The size of a block
FComplexe*const multipoleMatrix; //< To copy all the multipole vectors
FComplexe*const localMatrix; //< To save all the local vectors result
FSmartPointer<FComplexe**> preM2LTransitions; //< The pre-computation for the M2L based on the level and the 189 possibilities
FComplex*const multipoleMatrix; //< To copy all the multipole vectors
FComplex*const localMatrix; //< To save all the local vectors result
FSmartPointer<FComplex**> preM2LTransitions; //< The pre-computation for the M2L based on the level and the 189 possibilities
FVector<ComputationPair> interactions[343]; //< All the current interaction
......@@ -63,17 +63,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 ){
......@@ -84,8 +84,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){
......@@ -107,7 +107,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];
......@@ -138,8 +138,8 @@ public:
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),
BlockSize(inBlockSize),
multipoleMatrix(new FComplexe[inBlockSize * FF_MATRIX_COLUMN_DIM]),
localMatrix(new FComplexe[inBlockSize * FF_MATRIX_ROW_DIM]),
multipoleMatrix(new FComplex[inBlockSize * FF_MATRIX_COLUMN_DIM]),
localMatrix(new FComplex[inBlockSize * FF_MATRIX_ROW_DIM]),
preM2LTransitions(nullptr){
allocAndInit();
}
......@@ -150,8 +150,8 @@ public:
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),
BlockSize(other.BlockSize),
multipoleMatrix(new FComplexe[other.BlockSize * FF_MATRIX_COLUMN_DIM]),
localMatrix(new FComplexe[other.BlockSize * FF_MATRIX_ROW_DIM]),
multipoleMatrix(new FComplex[other.BlockSize * FF_MATRIX_COLUMN_DIM]),
localMatrix(new FComplex[other.BlockSize * FF_MATRIX_ROW_DIM]),
preM2LTransitions(other.preM2LTransitions) {
}
......@@ -201,7 +201,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
......@@ -240,10 +240,10 @@ public:
*
*Remark: here we have always j+n >= |-k-l|
*
* const FComplexe*const M2LTransfer = preM2LTransitions[inLevel][interactionIndex];
* const FComplex*const M2LTransfer = preM2LTransitions[inLevel][interactionIndex];
* for(int idxK = 0 ; idxK < interactions[interactionIndex].getSize() ; ++idxK){
* for(int idxRow = 0 ; idxRow < FF_MATRIX_ROW_DIM ; ++idxRow){
* FComplexe compute;
* FComplex compute;
* for(int idxCol = 0 ; idxCol < FF_MATRIX_COLUMN_DIM ; ++idxCol){
* compute.addMul(M2LTransfer[idxCol * FF_MATRIX_ROW_DIM + idxRow], multipoleMatrix[idxCol + idxK * FF_MATRIX_COLUMN_DIM]);
* }
......@@ -254,7 +254,7 @@ public:
void multipoleToLocal(const int interactionIndex, const int inLevel){
for(int idxInter = 0 ; idxInter < interactions[interactionIndex].getSize() ; ++idxInter){
// Copy original vector and compute exp2nexp
FMemUtils::copyall<FComplexe>(&multipoleMatrix[idxInter * FF_MATRIX_COLUMN_DIM],
FMemUtils::copyall<FComplex>(&multipoleMatrix[idxInter * FF_MATRIX_COLUMN_DIM],
interactions[interactionIndex][idxInter].pole, FF_MATRIX_COLUMN_DIM);
// Get a computable vector
......@@ -268,15 +268,15 @@ public:
FF_MATRIX_COLUMN_DIM,
interactions[interactionIndex].getSize(),
one,
FComplexe::ToFReal(preM2LTransitions[inLevel][interactionIndex]),
FComplex::ToFReal(preM2LTransitions[inLevel][interactionIndex]),
FF_MATRIX_ROW_DIM,
FComplexe::ToFReal(multipoleMatrix),
FComplex::ToFReal(multipoleMatrix),
FF_MATRIX_COLUMN_DIM,
FComplexe::ToFReal(localMatrix),
FComplex::ToFReal(localMatrix),
FF_MATRIX_ROW_DIM);
for(int idxInter = 0 ; idxInter < interactions[interactionIndex].getSize() ; ++idxInter){
FMemUtils::addall<FComplexe>(interactions[interactionIndex][idxInter].local, &localMatrix[idxInter * FF_MATRIX_ROW_DIM], FF_MATRIX_ROW_DIM);
FMemUtils::addall<FComplex>(interactions[interactionIndex][idxInter].local, &localMatrix[idxInter * FF_MATRIX_ROW_DIM], FF_MATRIX_ROW_DIM);
}
interactions[interactionIndex].clear();
......
......@@ -16,7 +16,7 @@
#ifndef FSPHERICALCELL_HPP
#define FSPHERICALCELL_HPP
#include "../../Utils/FComplexe.hpp"
#include "../../Utils/FComplex.hpp"
#include "../../Utils/FMemUtils.hpp"
#include "../../Extensions/FExtendCellType.hpp"
......@@ -33,8 +33,8 @@ protected:
static int PoleSize;
static bool UseBlas;
FComplexe* multipole_exp; //< For multipole extenssion
FComplexe* local_exp; //< For local extenssion
FComplex* multipole_exp; //< For multipole extenssion
FComplex* local_exp; //< For local extenssion
public:
static void Init(const int inDevP, const bool inUseBlas = false){
......@@ -62,15 +62,15 @@ public:
/** Default constructor */
FSphericalCell()
: multipole_exp(nullptr), local_exp(nullptr){
multipole_exp = new FComplexe[PoleSize];
local_exp = new FComplexe[LocalSize];
multipole_exp = new FComplex[PoleSize];
local_exp = new FComplex[LocalSize];
}
/** Constructor */
FSphericalCell(const FSphericalCell& other)
: multipole_exp(nullptr), local_exp(nullptr){
multipole_exp = new FComplexe[PoleSize];
local_exp = new FComplexe[LocalSize];
multipole_exp = new FComplex[PoleSize];
local_exp = new FComplex[LocalSize];
(*this) = other;
}
......@@ -88,20 +88,20 @@ public:
}
/** Get Multipole */
const FComplexe* getMultipole() const {
const FComplex* getMultipole() const {
return multipole_exp;
}
/** Get Local */
const FComplexe* getLocal() const {
const FComplex* getLocal() const {
return local_exp;
}
/** Get Multipole */
FComplexe* getMultipole() {
FComplex* getMultipole() {
return multipole_exp;
}
/** Get Local */
FComplexe* getLocal() {
FComplex* getLocal() {
return local_exp;
}
......@@ -153,7 +153,7 @@ public:
}
static int GetSize(){
return (int) sizeof(FComplexe) * (PoleSize+LocalSize);
return (int) sizeof(FComplex) * (PoleSize+LocalSize);
}
};
......
This diff is collapsed.
......@@ -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)
......@@ -47,17 +47,17 @@ class FUnifCell : 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:
FUnifCell(){
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);
}
~FUnifCell() {}
......@@ -86,20 +86,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;
}
......@@ -113,9 +113,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);
}
///////////////////////////////////////////////////////
......@@ -167,7 +167,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);
}
template <class StreamClass>
......
......@@ -149,7 +149,7 @@ public:
FUnifTensor<ORDER>::setRoots(AbstractBaseClass::getCellCenter(TargetCell->getCoordinate(),TreeLevel), CellWidth, X);
for(int idxRhs = 0 ; idxRhs < NVALS ; ++idxRhs){
// FComplexe *const TransformedLocalExpansion = TargetCell->getTransformedLocal(idxRhs);
// FComplex *const TransformedLocalExpansion = TargetCell->getTransformedLocal(idxRhs);
for (int idx=0; idx<343; ++idx){
if (SourceCells[idx]){
......
......@@ -139,7 +139,7 @@ public:
const FReal scale(MatrixKernel->getScaleFactor(CellWidth));
for(int idxRhs = 0 ; idxRhs < NVALS ; ++idxRhs){
FComplexe *const TransformedLocalExpansion = TargetCell->getTransformedLocal(idxRhs);
FComplex *const TransformedLocalExpansion = TargetCell->getTransformedLocal(idxRhs);
for (int idx=0; idx<343; ++idx){
if (SourceCells[idx]){
......
......@@ -27,7 +27,7 @@
#include "../../Utils/FTic.hpp"
#include "../../Utils/FDft.hpp"
#include "../../Utils/FComplexe.hpp"
#include "../../Utils/FComplex.hpp"
#include "./FUnifTensor.hpp"
......@@ -35,7 +35,7 @@