PView *GMSH_Lambda2Plugin::execute(PView *v)
{
int ev = (int)Lambda2Options_Number[0].def;
int iView = (int)Lambda2Options_Number[1].def;
PView *v1 = getView(iView, v);
if(!v1) return v;
PViewDataList *data1 = getDataList(v1);
if(!data1) return v;
PView *v2 = new PView();
PViewDataList *data2 = getDataList(v2);
if(!data2) return v;
// assume that the tensors contain the velocity gradient tensor
int nts = data1->getNumTimeSteps();
eigen(data1->TP, data1->NbTP, data2->SP, &data2->NbSP, nts, 1, 9, ev);
eigen(data1->TL, data1->NbTL, data2->SL, &data2->NbSL, nts, 2, 9, ev);
eigen(data1->TT, data1->NbTT, data2->ST, &data2->NbST, nts, 3, 9, ev);
eigen(data1->TQ, data1->NbTQ, data2->SQ, &data2->NbSQ, nts, 4, 9, ev);
eigen(data1->TS, data1->NbTS, data2->SS, &data2->NbSS, nts, 4, 9, ev);
eigen(data1->TH, data1->NbTH, data2->SH, &data2->NbSH, nts, 8, 9, ev);
eigen(data1->TI, data1->NbTI, data2->SI, &data2->NbSI, nts, 6, 9, ev);
eigen(data1->TY, data1->NbTY, data2->SY, &data2->NbSY, nts, 5, 9, ev);
// assume that the vectors contain the velocities
// FIXME: only implemented for tri/tet at the moment
// eigen(data1->VP, data1->NbVP, data2->SP, &data2->NbSP, nts, 1, 3, ev);
// eigen(data1->VL, data1->NbVL, data2->SL, &data2->NbSL, nts, 2, 3, ev);
eigen(data1->VT, data1->NbVT, data2->ST, &data2->NbST, nts, 3, 3, ev);
// eigen(data1->VQ, data1->NbVQ, data2->SQ, &data2->NbSQ, nts, 4, 3, ev);
eigen(data1->VS, data1->NbVS, data2->SS, &data2->NbSS, nts, 4, 3, ev);
// eigen(data1->VH, data1->NbVH, data2->SH, &data2->NbSH, nts, 8, 3, ev);
// eigen(data1->VI, data1->NbVI, data2->SI, &data2->NbSI, nts, 6, 3, ev);
// eigen(data1->VY, data1->NbVY, data2->SY, &data2->NbSY, nts, 5, 3, ev);
data2->Time = data1->Time;
data2->setName(data1->getName() + "_Lambda2");
data2->setFileName(data1->getName() + "_Lambda2.pos");
data2->finalize();
return v2;
}
PView *GMSH_ExtractEdgesPlugin::execute(PView *v)
{
std::vector<MTriangle *> elements;
for(GModel::fiter it = GModel::current()->firstFace();
it != GModel::current()->lastFace(); ++it)
elements.insert(elements.end(), (*it)->triangles.begin(),
(*it)->triangles.end());
if(elements.empty()) {
Msg::Error("No triangles in mesh to extract edges from");
return 0;
}
PView *v2 = new PView();
PViewDataList *data2 = getDataList(v2);
e2t_cont adj;
buildEdgeToTriangle(elements, adj);
std::vector<edge_angle> edges_detected, edges_lonly;
buildListOfEdgeAngle(adj, edges_detected, edges_lonly);
double threshold = ExtractEdgesOptions_Number[0].def / 180. * M_PI;
for(std::size_t i = 0; i < edges_detected.size(); i++) {
if(edges_detected[i].angle <= threshold) break;
add_edge(edges_detected[i], data2);
}
if(ExtractEdgesOptions_Number[1].def) {
for(std::size_t i = 0; i < edges_lonly.size(); i++) {
add_edge(edges_lonly[i], data2);
}
}
data2->setName("ExtractEdges");
data2->setFileName("ExtractEdges.pos");
data2->finalize();
return v2;
}
PView *GMSH_DistancePlugin::execute(PView *v)
{
int id_pt = (int) DistanceOptions_Number[0].def;
int id_line = (int) DistanceOptions_Number[1].def;
int id_face = (int) DistanceOptions_Number[2].def;
double type = (double) DistanceOptions_Number[3].def;
int ortho = (int) DistanceOptions_Number[6].def;
PView *view = new PView();
_data = getDataList(view);
#if defined(HAVE_SOLVER)
#if defined(HAVE_TAUCS)
linearSystemCSRTaucs<double> *lsys = new linearSystemCSRTaucs<double>;
#else
linearSystemCSRGmm<double> *lsys = new linearSystemCSRGmm<double>;
lsys->setNoisy(1);
lsys->setGmres(1);
lsys->setPrec(5.e-8);
#endif
dofManager<double> * dofView = new dofManager<double>(lsys);
#endif
std::vector<GEntity*> _entities;
GModel::current()->getEntities(_entities);
if (!_entities.size() || !_entities[_entities.size()-1]->getMeshElement(0)) {
Msg::Error("This plugin needs a mesh !");
return view;
}
GEntity* ge = _entities[_entities.size()-1];
int integrationPointTetra[2] = {0,0};
int numnodes = 0;
for (unsigned int i = 0; i < _entities.size()-1; i++)
numnodes += _entities[i]->mesh_vertices.size();
int totNodes = numnodes + _entities[_entities.size()-1]->mesh_vertices.size();
int order = ge->getMeshElement(0)->getPolynomialOrder();
int totNumNodes = totNodes + ge->getNumMeshElements()*integrationPointTetra[order-1];
std::vector<SPoint3> pts;
std::vector<double> distances;
std::vector<MVertex* > pt2Vertex;
pts.clear();
distances.clear();
pt2Vertex.clear();
pts.reserve(totNumNodes);
distances.reserve(totNumNodes);
pt2Vertex.reserve(totNumNodes);
std::map<MVertex*,double> _distanceE_map;
std::map<MVertex*,int> _isInYarn_map;
std::vector<int> index;
std::vector<double> distancesE;
std::vector<double> distances2;
std::vector<double> distancesE2;
std::vector<int> isInYarn;
std::vector<int> isInYarn2;
std::vector<SPoint3> closePts;
std::vector<SPoint3> closePts2;
for (int i=0; i<totNumNodes; i++) {
distances.push_back(1.e22);
}
int k = 0;
for (unsigned int i=0; i<_entities.size(); i++){
GEntity* ge = _entities[i];
_maxDim = std::max(_maxDim, ge->dim());
for (unsigned int j=0; j<ge->mesh_vertices.size(); j++) {
MVertex *v = ge->mesh_vertices[j];
pts.push_back(SPoint3(v->x(), v->y(), v->z()));
_distance_map.insert(std::make_pair(v, 0.0));
/* TO DO (by AM)
SPoint3 p_empty();
_closePts_map.insert(std::make_pair(v, p_empty));
*/
pt2Vertex[k] = v;
k++;
}
}
// Compute geometrical distance to mesh boundaries
//------------------------------------------------------
if (type < 0.0 ) {
bool existEntity = false;
for (unsigned int i=0; i<_entities.size(); i++) {
GEntity* g2 = _entities[i];
int gDim = g2->dim();
std::vector<int> phys = g2->getPhysicalEntities();
bool computeForEntity = false;
for(unsigned int k = 0; k<phys.size(); k++) {
int tagp = phys[k];
if (id_pt == 0 && id_line == 0 && id_face == 0 && gDim == _maxDim - 1)
computeForEntity = true;
else if ((tagp == id_pt && gDim == 0) || (tagp == id_line && gDim == 1) ||
(tagp == id_face && gDim == 2))
computeForEntity = true;
}
if (computeForEntity) {
existEntity = true;
for (unsigned int k = 0; k < g2->getNumMeshElements(); k++) {
std::vector<double> iDistances;
std::vector<SPoint3> iClosePts;
std::vector<double> iDistancesE;
std::vector<int> iIsInYarn;
MElement *e = g2->getMeshElement(k);
MVertex *v1 = e->getVertex(0);
MVertex *v2 = e->getVertex(1);
SPoint3 p1(v1->x(), v1->y(), v1->z());
SPoint3 p2(v2->x(), v2->y(), v2->z());
if ((e->getNumVertices() == 2 && order == 1) ||
(e->getNumVertices() == 3 && order == 2)) {
signedDistancesPointsLine(iDistances, iClosePts, pts, p1, p2);
}
else if ((e->getNumVertices() == 3 && order == 1) ||
(e->getNumVertices() == 6 && order == 2)) {
MVertex *v3 = e->getVertex(2);
SPoint3 p3 (v3->x(),v3->y(),v3->z());
signedDistancesPointsTriangle(iDistances, iClosePts, pts, p1, p2, p3);
}
for (unsigned int kk=0; kk<pts.size(); kk++) {
if (std::abs(iDistances[kk]) < distances[kk]) {
distances[kk] = std::abs(iDistances[kk]);
MVertex *v = pt2Vertex[kk];
_distance_map[v] = distances[kk];
/* TO DO (by AM)
_closePts_map[v] = iClosePts[kk];
*/
}
}
}
}
}
if (!existEntity){
if (id_pt != 0) Msg::Error("The Physical Point does not exist !");
if (id_line != 0) Msg::Error("The Physical Line does not exist !");
if (id_face != 0) Msg::Error("The Physical Surface does not exist !");
return view;
}
printView(_entities, _distance_map);
/* TO DO (by AM)
printView(_entities, _closePts_map);
*/
}
// Compute PDE for distance function
//-----------------------------------
else if (type > 0.0) {
#if defined(HAVE_SOLVER)
bool existEntity = false;
SBoundingBox3d bbox;
for(unsigned int i = 0; i < _entities.size(); i++){
GEntity* ge = _entities[i];
int gDim = ge->dim();
bool fixForEntity = false;
std::vector<int> phys = ge->getPhysicalEntities();
for(unsigned int k = 0; k < phys.size(); k++) {
int tagp = phys[k];
if (id_pt == 0 && id_line == 0 && id_face == 0 && gDim == _maxDim - 1)
fixForEntity = true;
else if ((tagp == id_pt && gDim == 0) || (tagp == id_line && gDim == 1) ||
(tagp == id_face && gDim == 2) )
fixForEntity = true;
}
if (fixForEntity) {
existEntity = true;
for (unsigned int i = 0; i < ge->getNumMeshElements(); ++i) {
MElement *t = ge->getMeshElement(i);
for (int k=0; k<t->getNumVertices(); k++) {
MVertex *v = t->getVertex(k);
dofView->fixVertex(v, 0, 1, 0.);
bbox += SPoint3(v->x(), v->y(), v->z());
}
}
}
}
if (!existEntity){
if (id_pt != 0) Msg::Error("The Physical Point does not exist !");
if (id_line != 0) Msg::Error("The Physical Line does not exist !");
if (id_face != 0) Msg::Error("The Physical Surface does not exist !");
return view;
}
std::vector<MElement *> allElems;
for(unsigned int ii = 0; ii < _entities.size(); ii++){
if(_entities[ii]->dim() == _maxDim) {
GEntity *ge = _entities[ii];
for(unsigned int i = 0; i < ge->getNumMeshElements(); ++i) {
MElement *t = ge->getMeshElement(i);
allElems.push_back(t);
for (int k = 0; k < t->getNumVertices(); k++)
dofView->numberVertex(t->getVertex(k), 0, 1);
}
}
}
double L = norm(SVector3(bbox.max(), bbox.min()));
double mu = type*L;
simpleFunction<double> DIFF(mu*mu), ONE(1.0);
distanceTerm distance(GModel::current(), 1, &DIFF, &ONE);
for (std::vector<MElement* >::iterator it = allElems.begin();
it != allElems.end(); it++){
SElement se((*it));
distance.addToMatrix(*dofView, &se);
}
groupOfElements gr(allElems);
distance.addToRightHandSide(*dofView, gr);
Msg::Info("Distance Computation: Assembly done");
lsys->systemSolve();
Msg::Info("Distance Computation: System solved");
for (std::map<MVertex*,double >::iterator itv = _distance_map.begin();
itv != _distance_map.end() ; ++itv) {
MVertex *v = itv->first;
double value;
dofView->getDofValue(v, 0, 1, value);
value = std::min(0.9999, value);
double dist = -mu * log(1. - value);
itv->second = dist;
}
printView(_entities, _distance_map);
#endif
}
_data->setName("distance");
_data->Time.push_back(0);
_data->setFileName(_fileName.c_str());
_data->finalize();
// compute also orthogonal vector to distance field
// A Uortho = -C DIST
//------------------------------------------------
if (ortho > 0) {
#if defined(HAVE_SOLVER)
#ifdef HAVE_TAUCS
linearSystemCSRTaucs<double> *lsys2 = new linearSystemCSRTaucs<double>;
#else
linearSystemCSRGmm<double> *lsys2 = new linearSystemCSRGmm<double>;
lsys->setNoisy(1);
lsys->setGmres(1);
lsys->setPrec(5.e-8);
#endif
dofManager<double> myAssembler(lsys2);
simpleFunction<double> ONE(1.0);
double dMax = 1.0; //EMI TO CHANGE
std::vector<MElement *> allElems;
for(unsigned int ii = 0; ii < _entities.size(); ii++){
if (_entities[ii]->dim() == _maxDim) {
GEntity *ge = _entities[ii];
for (unsigned int i=0; i<ge->getNumMeshElements(); ++i) {
MElement *t = ge->getMeshElement(i);
double vMean = 0.0;
for (int k = 0; k < t->getNumVertices(); k++) {
std::map<MVertex*, double>::iterator it = _distance_map.find(t->getVertex(k));
vMean += it->second;
}
vMean /= t->getNumVertices();
if (vMean < dMax)
allElems.push_back(ge->getMeshElement(i));
}
}
}
int mid = (int)floor(allElems.size() / 2.);
MElement *e = allElems[mid];
MVertex *vFIX = e->getVertex(0);
myAssembler.fixVertex(vFIX, 0, 1, 0.0);
for (std::vector<MElement* >::iterator it = allElems.begin();
it != allElems.end(); it++){
MElement *t = *it;
for(int k = 0; k < t->getNumVertices(); k++)
myAssembler.numberVertex(t->getVertex(k), 0, 1);
}
orthogonalTerm *ortho;
ortho = new orthogonalTerm(GModel::current(), 1, &ONE, &_distance_map);
// if (type < 0)
// ortho = new orthogonalTerm(GModel::current(), 1, &ONE, view);
// else
// ortho = new orthogonalTerm(GModel::current(), 1, &ONE, dofView);
for (std::vector<MElement* >::iterator it = allElems.begin();
it != allElems.end(); it++){
SElement se((*it));
ortho->addToMatrix(myAssembler, &se);
}
groupOfElements gr(allElems);
ortho->addToRightHandSide(myAssembler, gr);
Msg::Info("Orthogonal Computation: Assembly done");
lsys2->systemSolve();
Msg::Info("Orthogonal Computation: System solved");
PView *view2 = new PView();
PViewDataList *data2 = getDataList(view2);
data2->setName("ortogonal field");
Msg::Info("Writing orthogonal.pos");
FILE * f5 = Fopen("orthogonal.pos","w");
fprintf(f5,"View \"orthogonal\"{\n");
for (std::vector<MElement* >::iterator it = allElems.begin();
it != allElems.end(); it++){
MElement *e = *it;
int numNodes = e->getNumVertices();
if (e->getType() == TYPE_POLYG)
numNodes = e->getNumChildren() * e->getChild(0)->getNumVertices();
std::vector<double> x(numNodes), y(numNodes), z(numNodes);
std::vector<double> *out2 = data2->incrementList(1, e->getType(), numNodes);
std::vector<MVertex*> nods;
std::vector<double> orth;
if(!e->getNumChildren())
for(int i=0; i<numNodes; i++)
nods.push_back(e->getVertex(i));
else
for(int i = 0; i < e->getNumChildren(); i++)
for(int j = 0; j < e->getChild(i)->getNumVertices(); j++)
nods.push_back(e->getChild(i)->getVertex(j));
for(int nod = 0; nod < numNodes; nod++) out2->push_back((nods[nod])->x());
for(int nod = 0; nod < numNodes; nod++) out2->push_back((nods[nod])->y());
for(int nod = 0; nod < numNodes; nod++) out2->push_back((nods[nod])->z());
if (_maxDim == 2)
switch (numNodes) {
case 2: fprintf(f5,"SL("); break;
case 3: fprintf(f5,"ST("); break;
case 4: fprintf(f5,"SQ("); break;
default: Msg::Fatal("Error in Plugin 'Distance' (numNodes=%g).",numNodes); break;
}
else if (_maxDim == 3)
switch (numNodes) {
case 4: fprintf(f5,"SS("); break;
case 8: fprintf(f5,"SH("); break;
case 6: fprintf(f5,"SI("); break;
case 5: fprintf(f5,"SY("); break;
default: Msg::Fatal("Error in Plugin 'Distance' (numNodes=%g).",numNodes); break;
}
for (int j=0; j<numNodes; j++) {
MVertex *v = nods[j];
if (j)
fprintf(f5, ",%g,%g,%g", v->x(), v->y(), v->z());
else
fprintf(f5, "%g,%g,%g", v->x(), v->y(), v->z());
double value;
myAssembler.getDofValue(v, 0, 1, value);
orth.push_back(value);
}
fprintf(f5,"){");
for (unsigned int i=0; i<orth.size(); i++) {
out2->push_back(orth[i]);
if (i)
fprintf(f5,",%g", orth[i]);
else
fprintf(f5,"%g", orth[i]);
}
fprintf(f5,"};\n");
}
fprintf(f5,"};\n");
fclose(f5);
lsys->clear();
lsys2->clear();
data2->Time.push_back(0);
data2->setFileName("orthogonal.pos");
data2->finalize();
#endif
}
return view;
}
PView *GMSH_TetrahedralizePlugin::execute(PView *v)
{
int iView = (int)TetrahedralizeOptions_Number[0].def;
PView *v1 = getView(iView, v);
if(!v1) return v;
PViewData *data1 = v1->getData();
if(data1->hasMultipleMeshes()){
Msg::Error("Tetrahedralize plugin cannot be applied to multi-mesh views");
return v1;
}
// create list of points with associated data
std::vector<MVertex*> points;
int numSteps = data1->getNumTimeSteps();
for(int ent = 0; ent < data1->getNumEntities(0); ent++){
for(int ele = 0; ele < data1->getNumElements(0, ent); ele++){
if(data1->skipElement(0, ent, ele)) continue;
if(data1->getNumNodes(0, ent, ele) != 1) continue;
int numComp = data1->getNumComponents(0, ent, ele);
double x, y, z;
data1->getNode(0, ent, ele, 0, x, y, z);
PointData *p = new PointData(x, y, z, numComp * numSteps);
for(int step = 0; step < numSteps; step++)
for(int comp = 0; comp < numComp; comp++)
data1->getValue(step, ent, ele, 0, comp, p->val[numComp * step + comp]);
points.push_back(p);
}
}
if(points.size() < 4){
Msg::Error("Need at least 4 points to tetrahedralize");
for(unsigned int i = 0; i < points.size(); i++) delete points[i];
return v1;
}
std::vector<MTetrahedron*> tets;
delaunayMeshIn3D(points, tets);
// create output
PView *v2 = new PView();
PViewDataList *data2 = getDataList(v2);
for(unsigned int i = 0; i < tets.size(); i++){
PointData *p[4];
p[0] = (PointData*)tets[i]->getVertex(0);
p[1] = (PointData*)tets[i]->getVertex(1);
p[2] = (PointData*)tets[i]->getVertex(2);
p[3] = (PointData*)tets[i]->getVertex(3);
int numComp = 0;
std::vector<double> *vec = 0;
if((int)p[0]->val.size() == 9 * numSteps &&
(int)p[1]->val.size() == 9 * numSteps &&
(int)p[2]->val.size() == 9 * numSteps &&
(int)p[3]->val.size() == 9 * numSteps){
numComp = 9; data2->NbTS++; vec = &data2->TS;
}
else if((int)p[0]->val.size() == 3 * numSteps &&
(int)p[1]->val.size() == 3 * numSteps &&
(int)p[2]->val.size() == 3 * numSteps &&
(int)p[3]->val.size() == 3 * numSteps){
numComp = 3; data2->NbVS++; vec = &data2->VS;
}
else if((int)p[0]->val.size() == numSteps &&
(int)p[1]->val.size() == numSteps &&
(int)p[2]->val.size() == numSteps &&
(int)p[3]->val.size() == numSteps){
numComp = 1; data2->NbSS++; vec = &data2->SS;
}
else{
Msg::Warning("Bad data in tetrahedralization");
continue;
}
for(int nod = 0; nod < 4; nod++) vec->push_back(p[nod]->x());
for(int nod = 0; nod < 4; nod++) vec->push_back(p[nod]->y());
for(int nod = 0; nod < 4; nod++) vec->push_back(p[nod]->z());
for(int step = 0; step < numSteps; step++)
for(int nod = 0; nod < 4; nod++)
for(int comp = 0; comp < numComp; comp++)
vec->push_back(p[nod]->val[numComp * step + comp]);
}
for(unsigned int i = 0; i < tets.size(); i++) delete tets[i];
for(unsigned int i = 0; i < points.size(); i++) delete points[i];
for(int i = 0; i < data1->getNumTimeSteps(); i++)
data2->Time.push_back(data1->getTime(i));
data2->setName(data1->getName() + "_Tetrahedralize");
data2->setFileName(data1->getName() + "_Tetrahedralize.pos");
data2->finalize();
return v2;
}
PView *GMSH_CutGridPlugin::GenerateView(PView *v1, int connect)
{
if(getNbU() <= 0 || getNbV() <= 0)
return v1;
PViewData *data1 = getPossiblyAdaptiveData(v1);
PView *v2 = new PView();
PViewDataList *data2 = getDataList(v2);
OctreePost o(v1);
int nbs = data1->getNumScalars();
int nbv = data1->getNumVectors();
int nbt = data1->getNumTensors();
int maxcomp = nbt ? 9 : (nbv ? 3 : 1);
int numsteps = data1->getNumTimeSteps();
double ***pnts = new double** [getNbU()];
double ***vals = new double** [getNbU()];
for(int i = 0; i < getNbU(); i++){
pnts[i] = new double* [getNbV()];
vals[i] = new double* [getNbV()];
for(int j = 0; j < getNbV(); j++){
pnts[i][j] = new double[3];
vals[i][j] = new double[maxcomp * numsteps];
getPoint(i, j, pnts[i][j]);
}
}
if(nbs){
for(int i = 0; i < getNbU(); i++)
for(int j = 0; j < getNbV(); j++)
o.searchScalar(pnts[i][j][0], pnts[i][j][1], pnts[i][j][2], vals[i][j]);
addInView(numsteps, connect, 1, pnts, vals, data2->SP, &data2->NbSP,
data2->SL, &data2->NbSL, data2->SQ, &data2->NbSQ);
}
if(nbv){
for(int i = 0; i < getNbU(); i++)
for(int j = 0; j < getNbV(); j++)
o.searchVector(pnts[i][j][0], pnts[i][j][1], pnts[i][j][2], vals[i][j]);
addInView(numsteps, connect, 3, pnts, vals, data2->VP, &data2->NbVP,
data2->VL, &data2->NbVL, data2->VQ, &data2->NbVQ);
}
if(nbt){
for(int i = 0; i < getNbU(); i++)
for(int j = 0; j < getNbV(); j++)
o.searchTensor(pnts[i][j][0], pnts[i][j][1], pnts[i][j][2], vals[i][j]);
addInView(numsteps, connect, 9, pnts, vals, data2->TP, &data2->NbTP,
data2->TL, &data2->NbTL, data2->TQ, &data2->NbTQ);
}
for(int i = 0; i < getNbU(); i++){
for(int j = 0; j < getNbV(); j++){
delete [] pnts[i][j];
delete [] vals[i][j];
}
delete [] pnts[i];
delete [] vals[i];
}
delete [] pnts;
delete [] vals;
data2->setName(data1->getName() + "_CutGrid");
data2->setFileName(data1->getName() + "_CutGrid.pos");
data2->finalize();
return v2;
}
PView *GMSH_Scal2VecPlugin::execute(PView *v)
{
int iViewX = (int)Scal2VecOptions_Number[0].def;
int iViewY = (int)Scal2VecOptions_Number[1].def;
int iViewZ = (int)Scal2VecOptions_Number[2].def;
std::string nameNewView = Scal2VecOptions_String[0].def;
PView *vRef = 0, *vX = 0, *vY = 0, *vZ = 0;
PViewData *dataRef = 0, *dataX = 0, *dataY = 0, *dataZ = 0;
// Load data
if(iViewX >= 0){
vX = getView(iViewX, v);
if(!vX){
Msg::Error("Scal2Vec plugin could not find View X: %i", iViewX);
return v;
}
dataX = vX->getData();
if(!vRef){
vRef = vX;
dataRef = dataX;
}
}
if(iViewY >= 0){
vY = getView(iViewY, v);
if(!vY){
Msg::Error("Scal2Vec plugin could not find View Y: %i", iViewY);
return v;
}
dataY = vY->getData();
if(!vRef){
vRef = vY;
dataRef = dataY;
}
}
if(iViewZ >= 0){
vZ = getView(iViewZ, v);
if(!vZ){
Msg::Error("Scal2Vec plugin could not find View Z: %i", iViewZ);
return v;
}
dataZ = vZ->getData();
if(!vRef){
vRef = vZ;
dataRef = dataZ;
}
}
if(!vRef){
Msg::Error("Scal2Vec plugin could not find any view.", iViewZ);
return v;
}
// Initialize the new view
PView *vNew = new PView();
PViewDataList *dataNew = getDataList(vNew);
for(int ent = 0; ent < dataRef->getNumEntities(0); ent++){
for(int ele = 0; ele < dataRef->getNumElements(0, ent); ele++){
if(dataRef->skipElement(0, ent, ele)) continue;
int numComp = 3; // The 3 components of the new view: x,y,z
int type = dataRef->getType(0, ent, ele);
int numNodes = dataRef->getNumNodes(0, ent, ele);
std::vector<double> *out = dataNew->incrementList(numComp, type, numNodes); // Pointer in data of the new view
if(!out) continue;
double x[8], y[8], z[8], valX, valY, valZ;
for(int nod = 0; nod < numNodes; nod++)
dataRef->getNode(0, ent, ele, nod, x[nod], y[nod], z[nod]);
int dim = dataRef->getDimension(0, ent, ele);
elementFactory factory;
element *element = factory.create(numNodes, dim, x, y, z);
if(!element) continue;
for(int nod = 0; nod < numNodes; nod++) out->push_back(x[nod]); // Save coordinates (x,y,z)
for(int nod = 0; nod < numNodes; nod++) out->push_back(y[nod]);
for(int nod = 0; nod < numNodes; nod++) out->push_back(z[nod]);
for(int step = 0; step < dataRef->getNumTimeSteps(); step++){
for(int nod = 0; nod < numNodes; nod++){
if(vX) dataX->getValue(step, ent, ele, nod, 0, valX); else valX = 0;
if(vY) dataY->getValue(step, ent, ele, nod, 0, valY); else valY = 0;
if(vZ) dataZ->getValue(step, ent, ele, nod, 0, valZ); else valZ = 0;
out->push_back(valX); // Save values (fx,fy,fz)
out->push_back(valY);
out->push_back(valZ);
}
}
delete element;
}
}
for(int step = 0; step < dataRef->getNumTimeSteps(); step++){
if(dataRef->hasTimeStep(step)){
double time = dataRef->getTime(step);
dataNew->Time.push_back(time);
}
}
dataNew->setName(nameNewView);
dataNew->setFileName(nameNewView + ".pos");
dataNew->finalize();
return vNew;
}
PView *GMSH_ParticlesPlugin::execute(PView *v)
{
double A2 = ParticlesOptions_Number[11].def;
double A1 = ParticlesOptions_Number[12].def;
double A0 = ParticlesOptions_Number[13].def;
double DT = ParticlesOptions_Number[14].def;
int maxIter = (int)ParticlesOptions_Number[15].def;
int timeStep = (int)ParticlesOptions_Number[16].def;
int iView = (int)ParticlesOptions_Number[17].def;
PView *v1 = getView(iView, v);
if(!v1) return v;
PViewData *data1 = getPossiblyAdaptiveData(v1);
// sanity checks
if(timeStep > data1->getNumTimeSteps() - 1){
Msg::Error("Invalid time step (%d) in view[%d]: using 0", v1->getIndex());
timeStep = 0;
}
OctreePost o1(v1);
PView *v2 = new PView();
PViewDataList *data2 = getDataList(v2);
// solve 'A2 d^2x/dt^2 + A1 dx/dt + A0 x = F' using a Newmark scheme:
//
// (A2 + gamma DT A1 + beta DT^2 A0) x^{n+1} =
// (2 A2 - (1 - 2 gamma) DT A1 - (0.5 + gamma - 2 beta) DT^2 A0) x^n +
// (-A2 - (gamma - 1) DT A1 - (0.5 - gamma + beta) DT^2 A0) x^{n-1} +
// DT^2 (beta b^{n+1} + (0.5 + gamma - 2 beta) b^n + (0.5 - gamma + beta) b^{n-1})
//
// coefs for constant acceleration (unconditinonally stable)
const double gamma = 0.5, beta = 0.25;
double c1 = (A2 + gamma * DT * A1 + beta * DT * DT * A0);
double c2 = (2 * A2 - (1 - 2 * gamma) * DT * A1 - (0.5 + gamma - 2 * beta) * DT * DT * A0);
double c3 = (-A2 - (gamma - 1) * DT * A1 - (0.5 - gamma + beta) * DT * DT * A0);
double c4 = DT * DT * (beta + (0.5 + gamma - 2 * beta) + (0.5 - gamma + beta));
for(int i = 0; i < getNbU(); ++i){
for(int j = 0; j < getNbV(); ++j){
double XINIT[3], X0[3], X1[3];
getPoint(i, j, XINIT);
getPoint(i, j, X0);
getPoint(i, j, X1);
data2->NbVP++;
data2->VP.push_back(XINIT[0]);
data2->VP.push_back(XINIT[1]);
data2->VP.push_back(XINIT[2]);
for(int iter = 0; iter < maxIter; iter++){
double F[3], X[3];
o1.searchVector(X1[0], X1[1], X1[2], F, timeStep);
for(int k = 0; k < 3; k++)
X[k] = (c2 * X1[k] + c3 * X0[k] + c4 * F[k]) / c1;
data2->VP.push_back(X[0] - XINIT[0]);
data2->VP.push_back(X[1] - XINIT[1]);
data2->VP.push_back(X[2] - XINIT[2]);
for(int k = 0; k < 3; k++){
X0[k] = X1[k];
X1[k] = X[k];
}
}
}
}
v2->getOptions()->vectorType = PViewOptions::Displacement;
data2->setName(data1->getName() + "_Particles");
data2->setFileName(data1->getName() + "_Particles.pos");
data2->finalize();
return v2;
}
PView *GMSH_MathEvalPlugin::execute(PView *view)
{
int timeStep = (int)MathEvalOptions_Number[0].def;
int iView = (int)MathEvalOptions_Number[1].def;
int otherTimeStep = (int)MathEvalOptions_Number[2].def;
int iOtherView = (int)MathEvalOptions_Number[3].def;
int forceInterpolation = (int)MathEvalOptions_Number[4].def;
int physicalRegion = (int)MathEvalOptions_Number[5].def;
std::vector<std::string> expr(9);
for(int i = 0; i < 9; i++) expr[i] = MathEvalOptions_String[i].def;
PView *v1 = getView(iView, view);
if(!v1) return view;
PViewData *data1 = getPossiblyAdaptiveData(v1);
if(data1->hasMultipleMeshes()){
Msg::Error("MathEval plugin cannot be applied to multi-mesh views");
return view;
}
PView *otherView = v1;
if(iOtherView >= 0){
otherView = getView(iOtherView, view);
if(!otherView){
Msg::Error("MathEval plugin could not find other view %i", iOtherView);
return view;
}
}
PViewData *otherData = getPossiblyAdaptiveData(otherView);
if(otherData->hasMultipleMeshes()){
Msg::Error("MathEval plugin cannot be applied to multi-mesh views");
return view;
}
if(otherTimeStep < 0 && otherData->getNumTimeSteps() != data1->getNumTimeSteps()){
Msg::Error("Number of time steps don't match: using step 0");
otherTimeStep = 0;
}
else if(otherTimeStep > otherData->getNumTimeSteps() - 1){
Msg::Error("Invalid time step (%d) in View[%d]: using step 0 instead",
otherTimeStep, otherView->getIndex());
otherTimeStep = 0;
}
int numComp2;
if(expr[3].size() || expr[4].size() || expr[5].size() ||
expr[6].size() || expr[7].size() || expr[8].size()){
numComp2 = 9;
for(int i = 0; i < 9; i++)
if(expr[i].empty()) expr[i] = "0";
}
else if(expr[1].size() || expr[2].size()){
numComp2 = 3;
for(int i = 0; i < 3; i++)
if(expr[i].empty()) expr[i] = "0";
}
else{
numComp2 = 1;
}
expr.resize(numComp2);
const char *names[] =
{ "x", "y", "z", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8",
"w0", "w1", "w2", "w3", "w4", "w5", "w6", "w7", "w8" };
unsigned int numVariables = sizeof(names) / sizeof(names[0]);
std::vector<std::string> variables(numVariables);
for(unsigned int i = 0; i < numVariables; i++) variables[i] = names[i];
mathEvaluator f(expr, variables);
if(expr.empty()) return view;
std::vector<double> values(numVariables), res(numComp2);
OctreePost *octree = 0;
if(forceInterpolation ||
(data1->getNumEntities() != otherData->getNumEntities()) ||
(data1->getNumElements() != otherData->getNumElements())){
Msg::Info("Other view based on different grid: interpolating...");
octree = new OctreePost(otherView);
}
PView *v2 = new PView();
PViewDataList *data2 = getDataList(v2);
if(timeStep < 0){
timeStep = - data1->getNumTimeSteps();
}
else if(timeStep > data1->getNumTimeSteps() - 1){
Msg::Error("Invalid time step (%d) in View[%d]: using all steps instead",
timeStep, v1->getIndex());
timeStep = - data1->getNumTimeSteps();
}
int firstNonEmptyStep = data1->getFirstNonEmptyTimeStep();
int timeBeg = (timeStep < 0) ? firstNonEmptyStep : timeStep;
int timeEnd = (timeStep < 0) ? -timeStep : timeStep + 1;
for(int ent = 0; ent < data1->getNumEntities(timeBeg); ent++){
bool ok = (physicalRegion <= 0);
if(physicalRegion > 0){
GEntity *ge = data1->getEntity(timeBeg, ent);
if(ge){
std::vector<int>::iterator it = std::find
(ge->physicals.begin(), ge->physicals.end(), physicalRegion);
ok = (it != ge->physicals.end());
}
}
if(!ok) continue;
for(int ele = 0; ele < data1->getNumElements(timeBeg, ent); ele++){
if(data1->skipElement(timeBeg, ent, ele)) continue;
int numNodes = data1->getNumNodes(timeBeg, ent, ele);
int type = data1->getType(timeBeg, ent, ele);
int numComp = data1->getNumComponents(timeBeg, ent, ele);
int otherNumComp = (!otherData || octree) ? 9 :
otherData->getNumComponents(timeBeg, ent, ele);
std::vector<double> *out = data2->incrementList(numComp2, type, numNodes);
std::vector<double> v(std::max(9, numComp), 0.);
std::vector<double> w(std::max(9, otherNumComp), 0.);
std::vector<double> x(numNodes), y(numNodes), z(numNodes);
for(int nod = 0; nod < numNodes; nod++)
data1->getNode(timeBeg, ent, ele, nod, x[nod], y[nod], z[nod]);
for(int nod = 0; nod < numNodes; nod++) out->push_back(x[nod]);
for(int nod = 0; nod < numNodes; nod++) out->push_back(y[nod]);
for(int nod = 0; nod < numNodes; nod++) out->push_back(z[nod]);
for(int step = timeBeg; step < timeEnd; step++){
if(!data1->hasTimeStep(step)) continue;
int step2 = (otherTimeStep < 0) ? step : otherTimeStep;
for(int nod = 0; nod < numNodes; nod++){
for(int comp = 0; comp < numComp; comp++)
data1->getValue(step, ent, ele, nod, comp, v[comp]);
if(otherData){
if(octree){
int qn = forceInterpolation ? numNodes : 0;
if(!octree->searchScalar(x[nod], y[nod], z[nod], &w[0], step2,
0, qn, &x[0], &y[0], &z[0]))
if(!octree->searchVector(x[nod], y[nod], z[nod], &w[0], step2,
0, qn, &x[0], &y[0], &z[0]))
octree->searchTensor(x[nod], y[nod], z[nod], &w[0], step2,
0, qn, &x[0], &y[0], &z[0]);
}
else
for(int comp = 0; comp < otherNumComp; comp++)
otherData->getValue(step2, ent, ele, nod, comp, w[comp]);
}
values[0] = x[nod]; values[1] = y[nod]; values[2] = z[nod];
for(int i = 0; i < 9; i++) values[3 + i] = v[i];
for(int i = 0; i < 9; i++) values[12 + i] = w[i];
if(f.eval(values, res)){
for(int i = 0; i < numComp2; i++)
out->push_back(res[i]);
}
else{
goto end;
}
}
}
}
}
end:
if(octree) delete octree;
if(timeStep < 0){
for(int i = firstNonEmptyStep; i < data1->getNumTimeSteps(); i++) {
if(!data1->hasTimeStep(i)) continue;
data2->Time.push_back(data1->getTime(i));
}
}
else
data2->Time.push_back(data1->getTime(timeStep));
data2->setName(data1->getName() + "_MathEval");
data2->setFileName(data1->getName() + "_MathEval.pos");
data2->finalize();
return v2;
}
PView *GMSH_HarmonicToTimePlugin::execute(PView * v)
{
int rIndex = (int)HarmonicToTimeOptions_Number[0].def;
int iIndex = (int)HarmonicToTimeOptions_Number[1].def;
int nSteps = (int)HarmonicToTimeOptions_Number[2].def;
int iView = (int)HarmonicToTimeOptions_Number[3].def;
PView *v1 = getView(iView, v);
if(!v1) return v;
PViewData *data1 = v1->getData();
if(data1->hasMultipleMeshes()){
Msg::Error("HarmonicToTime plugin cannot be applied to multi-mesh views");
return v1;
}
if(rIndex < 0 || rIndex >= data1->getNumTimeSteps() ||
iIndex < 0 || iIndex >= data1->getNumTimeSteps()){
Msg::Error("Wrong real or imaginary part index");
return v1;
}
if(nSteps <= 0){
Msg::Error("nSteps should be > 0");
return v1;
}
PView *v2 = new PView();
PViewDataList *data2 = getDataList(v2);
for(int ent = 0; ent < data1->getNumEntities(0); ent++){
for(int ele = 0; ele < data1->getNumElements(0, ent); ele++){
if(data1->skipElement(0, ent, ele)) continue;
int numNodes = data1->getNumNodes(0, ent, ele);
int type = data1->getType(0, ent, ele);
int numComp = data1->getNumComponents(0, ent, ele);
std::vector<double> *out = data2->incrementList(numComp, type, numNodes);
std::vector<double> x(numNodes), y(numNodes), z(numNodes);
std::vector<double> vr(numNodes * numComp), vi(numNodes * numComp);
for(int nod = 0; nod < numNodes; nod++){
data1->getNode(0, ent, ele, nod, x[nod], y[nod], z[nod]);
for(int comp = 0; comp < numComp; comp++){
data1->getValue(rIndex, ent, ele, nod, comp, vr[numComp * nod + comp]);
data1->getValue(iIndex, ent, ele, nod, comp, vi[numComp * nod + comp]);
}
}
for(int nod = 0; nod < numNodes; nod++) out->push_back(x[nod]);
for(int nod = 0; nod < numNodes; nod++) out->push_back(y[nod]);
for(int nod = 0; nod < numNodes; nod++) out->push_back(z[nod]);
for(int t = 0; t < nSteps; t++) {
double p = 2. * M_PI * t / nSteps;
for(int nod = 0; nod < numNodes; nod++) {
for(int comp = 0; comp < numComp; comp++) {
double val = vr[numComp * nod + comp] * cos(p) -
vi[numComp * nod + comp] * sin(p);
out->push_back(val);
}
}
}
}
}
for(int i = 0; i < nSteps; i++){
double p = 2. * M_PI * i / (double)nSteps;
data2->Time.push_back(p);
}
data2->setName(data1->getName() + "_HarmonicToTime");
data2->setFileName(data1->getName() + "_HarmonicToTime.pos");
data2->finalize();
return v2;
}
PView *GMSH_MinMaxPlugin::execute(PView * v)
{
int iView = (int)MinMaxOptions_Number[0].def;
int overTime = (int)MinMaxOptions_Number[1].def;
int argument = (int)MinMaxOptions_Number[2].def;
PView *v1 = getView(iView, v);
if(!v1) return v;
PViewData *data1 = v1->getData(true);
PView *vMin = new PView();
PView *vMax = new PView();
PViewDataList *dataMin = getDataList(vMin);
PViewDataList *dataMax = getDataList(vMax);
if(!argument){
double x = data1->getBoundingBox().center().x();
double y = data1->getBoundingBox().center().y();
double z = data1->getBoundingBox().center().z();
dataMin->SP.push_back(x); dataMin->SP.push_back(y); dataMin->SP.push_back(z);
dataMax->SP.push_back(x); dataMax->SP.push_back(y); dataMax->SP.push_back(z);
dataMin->NbSP = 1;
dataMax->NbSP = 1;
}
double min=VAL_INF, max=-VAL_INF, timeMin=0, timeMax=0;
for(int step = 0; step < data1->getNumTimeSteps(); step++){
if(data1->hasTimeStep(step)){
double minView = VAL_INF, maxView = -VAL_INF;
double xmin = 0., ymin = 0., zmin = 0., xmax = 0., ymax = 0., zmax = 0.;
for(int ent = 0; ent < data1->getNumEntities(step); ent++){
for(int ele = 0; ele < data1->getNumElements(step, ent); ele++){
for(int nod = 0; nod < data1->getNumNodes(step, ent, ele); nod++){
double val;
data1->getScalarValue(step, ent, ele, nod, val);
if(val < minView){
data1->getNode(step, ent, ele, nod, xmin, ymin, zmin);
minView = val;
}
if(val > maxView){
data1->getNode(step, ent, ele, nod, xmax, ymax, zmax);
maxView = val;
}
}
}
}
if(!overTime){
if(argument){
dataMin->SP.push_back(xmin); dataMin->SP.push_back(ymin); dataMin->SP.push_back(zmin);
dataMax->SP.push_back(xmax); dataMax->SP.push_back(ymax); dataMax->SP.push_back(zmax);
(dataMin->NbSP)++;
(dataMax->NbSP)++;
}
else{
double time = data1->getTime(step);
dataMin->Time.push_back(time);
dataMax->Time.push_back(time);
}
dataMin->SP.push_back(minView);
dataMax->SP.push_back(maxView);
}
else{
if(minView < min){
min = minView;
timeMin = data1->getTime(step);
}
if(maxView > max){
max = maxView;
timeMax = data1->getTime(step);
}
}
}
}
if(overTime){
dataMin->SP.push_back(min);
dataMax->SP.push_back(max);
dataMin->Time.push_back(timeMin);
dataMax->Time.push_back(timeMax);
}
vMin->getOptions()->intervalsType = PViewOptions::Numeric;
vMax->getOptions()->intervalsType = PViewOptions::Numeric;
dataMin->setName(data1->getName() + "_Min");
dataMin->setFileName(data1->getName() + "_Min.pos");
dataMin->finalize();
dataMax->setName(data1->getName() + "_Max");
dataMax->setFileName(data1->getName() + "_Max.pos");
dataMax->finalize();
return 0;
}
PView *GMSH_SummationPlugin::execute(PView *view)
{
int nviewmax = 8;
std::vector<int> views_indices;
std::vector<PView *> pviews;
std::vector<PViewData *> pviewsdata;
// Get view indices and PViews
for(int i = 0; i < nviewmax; i++) {
int iview = (int)SummationOptions_Number[i].def;
if(i == 0 || iview > -1) {
views_indices.push_back(iview);
pviews.push_back(getView(iview, view));
if(!pviews.back()) {
Msg::Error("Summation plugin could not find view %i", iview);
return view;
}
pviewsdata.push_back(getPossiblyAdaptiveData(pviews.back()));
if(pviewsdata.back()->hasMultipleMeshes()) {
Msg::Error("Summation plugin cannot be applied to multi-mesh views");
return view;
}
}
}
// Number of view to sum
int nviews = pviews.size();
// Check if the views share the same mesh
//(at least same number of elements and entities)
// If a view has an empty timestep: skip it, no problem.
for(int j = 1; j < nviews; j++) {
if(pviewsdata[j]->getNumEntities() == 0 &&
pviewsdata[j]->getNumElements() == 0)
continue; // empty time step
if((pviewsdata[0]->getNumEntities() != pviewsdata[j]->getNumEntities()) ||
(pviewsdata[0]->getNumElements() != pviewsdata[j]->getNumElements())) {
Msg::Error("Summation plugin: views based on different grid.");
}
}
// get min/max indices of time steps
int timeBeg = pviewsdata[0]->getFirstNonEmptyTimeStep();
int timeEnd = pviewsdata[0]->getNumTimeSteps();
int iref = 0; // reference view and time step to get mesh's info
int stepref = timeBeg;
for(int i = 1; i < nviews; i++) {
if(timeBeg > pviewsdata[i]->getFirstNonEmptyTimeStep()) {
timeBeg = pviewsdata[i]->getFirstNonEmptyTimeStep();
iref = i;
stepref = timeBeg;
}
timeEnd = std::max(timeEnd, pviewsdata[i]->getNumTimeSteps());
}
// Init result
PView *v2 = new PView();
PViewDataList *data2 = getDataList(v2);
for(int ent = 0; ent < pviewsdata[iref]->getNumEntities(stepref); ent++) {
for(int ele = 0; ele < pviewsdata[iref]->getNumElements(stepref, ent);
ele++) {
// if(pviewsdata[0]->skipElement(timeBeg, ent, ele)) continue;
int numNodes = pviewsdata[iref]->getNumNodes(stepref, ent, ele);
int type = pviewsdata[iref]->getType(stepref, ent, ele);
int numComp = pviewsdata[iref]->getNumComponents(stepref, ent, ele);
int numComp2 = numComp;
std::vector<double> *out = data2->incrementList(numComp2, type, numNodes);
std::vector<double> v(std::max(9, numComp), 0.);
std::vector<double> x(numNodes), y(numNodes), z(numNodes);
for(int nod = 0; nod < numNodes; nod++)
pviewsdata[iref]->getNode(stepref, ent, ele, nod, x[nod], y[nod],
z[nod]);
for(int nod = 0; nod < numNodes; nod++) out->push_back(x[nod]);
for(int nod = 0; nod < numNodes; nod++) out->push_back(y[nod]);
for(int nod = 0; nod < numNodes; nod++) out->push_back(z[nod]);
for(int step = timeBeg; step < timeEnd; step++) {
for(int nod = 0; nod < numNodes; nod++) {
for(int comp = 0; comp < numComp; comp++) {
v[comp] = 0;
for(int iview = 0; iview < nviews; iview++) {
if(!pviewsdata[iview]->hasTimeStep(step)) continue;
double d;
pviewsdata[iview]->getValue(step, ent, ele, nod, comp, d);
v[comp] += d;
}
}
for(int i = 0; i < numComp2; i++) out->push_back(v[i]);
}
}
}
}
// Set time
for(int step = timeBeg; step < timeEnd; step++) {
int iview = 0;
for(iview = 0; iview < nviews; iview++) {
if(!pviewsdata[iview]->hasTimeStep(step)) continue;
break;
}
data2->Time.push_back(pviewsdata[iview]->getTime(step));
}
std::string outputname = SummationOptions_String[0].def;
if(outputname == "default")
outputname = pviewsdata[0]->getName() + "_Summation";
data2->setName(outputname);
data2->setFileName(outputname + "_Summation.pos");
data2->finalize();
return v2;
}
PView *GMSH_ExtractElementsPlugin::execute(PView *v)
{
double MinVal = ExtractElementsOptions_Number[0].def;
double MaxVal = ExtractElementsOptions_Number[1].def;
int thisStep = (int)ExtractElementsOptions_Number[2].def;
int visible = (int)ExtractElementsOptions_Number[3].def;
int dimension = (int)ExtractElementsOptions_Number[4].def;
int iView = (int)ExtractElementsOptions_Number[5].def;
PView *v1 = getView(iView, v);
if(!v1) return v;
PViewData *data1 = getPossiblyAdaptiveData(v1);
bool checkMinMax = MinVal != MaxVal;
int step = (thisStep < 0) ? 0 : thisStep;
if(thisStep > data1->getNumTimeSteps() - 1) {
Msg::Error("Invalid time step (%d) in View[%d]: using first step instead",
thisStep, v1->getIndex());
step = 0;
}
PView *v2 = new PView();
PViewDataList *data2 = getDataList(v2);
for(int ent = 0; ent < data1->getNumEntities(step); ent++) {
if(visible && data1->skipEntity(step, ent)) continue;
for(int ele = 0; ele < data1->getNumElements(step, ent); ele++) {
if(data1->skipElement(step, ent, ele, visible)) continue;
int dim = data1->getDimension(step, ent, ele);
if((dimension > 0) && (dim != dimension)) continue;
int numNodes = data1->getNumNodes(step, ent, ele);
if(checkMinMax) {
double d = 0.;
for(int nod = 0; nod < numNodes; nod++) {
double val;
data1->getScalarValue(step, ent, ele, nod, val);
d += val;
}
d /= (double)numNodes;
// use '>=' and '<' so that we can do segmentation without
// worrying about roundoff errors
if(d < MinVal || d >= MaxVal) continue;
}
int type = data1->getType(step, ent, ele);
int numComp = data1->getNumComponents(step, ent, ele);
std::vector<double> *out = data2->incrementList(numComp, type, numNodes);
std::vector<double> x(numNodes), y(numNodes), z(numNodes);
std::vector<double> v(numNodes * numComp);
for(int nod = 0; nod < numNodes; nod++)
data1->getNode(step, ent, ele, nod, x[nod], y[nod], z[nod]);
for(int nod = 0; nod < numNodes; nod++) out->push_back(x[nod]);
for(int nod = 0; nod < numNodes; nod++) out->push_back(y[nod]);
for(int nod = 0; nod < numNodes; nod++) out->push_back(z[nod]);
for(int step = 0; step < data1->getNumTimeSteps(); step++) {
if(!data1->hasTimeStep(step)) continue;
if((thisStep >= 0) && (thisStep != step)) continue;
for(int nod = 0; nod < numNodes; nod++) {
for(int comp = 0; comp < numComp; comp++) {
double temp;
data1->getValue(step, ent, ele, nod, comp, temp);
out->push_back(temp);
}
}
}
}
}
if(thisStep >= 0)
data2->Time.push_back(data1->getTime(thisStep));
else {
for(int step = 0; step < data1->getNumTimeSteps(); step++) {
data2->Time.push_back(data1->getTime(step));
}
}
data2->setName(data1->getName() + "_ExtractElements");
data2->setFileName(data1->getName() + "_ExtractElements.pos");
data2->finalize();
return v2;
}
PView *GMSH_TriangulatePlugin::execute(PView *v)
{
int iView = (int)TriangulateOptions_Number[0].def;
PView *v1 = getView(iView, v);
if(!v1) return v;
PViewData *data1 = v1->getData();
if(data1->hasMultipleMeshes()){
Msg::Error("Triangulate plugin cannot be applied to multi-mesh views");
return v1;
}
// create list of points with associated data
std::vector<MVertex*> points;
int numSteps = data1->getNumTimeSteps();
for(int ent = 0; ent < data1->getNumEntities(0); ent++){
for(int ele = 0; ele < data1->getNumElements(0, ent); ele++){
if(data1->skipElement(0, ent, ele)) continue;
if(data1->getNumNodes(0, ent, ele) != 1) continue;
int numComp = data1->getNumComponents(0, ent, ele);
double x, y, z;
data1->getNode(0, ent, ele, 0, x, y, z);
PointData *p = new PointData(x, y, z, numComp * numSteps);
for(int step = 0; step < numSteps; step++)
for(int comp = 0; comp < numComp; comp++)
data1->getValue(step, ent, ele, 0, comp, p->v[3 + numComp * step + comp]);
points.push_back(p);
}
}
if(points.size() < 3){
Msg::Error("Need at least 3 points to triangulate");
for(unsigned int i = 0; i < points.size(); i++)
delete points[i];
return v1;
}
// project points onto plane
discreteFace *s = new discreteFace
(GModel::current(), GModel::current()->getNumFaces() + 1);
s->computeMeanPlane(points);
double plan[3][3];
s->getMeanPlaneData(plan);
for(unsigned int i = 0; i < points.size(); i++) project(points[i], plan);
delete s;
// get lc
SBoundingBox3d bbox;
for(unsigned int i = 0; i < points.size(); i++) bbox += points[i]->point();
double lc = norm(SVector3(bbox.max(), bbox.min()));
// build a point record structure for the divide and conquer algorithm
DocRecord doc(points.size());
for(unsigned int i = 0; i < points.size(); i++){
double XX = CTX::instance()->mesh.randFactor * lc * (double)rand() / (double)RAND_MAX;
double YY = CTX::instance()->mesh.randFactor * lc * (double)rand() / (double)RAND_MAX;
doc.points[i].where.h = points[i]->x() + XX;
doc.points[i].where.v = points[i]->y() + YY;
doc.points[i].adjacent = NULL;
doc.points[i].data = (void*)points[i];
}
// triangulate
doc.MakeMeshWithPoints();
// create output (using unperturbed data)
PView *v2 = new PView();
PViewDataList *data2 = getDataList(v2);
for(int i = 0; i < doc.numTriangles; i++){
PointData *p[3];
p[0] = (PointData*)doc.points[doc.triangles[i].a].data;
p[1] = (PointData*)doc.points[doc.triangles[i].b].data;
p[2] = (PointData*)doc.points[doc.triangles[i].c].data;
int numComp = 0;
std::vector<double> *vec = 0;
if((int)p[0]->v.size() == 3 + 9 * numSteps &&
(int)p[1]->v.size() == 3 + 9 * numSteps &&
(int)p[2]->v.size() == 3 + 9 * numSteps){
numComp = 9; data2->NbTT++; vec = &data2->TT;
}
else if((int)p[0]->v.size() == 3 + 3 * numSteps &&
(int)p[1]->v.size() == 3 + 3 * numSteps &&
(int)p[2]->v.size() == 3 + 3 * numSteps){
numComp = 3; data2->NbVT++; vec = &data2->VT;
}
else{
numComp = 1; data2->NbST++; vec = &data2->ST;
}
for(int nod = 0; nod < 3; nod++) vec->push_back(p[nod]->v[0]);
for(int nod = 0; nod < 3; nod++) vec->push_back(p[nod]->v[1]);
for(int nod = 0; nod < 3; nod++) vec->push_back(p[nod]->v[2]);
for(int step = 0; step < numSteps; step++)
for(int nod = 0; nod < 3; nod++)
for(int comp = 0; comp < numComp; comp++)
vec->push_back(p[nod]->v[3 + numComp * step + comp]);
}
for(unsigned int i = 0; i < points.size(); i++)
delete points[i];
for(int i = 0; i < data1->getNumTimeSteps(); i++)
data2->Time.push_back(data1->getTime(i));
data2->setName(data1->getName() + "_Triangulate");
data2->setFileName(data1->getName() + "_Triangulate.pos");
data2->finalize();
return v2;
}
PView *GMSH_Scal2VecPlugin::execute(PView *v)
{
// Load options
int iView[3];
for (int comp=0; comp<3; comp++)
iView[comp] = (int)Scal2VecOptions_Number[comp].def;
// Load data
PView *vRef=0, *vComp[3];
for (int comp=0; comp<3; comp++) {
if (iView[comp]<0) vComp[comp] = 0;
else {
vComp[comp] = getView(iView[comp], v);
if (!vComp[comp]) {
Msg::Error("Scal2Vec plugin could not find View '%i'", iView[comp]);
return v;
}
if (!vRef) vRef = vComp[comp];
}
}
if (!vRef) {
Msg::Error("Scal2Vec plugin could not find any view.");
return v;
}
PViewData *dataRef = vRef->getData();
// Initialize the new view
PView *vNew = new PView();
PViewDataList *dataNew = getDataList(vNew);
int step0 = dataRef->getFirstNonEmptyTimeStep();
for (int ent=0; ent < dataRef->getNumEntities(step0); ent++) {
for (int ele=0; ele < dataRef->getNumElements(step0, ent); ele++) {
if (dataRef->skipElement(step0, ent, ele)) continue;
int type = dataRef->getType(step0, ent, ele);
int numNodes = dataRef->getNumNodes(step0, ent, ele);
std::vector<double> *out = dataNew->incrementList(3, type, numNodes); // Pointer in data of the new view
if (!out) continue;
double x[8], y[8], z[8];
for (int nod=0; nod<numNodes; nod++)
dataRef->getNode(step0, ent, ele, nod, x[nod], y[nod], z[nod]);
int dim = dataRef->getDimension(step0, ent, ele);
elementFactory factory;
element *element = factory.create(numNodes, dim, x, y, z);
if (!element) continue;
for (int nod=0; nod<numNodes; nod++) out->push_back(x[nod]); // Save coordinates (x,y,z)
for (int nod=0; nod<numNodes; nod++) out->push_back(y[nod]);
for (int nod=0; nod<numNodes; nod++) out->push_back(z[nod]);
for (int step=step0; step < dataRef->getNumTimeSteps(); step++) {
if (!dataRef->hasTimeStep(step)) continue;
for (int nod=0; nod<numNodes; nod++) {
for (int comp=0; comp<3; comp++) {
double val=0.;
if(vComp[comp]) vComp[comp]->getData()->getValue(step, ent, ele, nod, 0, val);
out->push_back(val); // Save value
}
}
}
delete element;
}
}
for (int step=step0; step < dataRef->getNumTimeSteps(); step++) {
if (!dataRef->hasTimeStep(step)) continue;
dataNew->Time.push_back(dataRef->getTime(step));
}
std::string nameNewView = Scal2VecOptions_String[0].def;
dataNew->setName(nameNewView);
dataNew->setFileName(nameNewView + ".pos");
dataNew->finalize();
return vNew;
}
PView *GMSH_EigenvaluesPlugin::execute(PView *v)
{
int iView = (int)EigenvaluesOptions_Number[0].def;
PView *v1 = getView(iView, v);
if(!v1) return v;
PViewData *data1 = getPossiblyAdaptiveData(v1);
if(data1->hasMultipleMeshes()){
Msg::Error("Eigenvalues plugin cannot be run on multi-mesh views");
return v;
}
PView *min = new PView();
PView *mid = new PView();
PView *max = new PView();
PViewDataList *dmin = getDataList(min);
PViewDataList *dmid = getDataList(mid);
PViewDataList *dmax = getDataList(max);
for(int ent = 0; ent < data1->getNumEntities(0); ent++){
for(int ele = 0; ele < data1->getNumElements(0, ent); ele++){
if(data1->skipElement(0, ent, ele)) continue;
int numComp = data1->getNumComponents(0, ent, ele);
if(numComp != 9) continue;
int type = data1->getType(0, ent, ele);
int numNodes = data1->getNumNodes(0, ent, ele);
std::vector<double> *outmin = dmin->incrementList(1, type, numNodes);
std::vector<double> *outmid = dmid->incrementList(1, type, numNodes);
std::vector<double> *outmax = dmax->incrementList(1, type, numNodes);
if(!outmin || !outmid || !outmax) continue;
double xyz[3][8];
for(int nod = 0; nod < numNodes; nod++)
data1->getNode(0, ent, ele, nod, xyz[0][nod], xyz[1][nod], xyz[2][nod]);
for(int i = 0; i < 3; i++){
for(int nod = 0; nod < numNodes; nod++){
outmin->push_back(xyz[i][nod]);
outmid->push_back(xyz[i][nod]);
outmax->push_back(xyz[i][nod]);
}
}
for(int step = 0; step < data1->getNumTimeSteps(); step++){
for(int nod = 0; nod < numNodes; nod++){
double val[9], w[3];
for(int comp = 0; comp < numComp; comp++)
data1->getValue(step, ent, ele, nod, comp, val[comp]);
double A[3][3] = {{val[0], val[1], val[2]},
{val[3], val[4], val[5]},
{val[6], val[7], val[8]}};
eigenvalue(A, w);
outmin->push_back(w[2]);
outmid->push_back(w[1]);
outmax->push_back(w[0]);
}
}
}
}
for(int i = 0; i < data1->getNumTimeSteps(); i++){
double time = data1->getTime(i);
dmin->Time.push_back(time);
dmid->Time.push_back(time);
dmax->Time.push_back(time);
}
dmin->setName(data1->getName() + "_MinEigenvalues");
dmin->setFileName(data1->getName() + "_MinEigenvalues.pos");
dmin->finalize();
dmid->setName(data1->getName() + "_MidEigenvalues");
dmid->setFileName(data1->getName() + "_MidEigenvalues.pos");
dmid->finalize();
dmax->setName(data1->getName() + "_MaxEigenvalues");
dmax->setFileName(data1->getName() + "_MaxEigenvalues.pos");
dmax->finalize();
return 0;
}
PView *GMSH_RemovePlugin::execute(PView *v)
{
int iView = (int)RemoveOptions_Number[13].def;
PView *v1 = getView(iView, v);
if(!v1) return v;
PViewDataList *data1 = getDataList(v1);
if(!data1) return v;
int scalar = (int)RemoveOptions_Number[10].def;
int vector = (int)RemoveOptions_Number[11].def;
int tensor = (int)RemoveOptions_Number[12].def;
if(RemoveOptions_Number[0].def) {
data1->NbT2 = 0;
data1->T2D.clear();
data1->T2C.clear();
}
if(RemoveOptions_Number[1].def) {
data1->NbT3 = 0;
data1->T3D.clear();
data1->T3C.clear();
}
if(RemoveOptions_Number[2].def) {
if(scalar) {
data1->NbSP = 0;
data1->SP.clear();
}
if(vector) {
data1->NbVP = 0;
data1->VP.clear();
}
if(tensor) {
data1->NbTP = 0;
data1->TP.clear();
}
}
if(RemoveOptions_Number[3].def) {
if(scalar) {
data1->NbSL = 0;
data1->SL.clear();
}
if(vector) {
data1->NbVL = 0;
data1->VL.clear();
}
if(tensor) {
data1->NbTL = 0;
data1->TL.clear();
}
}
if(RemoveOptions_Number[4].def) {
if(scalar) {
data1->NbST = 0;
data1->ST.clear();
}
if(vector) {
data1->NbVT = 0;
data1->VT.clear();
}
if(tensor) {
data1->NbTT = 0;
data1->TT.clear();
}
}
if(RemoveOptions_Number[5].def) {
if(scalar) {
data1->NbSQ = 0;
data1->SQ.clear();
}
if(vector) {
data1->NbVQ = 0;
data1->VQ.clear();
}
if(tensor) {
data1->NbTQ = 0;
data1->TQ.clear();
}
}
if(RemoveOptions_Number[6].def) {
if(scalar) {
data1->NbSS = 0;
data1->SS.clear();
}
if(vector) {
data1->NbVS = 0;
data1->VS.clear();
}
if(tensor) {
data1->NbTS = 0;
data1->TS.clear();
}
}
if(RemoveOptions_Number[7].def) {
if(scalar) {
data1->NbSH = 0;
data1->SH.clear();
}
if(vector) {
data1->NbVH = 0;
data1->VH.clear();
}
if(tensor) {
data1->NbTH = 0;
data1->TH.clear();
}
}
if(RemoveOptions_Number[8].def) {
if(scalar) {
data1->NbSI = 0;
data1->SI.clear();
}
if(vector) {
data1->NbVI = 0;
data1->VI.clear();
}
if(tensor) {
data1->NbTI = 0;
data1->TI.clear();
}
}
if(RemoveOptions_Number[9].def) {
if(scalar) {
data1->NbSY = 0;
data1->SY.clear();
}
if(vector) {
data1->NbVY = 0;
data1->VY.clear();
}
if(tensor) {
data1->NbTY = 0;
data1->TY.clear();
}
}
data1->finalize();
v1->setChanged(true);
return v1;
}
PView *GMSH_CutParametricPlugin::execute(PView *v)
{
int iView = (int)CutParametricOptions_Number[7].def;
PView *v1 = getView(iView, v);
if(!v1) return v;
if(!fillXYZ()) return v;
PViewData *data1 = getPossiblyAdaptiveData(v1);
int numSteps = data1->getNumTimeSteps();
int nbU = (int)CutParametricOptions_Number[2].def;
int nbV = (int)CutParametricOptions_Number[5].def;
int connect = (int)CutParametricOptions_Number[6].def;
if(nbU < 2 && nbV < 2) connect = 0;
OctreePost o(v1);
PView *v2 = new PView();
PViewDataList *data2 = getDataList(v2);
double *res0 = new double[9 * numSteps];
double *res1 = new double[9 * numSteps];
double *res2 = new double[9 * numSteps];
double *res3 = new double[9 * numSteps];
double x0 = 0., y0 = 0., z0 = 0., x1 = 0., y1 = 0., z1 = 0.;
double x2 = 0., y2 = 0., z2 = 0., x3 = 0., y3 = 0., z3 = 0.;
for(int k = 0; k < 9 * numSteps; ++k) res0[k] = res1[k] = 0.;
if(nbU == 1 || nbV == 1 || !connect){
for(unsigned int i = 0; i < x.size(); ++i){
if(i && connect){
x0 = x1;
y0 = y1;
z0 = z1;
for(int k = 0; k < 9 * numSteps; ++k) res0[k] = res1[k];
}
x1 = x[i];
y1 = y[i];
z1 = z[i];
if(data1->getNumScalars()){
o.searchScalar(x1, y1, z1, res1);
addInView(connect, i, 1, numSteps, x0, y0, z0, res0, x1, y1, z1, res1,
data2->SP, &data2->NbSP, data2->SL, &data2->NbSL);
}
if(data1->getNumVectors()){
o.searchVector(x1, y1, z1, res1);
addInView(connect, i, 3, numSteps, x0, y0, z0, res0, x1, y1, z1, res1,
data2->VP, &data2->NbVP, data2->VL, &data2->NbVL);
}
if(data1->getNumTensors()){
o.searchTensor(x1, y1, z1, res1);
addInView(connect, i, 9, numSteps, x0, y0, z0, res0, x1, y1, z1, res1,
data2->TP, &data2->NbTP, data2->TL, &data2->NbTL);
}
}
}
else{
for(int i = 0; i < nbU - 1; ++i){
for(int j = 0; j < nbV - 1; ++j){
int v = i * nbV + j;
x0 = x[v]; y0 = y[v]; z0 = z[v];
x1 = x[v+1]; y1 = y[v+1]; z1 = z[v+1];
x2 = x[v+nbV+1]; y2 = y[v+nbV+1]; z2 = z[v+nbV+1];
x3 = x[v+nbV]; y3 = y[v+nbV]; z3 = z[v+nbV];
if(data1->getNumScalars()){
o.searchScalar(x0, y0, z0, res0);
o.searchScalar(x1, y1, z1, res1);
o.searchScalar(x2, y2, z2, res2);
o.searchScalar(x3, y3, z3, res3);
addInView(1, numSteps, x0, y0, z0, res0, x1, y1, z1, res1,
x2, y2, z2, res2, x3, y3, z3, res3,
data2->SQ, &data2->NbSQ);
}
if(data1->getNumVectors()){
o.searchVector(x0, y0, z0, res0);
o.searchVector(x1, y1, z1, res1);
o.searchVector(x2, y2, z2, res2);
o.searchVector(x3, y3, z3, res3);
addInView(3, numSteps, x0, y0, z0, res0, x1, y1, z1, res1,
x2, y2, z2, res2, x3, y3, z3, res3,
data2->VQ, &data2->NbVQ);
}
if(data1->getNumTensors()){
o.searchTensor(x0, y0, z0, res0);
o.searchTensor(x1, y1, z1, res1);
o.searchTensor(x2, y2, z2, res2);
o.searchTensor(x3, y3, z3, res3);
addInView(9, numSteps, x0, y0, z0, res0, x1, y1, z1, res1,
x2, y2, z2, res2, x3, y3, z3, res3,
data2->TQ, &data2->NbTQ);
}
}
}
}
delete [] res0;
delete [] res1;
delete [] res2;
delete [] res3;
data2->setName(data1->getName() + "_CutParametric");
data2->setFileName(data1->getName() + "_CutParametric.pos");
data2->finalize();
return v2;
}
PView *GMSH_ProbePlugin::execute(PView *v)
{
double x = ProbeOptions_Number[0].def;
double y = ProbeOptions_Number[1].def;
double z = ProbeOptions_Number[2].def;
int iView = (int)ProbeOptions_Number[3].def;
PView *v1 = getView(iView, v);
if(!v1) return v;
PView *v2 = new PView();
PViewDataList *data2 = getDataList(v2);
int numSteps = v1->getData()->getNumTimeSteps();
double *val = new double[9 * numSteps];
OctreePost o(v1);
if(o.searchScalar(x, y, z, val)){
data2->SP.push_back(x);
data2->SP.push_back(y);
data2->SP.push_back(z);
for(int i = 0; i < numSteps; i++)
data2->SP.push_back(val[i]);
data2->NbSP++;
}
if(o.searchVector(x, y, z, val)){
data2->VP.push_back(x);
data2->VP.push_back(y);
data2->VP.push_back(z);
for(int i = 0; i < numSteps; i++){
for(int j = 0; j < 3; j++)
data2->VP.push_back(val[3 * i + j]);
}
data2->NbVP++;
}
if(o.searchTensor(x, y, z, val)){
data2->TP.push_back(x);
data2->TP.push_back(y);
data2->TP.push_back(z);
for(int i = 0; i < numSteps; i++){
for(int j = 0; j < 9; j++)
data2->TP.push_back(val[9 * i + j]);
}
data2->NbTP++;
}
delete [] val;
for(int i = 0; i < numSteps; i++){
double time = v1->getData()->getTime(i);
data2->Time.push_back(time);
}
data2->setName(v1->getData()->getName() + "_Probe");
data2->setFileName(v1->getData()->getName() + "_Probe.pos");
data2->finalize();
return v2;
}
PView *GMSH_SkinPlugin::execute(PView *v)
{
int visible = (int)SkinOptions_Number[0].def;
int fromMesh = (int)SkinOptions_Number[1].def;
int iView = (int)SkinOptions_Number[2].def;
// compute boundary of current mesh
if(fromMesh){
getBoundaryFromMesh(GModel::current(), visible);
return v;
}
// compute boundary of post-processing data set
PView *v1 = getView(iView, v);
if(!v1) return v;
PViewData *data1 = getPossiblyAdaptiveData(v1);
if(data1->hasMultipleMeshes()){
Msg::Error("Skin plugin cannot be applied to multi-mesh views");
return v;
}
Msg::Info("Extracting boundary from View[%d]", v1->getIndex());
PView *v2 = new PView();
PViewDataList *data2 = getDataList(v2);
std::set<ElmData, ElmDataLessThan> skin;
ElmDataLessThan::tolerance = CTX::instance()->lc * 1.e-12;
int firstNonEmptyStep = data1->getFirstNonEmptyTimeStep();
for(int ent = 0; ent < data1->getNumEntities(firstNonEmptyStep); ent++){
if(visible && data1->skipEntity(firstNonEmptyStep, ent)) continue;
for(int ele = 0; ele < data1->getNumElements(firstNonEmptyStep, ent); ele++){
if(data1->skipElement(firstNonEmptyStep, ent, ele, visible)) continue;
int numComp = data1->getNumComponents(firstNonEmptyStep, ent, ele);
int type = data1->getType(firstNonEmptyStep, ent, ele);
const int (*boundary)[6][4];
int numBoundary = getBoundary(type, &boundary);
if(!numBoundary) continue;
for(int i = 0; i < numBoundary; i++){
ElmData e(numComp);
for(int j = 0; j < 4; j++){
int nod = (*boundary)[i][j];
if(nod < 0) continue;
double x, y, z;
data1->getNode(firstNonEmptyStep, ent, ele, nod, x, y, z);
e.x.push_back(x);
e.y.push_back(y);
e.z.push_back(z);
}
std::set<ElmData, ElmDataLessThan>::iterator it = skin.find(e);
if(it == skin.end()){
for(int step = 0; step < data1->getNumTimeSteps(); step++){
if(data1->hasTimeStep(step)){
for(int j = 0; j < 4; j++){
int nod = (*boundary)[i][j];
if(nod < 0) continue;
double v;
for(int comp = 0; comp < numComp; comp++){
data1->getValue(step, ent, ele, nod, comp, v);
e.v.push_back(v);
}
}
}
}
skin.insert(e);
}
else
skin.erase(it);
}
}
}
for(std::set<ElmData, ElmDataLessThan>::iterator it = skin.begin();
it != skin.end(); it++)
it->addInView(data2);
for(int i = 0; i < data1->getNumTimeSteps(); i++)
if(data1->hasTimeStep(i))
data2->Time.push_back(data1->getTime(i));
data2->setName(data1->getName() + "_Skin");
data2->setFileName(data1->getName() + "_Skin.pos");
data2->finalize();
return v2;
}
PView *GMSH_DivergencePlugin::execute(PView *v)
{
int iView = (int)DivergenceOptions_Number[0].def;
PView *v1 = getView(iView, v);
if(!v1) return v;
PViewData *data1 = getPossiblyAdaptiveData(v1);
if(data1->hasMultipleMeshes()){
Msg::Error("Divergence plugin cannot be run on multi-mesh views");
return v;
}
PView *v2 = new PView();
PViewDataList *data2 = getDataList(v2);
int firstNonEmptyStep = data1->getFirstNonEmptyTimeStep();
for(int ent = 0; ent < data1->getNumEntities(firstNonEmptyStep); ent++){
for(int ele = 0; ele < data1->getNumElements(firstNonEmptyStep, ent); ele++){
if(data1->skipElement(firstNonEmptyStep, ent, ele)) continue;
int numComp = data1->getNumComponents(firstNonEmptyStep, ent, ele);
if(numComp != 3) continue;
int type = data1->getType(firstNonEmptyStep, ent, ele);
int numNodes = data1->getNumNodes(firstNonEmptyStep, ent, ele);
std::vector<double> *out = data2->incrementList(1, type, numNodes);
if(!out) continue;
double x[8], y[8], z[8], val[8 * 3];
for(int nod = 0; nod < numNodes; nod++)
data1->getNode(firstNonEmptyStep, ent, ele, nod, x[nod], y[nod], z[nod]);
int dim = data1->getDimension(firstNonEmptyStep, ent, ele);
elementFactory factory;
element *element = factory.create(numNodes, dim, x, y, z);
if(!element) continue;
for(int nod = 0; nod < numNodes; nod++) out->push_back(x[nod]);
for(int nod = 0; nod < numNodes; nod++) out->push_back(y[nod]);
for(int nod = 0; nod < numNodes; nod++) out->push_back(z[nod]);
for(int step = 0; step < data1->getNumTimeSteps(); step++){
if(!data1->hasTimeStep(step)) continue;
for(int nod = 0; nod < numNodes; nod++)
for(int comp = 0; comp < numComp; comp++)
data1->getValue(step, ent, ele, nod, comp, val[numComp * nod + comp]);
for(int nod = 0; nod < numNodes; nod++){
double u, v, w;
element->getNode(nod, u, v, w);
double f = element->interpolateDiv(val, u, v, w, 3);
out->push_back(f);
}
}
delete element;
}
}
for(int i = 0; i < data1->getNumTimeSteps(); i++){
if(!data1->hasTimeStep(i)) continue;
double time = data1->getTime(i);
data2->Time.push_back(time);
}
data2->setName(data1->getName() + "_Divergence");
data2->setFileName(data1->getName() + "_Divergence.pos");
data2->finalize();
return v2;
}
PView *GMSH_EigenvectorsPlugin::execute(PView *v)
{
int scale = (int)EigenvectorsOptions_Number[0].def;
int iView = (int)EigenvectorsOptions_Number[1].def;
PView *v1 = getView(iView, v);
if(!v1) return v;
PViewData *data1 = getPossiblyAdaptiveData(v1);
if(data1->hasMultipleMeshes()){
Msg::Error("Eigenvectors plugin cannot be run on multi-mesh views");
return v;
}
PView *min = new PView();
PView *mid = new PView();
PView *max = new PView();
PViewDataList *dmin = getDataList(min);
PViewDataList *dmid = getDataList(mid);
PViewDataList *dmax = getDataList(max);
int nbcomplex = 0;
fullMatrix<double> mat(3, 3), vl(3, 3), vr(3, 3);
fullVector<double> dr(3), di(3);
for(int ent = 0; ent < data1->getNumEntities(0); ent++){
for(int ele = 0; ele < data1->getNumElements(0, ent); ele++){
if(data1->skipElement(0, ent, ele)) continue;
int numComp = data1->getNumComponents(0, ent, ele);
if(numComp != 9) continue;
int type = data1->getType(0, ent, ele);
int numNodes = data1->getNumNodes(0, ent, ele);
std::vector<double> *outmin = dmin->incrementList(3, type, numNodes);
std::vector<double> *outmid = dmid->incrementList(3, type, numNodes);
std::vector<double> *outmax = dmax->incrementList(3, type, numNodes);
if(!outmin || !outmid || !outmax) continue;
double xyz[3][8];
for(int nod = 0; nod < numNodes; nod++)
data1->getNode(0, ent, ele, nod, xyz[0][nod], xyz[1][nod], xyz[2][nod]);
for(int i = 0; i < 3; i++){
for(int nod = 0; nod < numNodes; nod++){
outmin->push_back(xyz[i][nod]);
outmid->push_back(xyz[i][nod]);
outmax->push_back(xyz[i][nod]);
}
}
for(int step = 0; step < data1->getNumTimeSteps(); step++){
for(int nod = 0; nod < numNodes; nod++){
for(int i = 0; i < 3; i++)
for(int j = 0; j < 3; j++)
data1->getValue(step, ent, ele, nod, 3 * i + j, mat(i, j));
if(mat.eig(dr, di, vl, vr, true)){
if(!scale) dr(0) = dr(1) = dr(2) = 1.;
for(int i = 0; i < 3; i++){
double res;
res = dr(0) * vr(i, 0); outmin->push_back(res);
res = dr(1) * vr(i, 1); outmid->push_back(res);
res = dr(2) * vr(i, 2); outmax->push_back(res);
}
if(di(0) || di(1) || di(2)) nbcomplex++;
}
else{
Msg::Error("Could not compute eigenvalues/vectors");
}
}
}
}
}
if(nbcomplex)
Msg::Error("%d tensors have complex eigenvalues", nbcomplex);
for(int i = 0; i < data1->getNumTimeSteps(); i++){
double time = data1->getTime(i);
dmin->Time.push_back(time);
dmid->Time.push_back(time);
dmax->Time.push_back(time);
}
dmin->setName(data1->getName() + "_MinEigenvectors");
dmin->setFileName(data1->getName() + "_MinEigenvectors.pos");
dmin->finalize();
dmid->setName(data1->getName() + "_MidEigenvectors");
dmid->setFileName(data1->getName() + "_MidEigenvectors.pos");
dmid->finalize();
dmax->setName(data1->getName() + "_MaxEigenvectors");
dmax->setFileName(data1->getName() + "_MaxEigenvectors.pos");
dmax->finalize();
return 0;
}
PView *GMSH_LevelsetPlugin::execute(PView *v)
{
// for adapted views we can only run the plugin on one step at a time
if(v->getData()->getAdaptiveData()){
PViewOptions *opt = v->getOptions();
v->getData()->getAdaptiveData()->changeResolution
(opt->timeStep, _recurLevel, _targetError, this);
v->setChanged(true);
}
PViewData *vdata = getPossiblyAdaptiveData(v), *wdata;
if(_valueView < 0) {
wdata = vdata;
}
else if(_valueView > (int)PView::list.size() - 1){
Msg::Error("View[%d] does not exist: reverting to View[%d]",
_valueView, v->getIndex());
wdata = vdata;
}
else{
wdata = getPossiblyAdaptiveData(PView::list[_valueView]);
}
// sanity checks
if(vdata->getNumEntities() != wdata->getNumEntities() ||
vdata->getNumElements() != wdata->getNumElements()){
Msg::Error("Incompatible views");
return v;
}
if(_valueTimeStep >= wdata->getNumTimeSteps()) {
Msg::Error("Wrong time step %d in view", _valueTimeStep);
return v;
}
// Force creation of one view per time step if we have multi meshes
if(vdata->hasMultipleMeshes()) _valueIndependent = 0;
double x[8], y[8], z[8], levels[8];
double scalarValues[8] = {0., 0., 0., 0., 0., 0., 0., 0.};
if(_valueIndependent) {
// create a single output view containing the (possibly
// multi-step) levelset
int firstNonEmptyStep = vdata->getFirstNonEmptyTimeStep();
PViewDataList *out = getDataList(new PView());
for(int ent = 0; ent < vdata->getNumEntities(firstNonEmptyStep); ent++){
for(int ele = 0; ele < vdata->getNumElements(firstNonEmptyStep, ent); ele++){
if(vdata->skipElement(firstNonEmptyStep, ent, ele)) continue;
for(int nod = 0; nod < vdata->getNumNodes(firstNonEmptyStep, ent, ele); nod++){
vdata->getNode(firstNonEmptyStep, ent, ele, nod, x[nod], y[nod], z[nod]);
levels[nod] = levelset(x[nod], y[nod], z[nod], 0.);
}
_cutAndAddElements(vdata, wdata, ent, ele, -1, _valueTimeStep, x, y, z,
levels, scalarValues, out);
}
}
out->setName(vdata->getName() + "_Levelset");
out->setFileName(vdata->getFileName() + "_Levelset.pos");
out->finalize();
}
else{
// create one view per timestep
for(int step = 0; step < vdata->getNumTimeSteps(); step++){
if(!vdata->hasTimeStep(step)) continue;
PViewDataList *out = getDataList(new PView());
for(int ent = 0; ent < vdata->getNumEntities(step); ent++){
for(int ele = 0; ele < vdata->getNumElements(step, ent); ele++){
if(vdata->skipElement(step, ent, ele)) continue;
for(int nod = 0; nod < vdata->getNumNodes(step, ent, ele); nod++){
vdata->getNode(step, ent, ele, nod, x[nod], y[nod], z[nod]);
vdata->getScalarValue(step, ent, ele, nod, scalarValues[nod]);
levels[nod] = levelset(x[nod], y[nod], z[nod], scalarValues[nod]);
}
int wstep = (_valueTimeStep < 0) ? step : _valueTimeStep;
_cutAndAddElements(vdata, wdata, ent, ele, step, wstep, x, y, z,
levels, scalarValues, out);
}
}
char tmp[246];
sprintf(tmp, "_Levelset_%d", step);
out->setName(vdata->getName() + tmp);
out->setFileName(vdata->getFileName() + tmp + ".pos");
out->finalize();
}
}
return 0;
}
