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_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_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_ModifyComponentPlugin::execute(PView *view)
{
int component = (int)ModifyComponentOptions_Number[0].def;
int timeStep = (int)ModifyComponentOptions_Number[1].def;
int iView = (int)ModifyComponentOptions_Number[2].def;
int otherTimeStep = (int)ModifyComponentOptions_Number[3].def;
int otherView = (int)ModifyComponentOptions_Number[4].def;
int forceInterpolation = (int)ModifyComponentOptions_Number[5].def;
PView *v1 = getView(iView, view);
if(!v1) return view;
PViewData *data1 = v1->getData();
if(timeStep > data1->getNumTimeSteps() - 1){
Msg::Error("Invalid time step (%d) in View[%d]: using step 0 instead",
timeStep, v1->getIndex());
timeStep = 0;
}
PView *v2 = v1;
if(otherView >= 0){
if(otherView < (int)PView::list.size())
v2 = PView::list[otherView];
else
Msg::Error("View[%d] does not exist: using self", otherView);
}
PViewData *data2 = getPossiblyAdaptiveData(v2);
if(otherTimeStep < 0 && data2->getNumTimeSteps() != data1->getNumTimeSteps()){
Msg::Error("Number of time steps don't match: using step 0");
otherTimeStep = 0;
}
else if(otherTimeStep > data2->getNumTimeSteps() - 1){
Msg::Error("Invalid time step (%d) in View[%d]: using step 0 instead",
otherTimeStep, v2->getIndex());
otherTimeStep = 0;
}
const char *names[] =
{"x", "y", "z", "Time", "TimeStep",
"v", "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", "v8",
"w", "w0", "w1", "w2", "w3", "w4", "w5", "w6", "w7", "w8"};
unsigned int numVariables = sizeof(names) / sizeof(names[0]);
std::vector<std::string> expressions(1), variables(numVariables);
expressions[0] = ModifyComponentOptions_String[0].def;
for(unsigned int i = 0; i < numVariables; i++) variables[i] = names[i];
mathEvaluator f(expressions, variables);
if(expressions.empty()) return view;
std::vector<double> values(numVariables), res(1);
OctreePost *octree = 0;
if(forceInterpolation ||
(data1->getNumEntities() != data2->getNumEntities()) ||
(data1->getNumElements() != data2->getNumElements())){
Msg::Info("Other view based on different grid: interpolating...");
octree = new OctreePost(v2);
}
for(int step = 0; step < data1->getNumTimeSteps(); step++){
if(timeStep >= 0 && timeStep != step) continue;
double time = data1->getTime(step);
int step2 = (otherTimeStep < 0) ? step : otherTimeStep;
// tag all the nodes with "0" (the default tag)
for(int ent = 0; ent < data1->getNumEntities(step); ent++){
for(int ele = 0; ele < data1->getNumElements(step, ent); ele++){
if(data1->skipElement(step, ent, ele)) continue;
for(int nod = 0; nod < data1->getNumNodes(step, ent, ele); nod++)
data1->tagNode(step, ent, ele, nod, 0);
}
}
for(int ent = 0; ent < data1->getNumEntities(step); ent++){
for(int ele = 0; ele < data1->getNumElements(step, ent); ele++){
if(data1->skipElement(step, ent, ele)) continue;
int numComp = data1->getNumComponents(step, ent, ele);
int numComp2 = octree ? 9 : data2->getNumComponents(step2, ent, ele);
int numNodes = data1->getNumNodes(step, ent, ele);
std::vector<int> tag(numNodes);
std::vector<double> x(numNodes), y(numNodes), z(numNodes);
for(int nod = 0; nod < numNodes; nod++)
tag[nod] = data1->getNode(step, ent, ele, nod, x[nod], y[nod], z[nod]);
for(int nod = 0; nod < numNodes; nod++){
if(tag[nod]) continue; // node has already been modified
std::vector<double> v(std::max(9, numComp), 0.);
for(int comp = 0; comp < numComp; comp++)
data1->getValue(step, ent, ele, nod, comp, v[comp]);
std::vector<double> w(std::max(9, numComp2), 0.);
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 < numComp2; comp++)
data2->getValue(step2, ent, ele, nod, comp, w[comp]);
for(int comp = 0; comp < numComp; comp++){
if(component >= 0 && component != comp) continue;
values[0] = x[nod]; values[1] = y[nod]; values[2] = z[nod];
values[3] = time; values[4] = step;
values[5] = v[comp];
for(int i = 0; i < 9; i++) values[6 + i] = v[i];
values[15] = w[comp];
for(int i = 0; i < 9; i++) values[16 + i] = w[i];
if(f.eval(values, res))
data1->setValue(step, ent, ele, nod, comp, res[0]);
data1->tagNode(step, ent, ele, nod, 1);
}
}
}
}
}
if(octree) delete octree;
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_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_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_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_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_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_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;
}
