void PViewFactory::setEntry (int id, const fullMatrix<double> &val)
{
std::vector<double> &vv = _values[id];
vv.resize(val.size1()*val.size2());
int k=0;
for (int i=0;i<val.size1(); i++) {
for (int j=0;j<val.size2(); j++) {
vv[k++] = val(i,j);
}
}
}
bool fullMatrix<double>::invert(fullMatrix<double> &result) const
{
int M = size1(), N = size2(), lda = size1(), info;
int *ipiv = new int[std::min(M, N)];
if (result.size2() != M || result.size1() != N) {
if (result._own_data || !result._data)
result.resize(M,N,false);
else
Msg::Fatal("FullMatrix: Bad dimension, I cannot write in proxy");
}
result.setAll(*this);
F77NAME(dgetrf)(&M, &N, result._data, &lda, ipiv, &info);
if(info == 0){
int lwork = M * 4;
double *work = new double[lwork];
F77NAME(dgetri)(&M, result._data, &lda, ipiv, work, &lwork, &info);
delete [] work;
}
delete [] ipiv;
if(info == 0) return true;
else if(info > 0)
Msg::Error("U(%d,%d)=0 in matrix inversion", info, info);
else
Msg::Error("Wrong %d-th argument in matrix inversion", -info);
return false;
}
void fullMatrix<double>::gemm(const fullMatrix<double> &a, const fullMatrix<double> &b,
double alpha, double beta, bool transposeA, bool transposeB)
{
int M = size1(), N = size2(), K = transposeA ? a.size1() : a.size2();
int LDA = a.size1(), LDB = b.size1(), LDC = size1();
F77NAME(dgemm)(transposeA ? "T" : "N", transposeB ? "T" :"N", &M, &N, &K, &alpha, a._data, &LDA, b._data, &LDB,
&beta, _data, &LDC);
}
void fullMatrix<double>::mult(const fullMatrix<double> &b, fullMatrix<double> &c) const
{
int M = c.size1(), N = c.size2(), K = _c;
int LDA = _r, LDB = b.size1(), LDC = c.size1();
double alpha = 1., beta = 0.;
F77NAME(dgemm)("N", "N", &M, &N, &K, &alpha, _data, &LDA, b._data, &LDB,
&beta, c._data, &LDC);
}
bool fullMatrix<double>::svd(fullMatrix<double> &V, fullVector<double> &S)
{
fullMatrix<double> VT(V.size2(), V.size1());
int M = size1(), N = size2(), LDA = size1(), LDVT = VT.size1(), info;
int lwork = std::max(3 * std::min(M, N) + std::max(M, N), 5 * std::min(M, N));
fullVector<double> WORK(lwork);
F77NAME(dgesvd)("O", "A", &M, &N, _data, &LDA, S._data, _data, &LDA,
VT._data, &LDVT, WORK._data, &lwork, &info);
V = VT.transpose();
if(info == 0) return true;
if(info > 0)
Msg::Error("SVD did not converge");
else
Msg::Error("Wrong %d-th argument in SVD decomposition", -info);
return false;
}
void polynomialBasis::df(const fullMatrix<double> &coord,
fullMatrix<double> &dfm) const
{
double dfv[1256][3];
dfm.resize(coord.size1() * 3, coefficients.size1(), false);
int dimCoord = coord.size2();
for(int iPoint = 0; iPoint < coord.size1(); iPoint++) {
df(coord(iPoint, 0), dimCoord > 1 ? coord(iPoint, 1) : 0.,
dimCoord > 2 ? coord(iPoint, 2) : 0., dfv);
for(int i = 0; i < coefficients.size1(); i++) {
dfm(iPoint * 3 + 0, i) = dfv[i][0];
dfm(iPoint * 3 + 1, i) = dfv[i][1];
dfm(iPoint * 3 + 2, i) = dfv[i][2];
}
}
}
void polynomialBasis::f(const fullMatrix<double> &coord,
fullMatrix<double> &sf) const
{
double p[1256];
sf.resize(coord.size1(), coefficients.size1());
for(int iPoint = 0; iPoint < coord.size1(); iPoint++) {
evaluateMonomials(coord(iPoint, 0),
coord.size2() > 1 ? coord(iPoint, 1) : 0,
coord.size2() > 2 ? coord(iPoint, 2) : 0, p);
for(int i = 0; i < coefficients.size1(); i++) {
sf(iPoint, i) = 0.;
for(int j = 0; j < coefficients.size2(); j++)
sf(iPoint, i) += coefficients(i, j) * p[j];
}
}
}
double l2Norm(const fullMatrix<double>& valA, const fullMatrix<double>& valB){
const size_t nPoint = valA.size1();
const size_t dim = valA.size2();
double norm = 0;
double modSquare = 0;
for(size_t i = 0; i < nPoint; i++){
modSquare = 0;
for(size_t j = 0; j < dim; j++)
modSquare += (valA(i, j) - valB(i, j)) * (valA(i, j) - valB(i, j));
norm += modSquare;
}
return norm = sqrt(norm);
}
void linearSystemPETSc<fullMatrix<double> >::addToMatrix(int row, int col,
const fullMatrix<double> &val)
{
if (!_entriesPreAllocated)
preAllocateEntries();
#ifdef PETSC_USE_COMPLEX
fullMatrix<std::complex<double> > modval(val.size1(), val.size2());
for (int ii = 0; ii < val.size1(); ii++) {
for (int jj = 0; jj < val.size1(); jj++) {
modval(ii, jj) = val (jj, ii);
modval(jj, ii) = val (ii, jj);
}
}
#else
fullMatrix<double> &modval = *const_cast<fullMatrix<double> *>(&val);
for (int ii = 0; ii < val.size1(); ii++) {
for (int jj = 0; jj < ii; jj++) {
PetscScalar buff = modval(ii, jj);
modval(ii, jj) = modval (jj, ii);
modval(jj, ii) = buff;
}
}
#endif
PetscInt i = row, j = col;
MatSetValuesBlocked(_a, 1, &i, 1, &j, &modval(0,0), ADD_VALUES);
//transpose back so that the original matrix is not modified
#ifndef PETSC_USE_COMPLEX
for (int ii = 0; ii < val.size1(); ii++)
for (int jj = 0; jj < ii; jj++) {
PetscScalar buff = modval(ii,jj);
modval(ii, jj) = modval (jj,ii);
modval(jj, ii) = buff;
}
#endif
_valuesNotAssembled = true;
}
void write(bool isScalar, const fullMatrix<double>& l2, string name){
// Stream
ofstream stream;
string fileName;
if(isScalar)
fileName = name + "Node.m";
else
fileName = name + "Edge.m";
stream.open(fileName.c_str());
// Matrix data
const size_t l2Row = l2.size1();
const size_t l2ColMinus = l2.size2() - 1;
// Clean Octave
stream << "close all;" << endl
<< "clear all;" << endl
<< endl;
// Mesh (Assuming uniform refinement)
stream << "h = [1, ";
for(size_t i = 1; i < l2ColMinus; i++)
stream << 1 / pow(2, i) << ", ";
stream << 1 / pow(2, l2ColMinus) << "];" << endl;
// Order (Assuming uniform refinement)
stream << "p = [1:" << l2Row << "];" << endl
<< endl;
// Matrix of l2 error (l2[Order][Mesh])
stream << "l2 = ..." << endl
<< " [..." << endl;
for(size_t i = 0; i < l2Row; i++){
stream << " ";
for(size_t j = 0; j < l2ColMinus; j++)
stream << scientific << showpos
<< l2(i, j) << " , ";
stream << scientific << showpos
<< l2(i, l2ColMinus) << " ; ..." << endl;
}
stream << " ];" << endl
<< endl;
// Delta
stream << "P = size(p, 2);" << endl
<< "H = size(h, 2);" << endl
<< endl
<< "delta = zeros(P, H - 1);" << endl
<< endl
<< "for i = 1:H-1" << endl
<< " delta(:, i) = ..." << endl
<< " (log10(l2(:, i + 1)) - log10(l2(:, i))) / ..." << endl
<< " (log10(1/h(i + 1)) - log10(1/h(i)));" << endl
<< "end" << endl
<< endl
<< "delta" << endl
<< endl;
// Plot
stream << "figure;" << endl
<< "loglog(1./h, l2', '-*');" << endl
<< "grid;"
<< endl;
// Title
stream << "title(" << "'" << name << ": ";
if(isScalar)
stream << "Nodal";
else
stream << "Edge";
stream << "');" << endl
<< endl;
// Axis
stream << "xlabel('1/h [-]');" << endl
<< "ylabel('L2 Error [-]');" << endl;
// Close
stream.close();
}
inline void JacobianBasis::getJacobianGeneral(int nJacNodes, const fullMatrix<double> &gSMatX,
const fullMatrix<double> &gSMatY, const fullMatrix<double> &gSMatZ,
const fullMatrix<double> &nodesX, const fullMatrix<double> &nodesY,
const fullMatrix<double> &nodesZ, fullMatrix<double> &jacobian) const
{
switch (_dim) {
case 0 : {
const int numEl = nodesX.size2();
for (int iEl = 0; iEl < numEl; iEl++)
for (int i = 0; i < nJacNodes; i++) jacobian(i,iEl) = 1.;
break;
}
case 1 : {
const int numEl = nodesX.size2();
fullMatrix<double> dxdX(nJacNodes,numEl), dydX(nJacNodes,numEl), dzdX(nJacNodes,numEl);
gSMatX.mult(nodesX, dxdX); gSMatX.mult(nodesY, dydX); gSMatX.mult(nodesZ, dzdX);
for (int iEl = 0; iEl < numEl; iEl++) {
fullMatrix<double> nodesXYZ(numPrimMapNodes,3);
for (int i = 0; i < numPrimMapNodes; i++) {
nodesXYZ(i,0) = nodesX(i,iEl);
nodesXYZ(i,1) = nodesY(i,iEl);
nodesXYZ(i,2) = nodesZ(i,iEl);
}
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
}
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);
for (int i = 0; i < nJacNodes; i++)
jacobian(i,iEl) = calcDet3D(dxdX(i,iEl),dydX(i,iEl),dzdX(i,iEl),
dxdY,dydY,dzdY,
dxdZ,dydZ,dzdZ);
}
break;
}
case 2 : {
const int numEl = nodesX.size2();
fullMatrix<double> dxdX(nJacNodes,numEl), dydX(nJacNodes,numEl), dzdX(nJacNodes,numEl);
fullMatrix<double> dxdY(nJacNodes,numEl), dydY(nJacNodes,numEl), dzdY(nJacNodes,numEl);
gSMatX.mult(nodesX, dxdX); gSMatX.mult(nodesY, dydX); gSMatX.mult(nodesZ, dzdX);
gSMatY.mult(nodesX, dxdY); gSMatY.mult(nodesY, dydY); gSMatY.mult(nodesZ, dzdY);
for (int iEl = 0; iEl < numEl; iEl++) {
fullMatrix<double> nodesXYZ(numPrimMapNodes,3);
for (int i = 0; i < numPrimMapNodes; i++) {
nodesXYZ(i,0) = nodesX(i,iEl);
nodesXYZ(i,1) = nodesY(i,iEl);
nodesXYZ(i,2) = nodesZ(i,iEl);
}
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
}
const double &dxdZ = normal(0,0), &dydZ = normal(0,1), &dzdZ = normal(0,2);
for (int i = 0; i < nJacNodes; i++)
jacobian(i,iEl) = calcDet3D(dxdX(i,iEl),dydX(i,iEl),dzdX(i,iEl),
dxdY(i,iEl),dydY(i,iEl),dzdY(i,iEl),
dxdZ,dydZ,dzdZ);
}
break;
}
case 3 : {
const int numEl = nodesX.size2();
fullMatrix<double> dxdX(nJacNodes,numEl), dydX(nJacNodes,numEl), dzdX(nJacNodes,numEl);
fullMatrix<double> dxdY(nJacNodes,numEl), dydY(nJacNodes,numEl), dzdY(nJacNodes,numEl);
fullMatrix<double> dxdZ(nJacNodes,numEl), dydZ(nJacNodes,numEl), dzdZ(nJacNodes,numEl);
gSMatX.mult(nodesX, dxdX); gSMatX.mult(nodesY, dydX); gSMatX.mult(nodesZ, dzdX);
gSMatY.mult(nodesX, dxdY); gSMatY.mult(nodesY, dydY); gSMatY.mult(nodesZ, dzdY);
gSMatZ.mult(nodesX, dxdZ); gSMatZ.mult(nodesY, dydZ); gSMatZ.mult(nodesZ, dzdZ);
for (int iEl = 0; iEl < numEl; iEl++) {
for (int i = 0; i < nJacNodes; i++)
jacobian(i,iEl) = calcDet3D(dxdX(i,iEl),dydX(i,iEl),dzdX(i,iEl),
dxdY(i,iEl),dydY(i,iEl),dzdY(i,iEl),
dxdZ(i,iEl),dydZ(i,iEl),dzdZ(i,iEl));
if (scaling) {
fullMatrix<double> nodesXYZ(numPrimMapNodes,3);
for (int i = 0; i < numPrimMapNodes; i++) {
nodesXYZ(i,0) = nodesX(i,iEl);
nodesXYZ(i,1) = nodesY(i,iEl);
nodesXYZ(i,2) = nodesZ(i,iEl);
}
const double scale = 1./getPrimJac3D(nodesXYZ);
for (int i = 0; i < nJacNodes; i++) jacobian(i,iEl) *= scale;
}
}
break;
}
}
}