PView *elasticitySolver::buildErrorView(const std::string postFileName,
simpleFunction<double> *f0,
simpleFunction<double> *f1,
simpleFunction<double> *f2)
{
std::cout << "build Error View" << std::endl;
std::map<int, std::vector<double> > data;
SolverField<SVector3> solField(pAssembler, LagSpace);
for(std::size_t i = 0; i < elasticFields.size(); ++i) {
for(groupOfElements::elementContainer::const_iterator it =
elasticFields[i].g->begin();
it != elasticFields[i].g->end(); ++it) {
MElement *e = *it;
int npts;
IntPt *GP;
double jac[3][3];
int integrationOrder = 2 * (e->getPolynomialOrder() + 5);
e->getIntegrationPoints(integrationOrder, &npts, &GP);
double val = 0.0;
for(int j = 0; j < npts; j++) {
double u = GP[j].pt[0];
double v = GP[j].pt[1];
double w = GP[j].pt[2];
double weight = GP[j].weight;
double detJ = fabs(e->getJacobian(u, v, w, jac));
SPoint3 p;
e->pnt(u, v, w, p);
SVector3 FEMVALUE;
solField.f(e, u, v, w, FEMVALUE);
SVector3 sol((*f0)(p.x(), p.y(), p.z()), (*f1)(p.x(), p.y(), p.z()),
(*f2)(p.x(), p.y(), p.z()));
double diff = normSq(sol - FEMVALUE);
val += diff * detJ * weight;
}
std::vector<double> vec;
vec.push_back(sqrt(val));
data[e->getNum()] = vec;
}
}
PView *pv = new PView(postFileName, "ElementData", pModel, data, 0.0, 1);
return pv;
}
double thermicSolver::computeL2Norm(simpleFunction<double> *sol)
{
double val = 0.0;
SolverField<double> solField(pAssembler, LagSpace);
for(std::size_t i = 0; i < thermicFields.size(); ++i) {
for(groupOfElements::elementContainer::const_iterator it =
thermicFields[i].g->begin();
it != thermicFields[i].g->end(); ++it) {
MElement *e = *it;
// printf("element (%g,%g) (%g,%g)
// (%g,%g)\n",e->getVertex(0)->x(),e->getVertex(0)->y(),e->getVertex(1)->x(),e->getVertex(1)->y(),e->getVertex(2)->x(),e->getVertex(2)->y());
int npts;
IntPt *GP;
double jac[3][3];
int integrationOrder = 2 * (e->getPolynomialOrder() + 5);
e->getIntegrationPoints(integrationOrder, &npts, &GP);
for(int j = 0; j < npts; j++) {
double u = GP[j].pt[0];
double v = GP[j].pt[1];
double w = GP[j].pt[2];
double weight = GP[j].weight;
double detJ = fabs(e->getJacobian(u, v, w, jac));
SPoint3 p;
e->pnt(u, v, w, p);
double FEMVALUE;
solField.f(e, u, v, w, FEMVALUE);
double diff = (*sol)(p.x(), p.y(), p.z()) - FEMVALUE;
val += diff * diff * detJ * weight;
// printf("(%g %g) : detJ=%g we=%g FV=%g sol=%g
// diff=%g\n",p.x(),p.y(),detJ,weight,FEMVALUE,(*sol)(p.x(), p.y(),
// p.z()),diff);
}
}
}
printf("L2Norm = %g\n", sqrt(val));
return sqrt(val);
}
double elasticitySolver::computeL2Norm(simpleFunction<double> *f0,
simpleFunction<double> *f1,
simpleFunction<double> *f2)
{
double val = 0.0;
SolverField<SVector3> solField(pAssembler, LagSpace);
for(std::size_t i = 0; i < elasticFields.size(); ++i) {
for(groupOfElements::elementContainer::const_iterator it =
elasticFields[i].g->begin();
it != elasticFields[i].g->end(); ++it) {
MElement *e = *it;
int npts;
IntPt *GP;
double jac[3][3];
int integrationOrder = 2 * (e->getPolynomialOrder() + 5);
e->getIntegrationPoints(integrationOrder, &npts, &GP);
for(int j = 0; j < npts; j++) {
double u = GP[j].pt[0];
double v = GP[j].pt[1];
double w = GP[j].pt[2];
double weight = GP[j].weight;
double detJ = fabs(e->getJacobian(u, v, w, jac));
SPoint3 p;
e->pnt(u, v, w, p);
SVector3 FEMVALUE;
solField.f(e, u, v, w, FEMVALUE);
SVector3 sol((*f0)(p.x(), p.y(), p.z()), (*f1)(p.x(), p.y(), p.z()),
(*f2)(p.x(), p.y(), p.z()));
double diff = normSq(sol - FEMVALUE);
val += diff * detJ * weight;
}
}
}
printf("L2Norm = %g\n", sqrt(val));
return sqrt(val);
}
double GRegion::computeSolidProperties(std::vector<double> cg,
std::vector<double> inertia)
{
std::list<GFace*>::iterator it = l_faces.begin();
std::list<int>::iterator itdir = l_dirs.begin();
double volumex = 0;
double volumey = 0;
double volumez = 0;
double surface = 0;
cg[0] = cg[1] = cg[2] = 0.0;
for ( ; it != l_faces.end(); ++it,++itdir){
for (unsigned int i = 0; i < (*it)->triangles.size(); ++i){
MTriangle *e = (*it)->triangles[i];
int npt;
IntPt *pts;
e->getIntegrationPoints (2*(e->getPolynomialOrder()-1)+3, &npt, &pts);
for (int j=0;j<npt;j++){
SPoint3 pt;
// compute x,y,z of the integration point
e->pnt(pts[j].pt[0], pts[j].pt[1], pts[j].pt[2], pt);
double jac[3][3];
// compute normal
double detJ = e->getJacobian(pts[j].pt[0], pts[j].pt[1], pts[j].pt[2], jac);
SVector3 n(jac[2][0], jac[2][1], jac[2][2]);
n.normalize();
n *= (double)*itdir;
surface += detJ* pts[j].weight;
volumex += detJ * n.x() * pt.x() * pts[j].weight;
volumey += detJ * n.y() * pt.y() * pts[j].weight;
volumez += detJ * n.z() * pt.z() * pts[j].weight;
cg[0] += detJ * n.x() * (pt.x() * pt.x()) * pts[j].weight * 0.5;
cg[1] += detJ * n.y() * (pt.y() * pt.y()) * pts[j].weight * 0.5;
cg[2] += detJ * n.z() * (pt.z() * pt.z()) * pts[j].weight * 0.5;
}
}
}
printf("%g -- %g %g %g\n", surface, volumex, volumey, volumez);
double volume = volumex;
cg[0] /= volume;
cg[1] /= volume;
cg[2] /= volume;
it = l_faces.begin();
itdir = l_dirs.begin();
inertia[0] = inertia[1] = inertia[2] = inertia[3] = inertia[4] = inertia[5] = 0.0;
for ( ; it != l_faces.end(); ++it,++itdir){
for (unsigned int i = 0; i < (*it)->getNumMeshElements(); ++i){
MElement *e = (*it)->getMeshElement(i);
int npt;
IntPt *pts;
e->getIntegrationPoints(2 * (e->getPolynomialOrder() - 1) + 3, &npt, &pts);
for (int j = 0; j < npt; j++){
SPoint3 pt;
// compute x,y,z of the integration point
e->pnt(pts[j].pt[0], pts[j].pt[1], pts[j].pt[2], pt);
double jac[3][3];
// compute normal
double detJ = e->getJacobian(pts[j].pt[0], pts[j].pt[1], pts[j].pt[2], jac);
SVector3 n(jac[2][0], jac[2][1], jac[2][2]);
n *= (double)*itdir;
inertia[0] += pts[j].weight * detJ * n.x() *
(pt.x() - cg[0]) * (pt.x() - cg[0]) * (pt.x() - cg[0]) / 3.0;
inertia[1] += pts[j].weight * detJ * n.y() *
(pt.y() - cg[1]) * (pt.y() - cg[1]) * (pt.y() - cg[1]) / 3.0;
inertia[2] += pts[j].weight * detJ * n.z() *
(pt.z() - cg[2]) * (pt.z() - cg[2]) * (pt.z() - cg[2]) / 3.0;
inertia[3] += pts[j].weight * detJ * n.x() *
(pt.y() - cg[1]) * (pt.x() - cg[0]) * (pt.x() - cg[0]) / 3.0;
inertia[4] += pts[j].weight * detJ * n.x() *
(pt.z() - cg[2]) * (pt.x() - cg[0]) * (pt.x() - cg[0]) / 3.0;
inertia[5] += pts[j].weight * detJ * n.y() *
(pt.z() - cg[2]) * (pt.y() - cg[1]) * (pt.y() - cg[1]) / 3.0;
}
}
}
return volume;
}