Skip to content
Snippets Groups Projects
Commit 7742ab29 authored by Amaury Johnen's avatar Amaury Johnen
Browse files

remove old code for 2D recombinations

parent 382d7d40
No related branches found
No related tags found
No related merge requests found
Expand all Show whitespace changes
Inline Side-by-side
Mesh/meshRecombine2D.cpp deleted 100644 → 0
+ 0
− 490
View file @ 382d7d40
// Gmsh - Copyright (C) 1997-2016 C. Geuzaine, J.-F. Remacle
//
// See the LICENSE.txt file for license information. Please report all
// bugs and problems to the public mailing list <gmsh@onelab.info>.
//
// Contributor(s):
// Amaury Johnen, adapted from meshGFaceOptimize
//
#include "meshRecombine2D.h"
#include "GFace.h"
#include <cmath>
#include <FL/Fl.H>
#include "drawContext.h"
#include "FlGui.h"
#include "Context.h"
#include "OpenFile.h"//pas propre
static int HORIZ = 20;
static int NEW_NODE = 0;
static int DEL_NODE = 0;
Recombine2D::Recombine2D(GFace *gf, int horizon)
: _horizon(horizon), _gf(gf), _benef(.0), _applied(true)
{
if (_horizon < 1) _horizon = 1;
//return;
//laplaceSmoothing(gf,100);
//gf->model()->writeMSH("befSquare.msh");
Msg::Info("Branching with horizon %d", _horizon = HORIZ);
_haveParam = gf->geomType() != GEntity::DiscreteSurface || gf->getCompound();
if(!_haveParam) {
Msg::Warning("Surfaces must have prametrization in order to recombine triangles");
//return;
_haveParam=true;
}
e2t_cont adj;
_buildEdgeToElement(gf->triangles, adj);
std::map<MElement*, int> boundaryTriangle;
std::pair<Set_Recomb::iterator, bool> ret;
for (e2t_cont::iterator it = adj.begin(); it != adj.end(); ++it) {
if (it->second.second) {
RecombTriangle *rt = new RecombTriangle(it->first, it->second.first, it->second.second);
ret = _pairs.insert(rt);
while (ret.second == false) {
rt->touch();
ret = _pairs.insert(rt);
}
_possibleRecomb[it->second.first].insert(rt);
_possibleRecomb[it->second.second].insert(rt);
}
else {
if (boundaryTriangle.find(it->second.first) == boundaryTriangle.end())
boundaryTriangle[it->second.first] = 1;
else
boundaryTriangle[it->second.first] = 2;
}
}
/*std::map<MElement*, int>::iterator itt;
for (itt = boundaryTriangle.begin(); itt != boundaryTriangle.end(); ++itt) {
RecombTriangle *rt;
if (itt->second == 1)
rt = new RecombTriangle(itt->first, -100);
else
rt = new RecombTriangle(itt->first, -200);
ret = _pairs.insert(rt);
while (!ret.second) {
rt->touch();
ret = _pairs.insert(rt);
}
_possibleRecomb[itt->first].insert(rt);
}*/
Msg::Info("poss %d", _possibleRecomb.size());
Msg::Info("pairs %d", _pairs.size());
Msg::Info("tri %d", gf->triangles.size());
_recombine();
Msg::Info("new %d ", NEW_NODE);
Msg::Info("del %d ", DEL_NODE);
_applied = false;
}
Recombine2D::~Recombine2D()
{
if (!_applied)
for (int i = 0; i < _quads.size(); i++)
delete _quads[i];
}
template <class E>
void Recombine2D::_buildEdgeToElement(std::vector<E*> &elements, e2t_cont &adj)
{
for (unsigned int i = 0; i < elements.size(); i++) {
E *el = elements[i];
for (int j = 0; j < el->getNumEdges(); j++) {
MEdge e = el->getEdge(j);
e2t_cont::iterator it = adj.find(e);
if (it == adj.end()) {
std::pair<MElement*, MElement*> one = std::make_pair(el, (MElement*)0);
adj[e] = one;
}
else
it->second.second = el;
}
}
}
void Recombine2D::_recombine()
{
//SetBoundingBox();
/*Map_Tri_Recomb::iterator itt;
for (itt = _possibleRecomb.begin(); itt != _possibleRecomb.end(); ++itt) {
if
}*/
int i = 0;
while ((!_pairs.empty() || !_lastRecomb.empty()) && i < 1000) {
Msg::Info("%d",i);
Set_Recomb::iterator it = _bestNextRecombination();
/*if (it != _pairs.begin()) {
std::set<MElement*> isolatedCP(_isolated);
_isolated.clear();
Set_Recomb::iterator itnp = _pairs.begin();
int n = 0;
while (itnp != it) {
n++;
for (int k = 0; k < (*itnp)->numTriangles(); k++){
Msg::Info("recomb[%d] %d : %d", n, k+1, (*itnp)->triangle(k)->getNum());
_isolated.insert((*itnp)->triangle(k));
}
itnp++;
}
Msg::Info("%d triangles et %d quads", _gf->triangles.size(), _gf->quadrangles.size());
_applied = false;
apply();
_applied = false;
CTX::instance()->mesh.changed = (ENT_ALL);
drawContext::global()->draw();
FlGui::instance()->check();
drawContext::global()->draw();
if (!Msg::GetAnswer("Continue ?", 1, "no", "yes"))
Msg::Info("I continue anyway :p");
_isolated = isolatedCP;
}*/
_benef += (*it)->getBenef();
if ((*it)->isQuad())
_quads.push_back((*it)->createQuad());
else
for (int i = 0; i < (*it)->numTriangles(); i++)
_isolated.insert((*it)->triangle(i));
/*Set_Recomb::iterator itmp = _pairs.begin();
while (itmp != it) {
_rmRT(*itmp);
itmp = _pairs.begin();
}*/
_removeImpossible(it);
i++;
}
Msg::Info("Done %d (%d)", i, _pairs.size());
}
Set_Recomb::iterator Recombine2D::_bestNextRecombination()
{
if (!_lastRecomb.empty())
return _lastRecomb.begin();
Map_Tri_Node touched;
std::vector<Recomb2D_Node*> nodes(_horizon);
Set_Recomb::iterator it = _pairs.begin(), itmax = _pairs.begin();
int h = 0, nSkip = 0;
double maxBenef = _horizon * -200.;
bool haveOptimal = false;
int maxH = 0;
int numb = 0;
while (!haveOptimal) {
numb++;
while (h < _horizon && it != _pairs.end()) {
bool possible = true;
Map_Tri_Node::iterator itm;
for (int i = 0; i < (*it)->numTriangles(); i++) {
itm = touched.find((*it)->triangle(i));
if (itm != touched.end()) {
itm->second->blocking(itm);
possible = false;
}
}
if (possible) {
if (h == 0) nodes[h] = new Recomb2D_Node(it, nSkip, _horizon, touched);
else nodes[h] = new Recomb2D_Node(it, nSkip, nodes[h-1]);
NEW_NODE++;
h++;
nSkip = 0;
if (h >= _horizon || nodes[h - 1]->getBound() < maxBenef)
break;
}
it++;
}
if (--h < 0) haveOptimal = true;
if (nodes[h]->getTotBenef() > maxBenef && h >= maxH) {
maxBenef = nodes[h]->getTotBenef();
itmax = nodes[0]->getItRecomb();
maxH = h;
}
/*nSkip = 0;
while (h >= 0 && nSkip < 2) {
nodes[h]->erase();
nSkip += nodes[h--]->getnSkip();
if (h == _horizon - 2 && nodes[h]->getnSkip() >= 3) nodes[h--]->erase(); //probleme si h=-1
while (h >= 0 &&
nodes[h]->beSkipped() &&
nodes[h]->getnSkip() >= 2 * (_horizon - h))
nodes[h--]->erase();*/
while (h >= 0 &&
(nodes[h]->isBetter() ||
nodes[h]->getnSkip() >= 2 * (_horizon - h) - 1)){
DEL_NODE++;
delete nodes[h--];
}
if (h < 0) haveOptimal = true;
else {
it = ++nodes[h]->getItRecomb();
nSkip = nodes[h]->getnSkip() + 1;
delete nodes[h];
DEL_NODE++;
}
}
Msg::Info("num test %d", numb);
return itmax;
}
void Recombine2D::_removeImpossible(Set_Recomb::iterator it)
{
std::vector<MElement *> t;
(*it)->triangles(t);
Map_Tri_Recomb::iterator itm;
std::set<RecombTriangle*>::iterator itrt;
for (int i = 0; i < t.size(); i++) // loop over touched triangles
if ((itm = _possibleRecomb.find(t[i])) != _possibleRecomb.end()) {
itrt = itm->second.begin();
while (itrt != itm->second.end()) { // loop over incompatible RecombTriangle
if (*itrt != *it)
_rmRT(*itrt, t[i]);
itrt++;
}
_possibleRecomb.erase(itm);
}
RecombTriangle *rt = *it;
if (!_lastRecomb.erase(*it))
_pairs.erase(it);
delete rt;
}
void Recombine2D::_rmRT(RecombTriangle *rt, MElement *el)
{
MElement *tri;
Map_Tri_Recomb::iterator itmtri;
for (int i = 0; i < rt->numTriangles(); i++)
if ((tri = rt->triangle(i)) != el &&
(itmtri = _possibleRecomb.find(tri)) != _possibleRecomb.end()) {
itmtri->second.erase(rt);
switch (itmtri->second.size()) {
case 1 :
_pairs.erase(*itmtri->second.begin());
_lastRecomb.insert(*itmtri->second.begin());
break;
case 0 :
_isolated.insert(tri);
_possibleRecomb.erase(itmtri);
default :;
}
}
_pairs.erase(rt);
_lastRecomb.erase(rt);
delete rt;
}
int Recombine2D::apply()
{
if (!_haveParam || _applied) return 0;
std::vector<MTriangle*> triangles2;
for (int i = 0; i < _gf->triangles.size(); i++) {
if (_isolated.find(_gf->triangles[i]) == _isolated.end())
;//delete _gf->triangles[i];
else
triangles2.push_back(_gf->triangles[i]);
}
_gf->triangles = triangles2;
_gf->quadrangles = _quads;
_applied = true;
//_gf->model()->writeMSH("recSquare.msh");
laplaceSmoothing(_gf,10);
//_gf->model()->writeMSH("aftSquare.msh");
return 1;
}
RecombTriangle::RecombTriangle(const MEdge &me, MElement *t1, MElement *t2)
: _formingQuad(true)
{
_t.push_back(t1);
_t.push_back(t2);
_n1 = me.getVertex(0);
_n2 = me.getVertex(1);
_sign = (std::rand() % 2) * 2 - 1;
if(t1->getVertex(0) != _n1 && t1->getVertex(0) != _n2) _n3 = t1->getVertex(0);
else if(t1->getVertex(1) != _n1 && t1->getVertex(1) != _n2) _n3 = t1->getVertex(1);
else if(t1->getVertex(2) != _n1 && t1->getVertex(2) != _n2) _n3 = t1->getVertex(2);
if(t2->getVertex(0) != _n1 && t2->getVertex(0) != _n2) _n4 = t2->getVertex(0);
else if(t2->getVertex(1) != _n1 && t2->getVertex(1) != _n2) _n4 = t2->getVertex(1);
else if(t2->getVertex(2) != _n1 && t2->getVertex(2) != _n2) _n4 = t2->getVertex(2);
double a1 = 180 * angle3Vertices(_n1, _n4, _n2) / M_PI;
double a2 = 180 * angle3Vertices(_n4, _n2, _n3) / M_PI;
double a3 = 180 * angle3Vertices(_n2, _n3, _n1) / M_PI;
double a4 = 180 * angle3Vertices(_n3, _n1, _n4) / M_PI;
_angle = fabs(90. - a1);
_angle = std::max(fabs(90. - a2), _angle);
_angle = std::max(fabs(90. - a3), _angle);
_angle = std::max(fabs(90. - a4), _angle);
_benefit = std::max(1. - _angle/90., .0);
//_benefit = compute_alignment(me,t1,t2);
//cost_alignment = Temporary::compute_alignment(me,_t1,_t2); //addition for class Temporary
//total_cost = Temporary::compute_total_cost(cost_quality,cost_alignment); //addition for class Temporary
//total_cost = 100.0*cost_quality; //addition for class Temporary
}
RecombTriangle::RecombTriangle(MElement *t, double a)
: _benefit(a), _formingQuad(false)
{
_t.push_back(t);
_sign = (std::rand() % 2) * 2 - 1;
}
double RecombTriangle::touch()
{
if (_benefit == .0)
return _benefit = _sign * std::pow(2., -1022);
else // add smaller possible value
return _benefit += _sign * std::pow(2., std::floor(std::log(std::fabs(_benefit))/std::log(2.))-52);
}
MQuadrangle *RecombTriangle::createQuad() const
{
switch (_t.size()) {
case 1 :
{
Msg::Error("Can't make a quad from only one triangle");
return new MQuadrangle(_t[0]->getVertex(0),
_t[0]->getVertex(1),
_t[0]->getVertex(2),
_t[0]->getVertex(0));
}
case 2 :
{
int orientation = 0;
for (int i = 0; i < 3; i++) {
if (_t[0]->getVertex(i) == _n1) {
if (_t[0]->getVertex((i + 1) % 3) == _n2)
orientation = 1;
else
orientation = -1;
break;
}
}
if (orientation < 0)
return new MQuadrangle(_n1, _n3, _n2, _n4);
else
return new MQuadrangle(_n1, _n4, _n2, _n3);
}
default :
{
Msg::Warning("Quad creation not yet implemented for more than two triangles");
return new MQuadrangle(_n1, _n2, _n3, _n4);
}
}
}
double RecombTriangle::compute_alignment(const MEdge &edge, MElement *e1, MElement* e2)
{
return 1 - Temporary::compute_alignment(edge, e1, e2);
}
bool RecombTriangle::operator<(const RecombTriangle &other) const
{
return _benefit < other._benefit;
}
bool lessRecombTri::operator()(RecombTriangle *rt1, RecombTriangle *rt2) const
{
return *rt2 < *rt1;
}
//{Recomb2D_Node::Recomb2D_Node(Set_Recomb::iterator it,
// Map_Tri_Node &touched,
// int nskp, double ben) : _nskip(nskp), _recomb(it)
//{
// _benef = (*it)->getBenef();
// _totBenef = ben + _benef;
// for (int i = 0; i < (*it)->numTriangles(); i++)
// _vit.push_back(touched.insert( touched.begin(), std::make_pair((*it)->triangle(i), this) ));
// _touch = &touched;
//}
//}
Recomb2D_Node::Recomb2D_Node(Set_Recomb::iterator it, int nskp, int horiz,
Map_Tri_Node &touched)
: _nskip(nskp), _recomb(it)
{
_benef = (*it)->getBenef();
_totBenef = _benef;
_depth = horiz - 1;
for (int i = 0; i < (*it)->numTriangles(); i++)
_vit.push_back(touched.insert( touched.begin(), std::make_pair((*it)->triangle(i), this) ));
_touch = &touched;
}
Recomb2D_Node::Recomb2D_Node(Set_Recomb::iterator it, int nskp, Recomb2D_Node *n)
: _nskip(nskp), _recomb(it)
{
_benef = (*it)->getBenef();
_totBenef = n->_benef + _benef;
_depth = n->_depth - 1;
_touch = n->_touch;
for (int i = 0; i < (*it)->numTriangles(); i++)
_vit.push_back(_touch->insert( _touch->begin(), std::make_pair((*it)->triangle(i), this) ));
}
Recomb2D_Node::~Recomb2D_Node()
{
for (int i = 0; i < _vit.size(); i++)
_touch->erase(_vit[i]);
}
void Recomb2D_Node::erase()
{
for (int i = 0; i < _vit.size(); i++)
_touch->erase(_vit[i]);
}
void Recomb2D_Node::blocking(const Map_Tri_Node::iterator &it)
{
for (int i = 0; i < _vit.size(); i++) {
if (it == _vit[i]) {
_blocking.insert(i);
}
}
}
//
Mesh/meshRecombine2D.h deleted 100644 → 0
+ 0
− 420
View file @ 382d7d40
// Gmsh - Copyright (C) 1997-2012 C. Geuzaine, J.-F. Remacle
//
// See the LICENSE.txt file for license information. Please report all
// bugs and problems to <gmsh@geuz.org>.
//
// Contributor(s):
// Amaury Johnen
//
#ifndef _MESH_RECOMBINE_2D_H_
#define _MESH_RECOMBINE_2D_H_
#include <map>
#include <set>
#include <vector>
#include "MVertex.h"
#include "MTriangle.h"
#include "MQuadrangle.h"
#include "meshGFaceOptimize.h"
class RecombTriangle;
class Recomb2D_Node;
class TrianglesUnion;
class Rec2d_vertex;
class list_actions;
class Recombine2D;
//class list_actions;
//class list_actions::iterator;
struct lessRecombTri {
bool operator()(RecombTriangle *rt1, RecombTriangle *rt2) const;
};
struct lessTriUnion {
bool operator()(TrianglesUnion *, TrianglesUnion *) const;
};
struct lessTriUnionInv {
bool operator()(TrianglesUnion *, TrianglesUnion *) const;
};
typedef std::set<RecombTriangle*,lessRecombTri> Set_Recomb;
typedef std::map<MElement*,std::set<RecombTriangle*> > Map_Tri_Recomb;
typedef std::map<MElement*,Recomb2D_Node*> Map_Tri_Node;
typedef std::map<MTriangle*, std::set<TrianglesUnion*> > mapTriUnion;
typedef std::set<TrianglesUnion*, lessTriUnionInv> setTriUnion;
typedef std::vector<setTriUnion> vectSetTriUnion;
class list_actions {
private :
vectSetTriUnion _cont;
public :
list_actions(int h) {_cont.reserve(h);}
class iterator {
private :
int pos;
list_actions *la;
setTriUnion::iterator it;
public :
void print() {
Msg::Info("iterator(pos %d, la %d, tu %d)", pos, la, *it);
}
iterator(list_actions *l, int i, setTriUnion::iterator t) {
pos = i;
la = l;
it = t;
}
iterator() {
pos = -1;
}
bool operator==(iterator a) const {
if (pos != a.pos)
return false;
if (pos < 0)
return true;
return it == a.it;
}
bool operator!=(iterator a) const {
if (pos != a.pos)
return true;
if (pos < 0)
return false;
return it != a.it;
}
iterator& operator=(const iterator &a) {
if (this != &a) {
pos = a.pos;
la = a.la;
it = a.it;
}
return *this;
}
TrianglesUnion* operator*() const {
//Msg::Info("pos %d", pos);
//Msg::Info(" ");
if (pos < 0)
return NULL;
return *it;
}
iterator& operator++() {
int p = pos;
++it;
while (it == la->_end(p) && ++p != la->_size()) {
++pos;
it = la->_begin(pos);
}
return *this;
}
iterator& operator--() {
int p = pos;
while (it == la->_begin(p) && --p > -1) {
--pos;
it = la->_end(pos);
}
if (p > -1)
--it;
return *this;
}
iterator operator++(int n) {
iterator t = *this;
int p = pos;
++it;
while (it == la->_end(p) && ++p != la->_size()) {
++pos;
it = la->_begin(pos);
}
return t;
}
inline int getPos() {return pos;}
};
int add(setTriUnion &s) {
setTriUnion::iterator it = s.begin();
while (it != s.end()) {
if (find(*it) != end())
s.erase(it++);
else
++it;
}
_cont.push_back(s);
return _cont.size() - 1;
}
void remove(int a) {
for (; a < _cont.size(); a++)
_cont.pop_back();
}
iterator find(TrianglesUnion* tu) {
if (_cont.empty())
return end();
for (int i = 0; i < _cont.size(); ++i) {
setTriUnion::iterator it = _cont[i].find(tu);
if (it != _cont[i].end())
return iterator(this, i, it);
}
return end();
}
iterator begin() {
if (_cont.empty())
return iterator(this, -1, _begin());
return iterator(this, 0, _begin());
}
iterator end() {
return iterator(this, _cont.size() - 1, _end());
}
void pop_back() {
_cont.pop_back();
}
void sizes(){
switch (_cont.size()) {
case 3 :
Msg::Info("--Actions : %d + %d + %d", _cont[0].size(), _cont[1].size(), _cont[2].size());
break;
case 2 :
Msg::Info("--Actions : %d + %d", _cont[0].size(), _cont[1].size());
break;
case 1 :
Msg::Info("--Actions : %d", _cont[0].size());
break;
default :
break;
}
//Msg::Info("%d sets", _cont.size());
//for (int i = 0; i < _cont.size(); ++i)
// Msg::Info("[%d] %d", i+1, _cont[i].size());
}
private :
setTriUnion::iterator _end(int pos = -1) {
if (_cont.size() == 0) {
setTriUnion::iterator it;
return it; // Not clean !
}
if (pos < 0)
return _cont.back().end();
return _cont[pos].end();
}
setTriUnion::iterator _begin(int pos = -1) {
if (_cont.size() == 0) {
setTriUnion::iterator it;
return it; // Not clean !
}
if (pos < 0)
return _cont.front().begin();
return _cont[pos].begin();
}
inline int _size() {return _cont.size();}
};
class Recombine2D {
private :
GFace *_gf;
int _horizon;
double _benef;
bool _haveParam, _applied;
Set_Recomb _pairs, _lastRecomb;
Map_Tri_Recomb _possibleRecomb;
std::set<MElement*> _isolated;
std::vector<MQuadrangle*> _quads;
static int ra;
template <class E>
void _buildEdgeToElement(std::vector<E*> &, e2t_cont &);
void _recombine();
Set_Recomb::iterator _bestNextRecombination();
void _removeImpossible(Set_Recomb::iterator);
void _rmRT(RecombTriangle *, MElement *e = NULL);
public :
Recombine2D(GFace*, int horizon);
Recombine2D(GFace*);
~Recombine2D();
int apply();
inline double getBenef() const {return _benef;}
inline int numTriangle() const {return _isolated.size();}
private :
//std::set<TrianglesUnion*, lessTriUnion> _setQuads;
std::list<TrianglesUnion*> _setQuads;
std::list<TrianglesUnion*> _lastQuad;
mapTriUnion _possibleActions;
mapTriUnion _lessActions;
void _removeImpossible(TrianglesUnion*);
void _recombine(bool);
void _lookAhead(std::list<TrianglesUnion*> &, int horiz);
void _lookAhead2(std::list<TrianglesUnion*> &, int horiz);
void _getIncompatibles(const TrianglesUnion*, setTriUnion &);
void _getNeighbors(const TrianglesUnion*, setTriUnion &);
void _addNeighbors(int horiz, std::vector<list_actions::iterator> &,
int current, list_actions*);
void _removeNeighbors(int horiz, int current, list_actions*);
int _checkIsolatedTri(const std::vector<list_actions::iterator> &,
int size, std::set<MTriangle*> &);
double _realisticReturn(const int *num,
const double *val,
const std::map<Rec2d_vertex*, int> &,
const std::vector<list_actions::iterator> &,
int size,
const std::set<MTriangle*> &);
public :
int apply(bool);
};
class RecombTriangle {
private :
std::vector<MElement *> _t;
MVertex *_n1, *_n2, *_n3, *_n4;
double _angle;
double _benefit;
bool _formingQuad;
int _sign;
public :
RecombTriangle(const MEdge &, MElement *, MElement *);
RecombTriangle(MElement *, double);
double touch();
MQuadrangle *createQuad() const;
bool operator<(const RecombTriangle &other) const;
inline void triangles(std::vector<MElement *> &v) const {v = _t;}
inline int numTriangles() const {return (int) _t.size();}
MElement *triangle(int i) const {
if (i >= 0 && i < _t.size())
return _t[i];
return NULL;
}
inline bool isQuad() const {return _formingQuad;}
inline double getBenef() const {return _benefit;}
double compute_alignment(const MEdge&, MElement*, MElement*);
};
class Recomb2D_Node {
private :
double _benef, _totBenef;
int _nskip, _depth;
Set_Recomb::iterator _recomb;
Map_Tri_Node *_touch;
std::vector<Map_Tri_Node::iterator> _vit;
std::set<int> _blocking;
public :
//Node(){}
//Recomb2D_Node(Set_Recomb::iterator, Map_Tri_Node &, int, double ben = .0);
Recomb2D_Node(Set_Recomb::iterator, int nskip, int depth, Map_Tri_Node &);
Recomb2D_Node(Set_Recomb::iterator, int nskip, Recomb2D_Node *);
~Recomb2D_Node();
void erase();
void blocking(const Map_Tri_Node::iterator &);
inline bool isBetter() {return _blocking.size() < 2;}
inline Set_Recomb::iterator getItRecomb() {return _recomb;}
inline double getTotBenef() {return _totBenef;}
inline int getnSkip() {return _nskip;}
inline double getBound() {return _totBenef + _benef * _depth;}
};
class Rec2d_vertex {
private :
// _onWhat={-1:corner,0:edge,1:face,(2:volume)}
int _onWhat, _numEl;
double _angle;
// GEdge : virtual SVector3 firstDer(double par) const = 0;
// GEntity : virtual Range<double> parBounds(int i)
static double **_Vvalues;
static double **_Vbenefs;
public :
Rec2d_vertex(MVertex *, std::list<MTriangle*> &,
std::map<MVertex*, std::set<GEdge*> > &, bool);
inline void changeNumEl(int c) {_numEl += c;}
double getReward();
double getReward(int);
//int onwhat() {return _onWhat;}
//int numel() {return _numEl;}
private :
void _initStaticTable();
double _computeAngle(MVertex *, std::list<MTriangle*> &, std::set<GEdge*> &);
};
class TrianglesUnion {
private :
int _numEmbEdge, _numboundEdge, _numEmbVert, _numBoundVert, _numTri, _computation;
double _embEdgeValue, _boundEdgeValue, _embVertValue, _globValIfExecuted;
Rec2d_vertex **_vertices;
MTriangle **_triangles;
static int _RECOMPUTE; //incremented when a recombination is executed
public:
static int _NumEdge, _NumVert;
static double _ValEdge, _ValVert;
private:
public :
TrianglesUnion(GFace *, std::list<MTriangle*> &, std::list<MEdge> &,
std::list<Rec2d_vertex*> &, std::map<MVertex*,double> &,
std::map<MEdge, std::list<MTriangle*>, Less_Edge>&);
bool operator<(TrianglesUnion &other);
void addTri(std::set<MTriangle*>&) const;
void removeTri(std::set<MTriangle*>&) const;
bool isIn(std::set<MTriangle*>&) const;
void addInfluence(int*, double*, std::map<Rec2d_vertex*, int>&) const;
void removeInfluence(int*, double*, std::map<Rec2d_vertex*, int>&) const;
static double computeReturn(const int*, const double*, const std::map<Rec2d_vertex*, int>&);
inline double getEdgeValue() const {return _embEdgeValue;}
inline double getVertValue() const {return _embVertValue;}
inline int getNumVerts() const {return _numEmbVert;}
inline int getNumEdges() const {return _numEmbEdge;}
inline int getNumVertices() const {return _numBoundVert;}
inline Rec2d_vertex* getVertex(int num) const {return _vertices[num];}
inline int getNumTriangles() const {return _numTri;}
inline MTriangle* getTriangle(int num) const {return _triangles[num];}
void select() {
_ValEdge -= _embEdgeValue;
_NumEdge -= _numEmbEdge;
_ValEdge += _boundEdgeValue;
_NumEdge += _numboundEdge;
_ValVert -= _embVertValue;
_NumVert -= _numEmbVert;
for (int i = 0; i < _numBoundVert; i++) {
_ValVert += _vertices[i]->getReward(-1);
_vertices[i]->changeNumEl(-1);
}
_RECOMPUTE++;
}
MQuadrangle* createQuad() const;
void print() {
Msg::Info("Printing TU (%d,%d,%d,%d)", _numEmbVert, _numBoundVert, _numEmbEdge, _numTri);
for (int i = 0; i < _numTri; i++)
Msg::Info("Triangle %d", _triangles[i]->getNum());
}
static inline void addRec() {_RECOMPUTE++;}
inline double getReturn() {return _globValIfExecuted;}
inline static double getActualReturn() {
return _ValEdge/_NumEdge * _ValVert/_NumVert * _ValVert/_NumVert;
}
static void clear() {_NumEdge = 0; _NumVert = 0;
_ValEdge = .0, _ValVert = .0;}
private:
double _computeEdgeLength(GFace*, MVertex**, double *u, double *v,
int numIntermedPoint= 1);
double _computeAlignment(const MEdge&, std::list<MTriangle*>&,
std::map<MEdge, std::list<MTriangle*>, Less_Edge>&);
void _update();
};
#endif
Mesh/meshRecombine2D_2.cpp deleted 100644 → 0
+ 0
− 1450
View file @ 382d7d40
This diff is collapsed.
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment