void Interpolator<Complex>::
interpolate(const MElement& element,
const FunctionSpace& fs,
const std::vector<Complex>& coef,
const fullVector<double>& xyz,
fullVector<Complex>& value){
// Real & Imaginary //
const size_t size = coef.size();
vector<double> coefReal(size);
vector<double> coefImag(size);
for(size_t i = 0; i < size; i++)
coefReal[i] = coef[i].real();
for(size_t i = 0; i < size; i++)
coefImag[i] = coef[i].imag();
// Scalar or Vector ?
const bool isScalar = fs.isScalar();
if(isScalar){
// Function Space Scalar
const FunctionSpaceScalar* fsScalar =
static_cast<const FunctionSpaceScalar*>(&fs);
// Alloc value
value.resize(1);
// Interpolate
double real = fsScalar->interpolate(element, coefReal, xyz);
double imag = fsScalar->interpolate(element, coefImag, xyz);
// Complex
value(0) = Complex(real, imag);
}
else{
// Function Space Vector
const FunctionSpaceVector* fsVector =
static_cast<const FunctionSpaceVector*>(&fs);
// Alloc value
value.resize(3);
// Interpolate
fullVector<double> real = fsVector->interpolate(element, coefReal, xyz);
fullVector<double> imag = fsVector->interpolate(element, coefImag, xyz);
// Complex
value(0) = Complex(real(0), imag(0));
value(1) = Complex(real(1), imag(1));
value(2) = Complex(real(2), imag(2));
}
}
void Interpolator<double>::
interpolate(const MElement& element,
const FunctionSpace& fs,
const std::vector<double>& coef,
const fullVector<double>& xyz,
fullVector<double>& value){
// Scalar or Vector ?
const bool isScalar = fs.isScalar();
if(isScalar){
// Function Space Scalar
const FunctionSpaceScalar* fsScalar =
static_cast<const FunctionSpaceScalar*>(&fs);
// Alloc value
value.resize(1);
// Interpolate
value(0) = fsScalar->interpolate(element, coef, xyz);
}
else{
// Function Space Vector
const FunctionSpaceVector* fsVector =
static_cast<const FunctionSpaceVector*>(&fs);
// Alloc & Interpolate
value = fsVector->interpolate(element, coef, xyz);
}
}
bool fullMatrix<double>::luFactor(fullVector<int> &ipiv)
{
int M = size1(), N = size2(), lda = size1(), info;
ipiv.resize(std::min(M, N));
F77NAME(dgetrf)(&M, &N, _data, &lda, &ipiv(0), &info);
if(info == 0) return true;
return false;
}
void Quadrature::point(fullMatrix<double>& gC,
fullVector<double>& gW){
gW.resize(1);
gC.resize(1, 1);
gW(0) = 1;
gC(0, 0) = 0;
gC(0, 1) = 0;
gC(0, 2) = 0;
}
template<class T2> void LinearTermBase<T2>::get(MElement *ele, int npts, IntPt *GP, fullVector<T2> &vec) const
{
std::vector<fullVector<T2> > vv;
vv.resize(npts);
get(ele,npts,GP,vv);
int nbFF=vv[0].size();
vec.resize(nbFF);
vec.setAll(T2());
double jac[3][3];
for(int i = 0; i < npts; i++)
{
const double u = GP[i].pt[0]; const double v = GP[i].pt[1]; const double w = GP[i].pt[2];
const double weight = GP[i].weight; const double detJ = ele->getJacobian(u, v, w, jac);
for(int j = 0; j < nbFF; j++)
{
double contrib = weight * detJ;
vec(j) += contrib*vv[i](j);
}
}
}
template<class T1> void LoadTerm<T1>::get(MElement *ele, int npts, IntPt *GP, fullVector<double> &m) const
{
if(ele->getParent()) ele = ele->getParent();
int nbFF = LinearTerm<T1>::space1.getNumKeys(ele);
double jac[3][3];
m.resize(nbFF);
m.scale(0.);
for(int i = 0; i < npts; i++){
const double u = GP[i].pt[0]; const double v = GP[i].pt[1]; const double w = GP[i].pt[2];
const double weight = GP[i].weight; const double detJ = ele->getJacobian(u, v, w, jac);
std::vector<typename TensorialTraits<T1>::ValType> Vals;
LinearTerm<T1>::space1.f(ele, u, v, w, Vals);
SPoint3 p;
ele->pnt(u, v, w, p);
typename TensorialTraits<T1>::ValType load = (*Load)(p.x(), p.y(), p.z());
for(int j = 0; j < nbFF ; ++j)
{
m(j) += dot(Vals[j], load) * weight * detJ;
}
}
}
void dump(string filename, fullVector<Complex>& eig){
const double Pi = 4 * atan(1);
FILE* file = fopen(filename.c_str(), "w");
fprintf(file, "Eig\tReal(Omega^2)\tImag(Omega^2)\tf[MHz]\tt[ms]\n");
for(int i = 0; i < eig.size(); i++)
fprintf(file, "%d:\t%.16e\t%.16e\t%.16e\t%.16e\n",
i,
eig(i).real(), eig(i).imag(),
sqrt(eig(i)).real() / (2 * Pi) * 1e-9,
1.0 / (sqrt(eig(i)).imag() / (2 * Pi)) * 1e3);
fclose(file);
}
// Research purpose (to be removed ?)
void JacobianBasis::interpolate(const fullVector<double> &jacobian,
const fullMatrix<double> &uvw,
fullMatrix<double> &result,
bool areBezier) const
{
fullMatrix<double> bezM(jacobian.size(), 1);
fullVector<double> bez;
bez.setAsProxy(bezM, 0);
if (areBezier)
bez.setAll(jacobian);
else
lag2Bez(jacobian, bez);
getBezier()->interpolate(bezM, uvw, result);
}
inline void JacobianBasis::getJacobianGeneral(int nJacNodes, const fullMatrix<double> &gSMatX,
const fullMatrix<double> &gSMatY, const fullMatrix<double> &gSMatZ,
const fullMatrix<double> &nodesXYZ, fullVector<double> &jacobian) const
{
switch (_dim) {
case 0 : {
for (int i = 0; i < nJacNodes; i++) jacobian(i) = 1.;
break;
}
case 1 : {
fullMatrix<double> normals(2,3);
const double invScale = getPrimNormals1D(nodesXYZ,normals);
if (scaling) {
const double scale = 1./invScale;
normals(0,0) *= scale; normals(0,1) *= scale; normals(0,2) *= scale; // Faster to scale 1 normal than afterwards
}
fullMatrix<double> dxyzdX(nJacNodes,3);
gSMatX.mult(nodesXYZ, dxyzdX);
for (int i = 0; i < nJacNodes; i++) {
const double &dxdX = dxyzdX(i,0), &dydX = dxyzdX(i,1), &dzdX = dxyzdX(i,2);
const double &dxdY = normals(0,0), &dydY = normals(0,1), &dzdY = normals(0,2);
const double &dxdZ = normals(1,0), &dydZ = normals(1,1), &dzdZ = normals(1,2);
jacobian(i) = calcDet3D(dxdX,dydX,dzdX,dxdY,dydY,dzdY,dxdZ,dydZ,dzdZ);
}
break;
}
case 2 : {
fullMatrix<double> normal(1,3);
const double invScale = getPrimNormal2D(nodesXYZ,normal);
if (scaling) {
const double scale = 1./invScale;
normal(0,0) *= scale; normal(0,1) *= scale; normal(0,2) *= scale; // Faster to scale normal than afterwards
}
fullMatrix<double> dxyzdX(nJacNodes,3), dxyzdY(nJacNodes,3);
gSMatX.mult(nodesXYZ, dxyzdX);
gSMatY.mult(nodesXYZ, dxyzdY);
for (int i = 0; i < nJacNodes; i++) {
const double &dxdX = dxyzdX(i,0), &dydX = dxyzdX(i,1), &dzdX = dxyzdX(i,2);
const double &dxdY = dxyzdY(i,0), &dydY = dxyzdY(i,1), &dzdY = dxyzdY(i,2);
const double &dxdZ = normal(0,0), &dydZ = normal(0,1), &dzdZ = normal(0,2);
jacobian(i) = calcDet3D(dxdX,dydX,dzdX,dxdY,dydY,dzdY,dxdZ,dydZ,dzdZ);
}
break;
}
case 3 : {
fullMatrix<double> dum;
fullMatrix<double> dxyzdX(nJacNodes,3), dxyzdY(nJacNodes,3), dxyzdZ(nJacNodes,3);
gSMatX.mult(nodesXYZ, dxyzdX);
gSMatY.mult(nodesXYZ, dxyzdY);
gSMatZ.mult(nodesXYZ, dxyzdZ);
for (int i = 0; i < nJacNodes; i++) {
const double &dxdX = dxyzdX(i,0), &dydX = dxyzdX(i,1), &dzdX = dxyzdX(i,2);
const double &dxdY = dxyzdY(i,0), &dydY = dxyzdY(i,1), &dzdY = dxyzdY(i,2);
const double &dxdZ = dxyzdZ(i,0), &dydZ = dxyzdZ(i,1), &dzdZ = dxyzdZ(i,2);
jacobian(i) = calcDet3D(dxdX,dydX,dzdX,dxdY,dydY,dzdY,dxdZ,dydZ,dzdZ);
}
if (scaling) {
const double scale = 1./getPrimJac3D(nodesXYZ);
jacobian.scale(scale);
}
break;
}
}
}