81
81
vector<geo_element> _subgeo[4];
82
82
vector<point> _vertex;
83
vector<geo_mask> _domains;
83
vector<domain_indirect> _domains;
86
86
geo_rep (string file_name) { /* code a developper */ }
87
geo_rep (const struct domain_rep& dom); // defini + loin
87
geo_rep (const struct geo_domain_rep& dom); // defini + loin
89
89
// interface "geo" concret :
90
90
virtual string name () const { return _name; }
91
91
const point& vertex (size_t iv) const { return _vertex[iv]; }
92
92
const geo_element& subgeo (size_t d,size_t ie) const { return _subgeo[d][ie]; }
93
geo_mask operator[] (string dom_name) const;
93
domain_indirect operator[] (string dom_name) const;
96
96
geo_rep::operator[] (string dom_name) const
98
98
for (size_t i = 0; i < _domains.size(); i++)
99
99
if (_domains[i].data()._name == dom_name) return _domains[i];
100
return geo_mask(); // erreur
100
return domain_indirect(); // erreur
111
111
geo () : smart_pointer<geo_abs_rep>(new geo_rep) {}
112
112
geo (string filename) : smart_pointer<geo_abs_rep>(new geo_rep(filename)) {}
113
geo (const geo_mask& mask); // defini + loin
113
geo (const domain_indirect& indirect); // defini + loin
114
114
// interface "geo" concret :
115
115
const point& vertex (size_t iv) const { return data().vertex(iv); }
116
116
const geo_element& subgeo (size_t d,size_t ie) const { return data().subgeo(d,ie);}
121
la classe "geo_mask" ne contient que les numeros des elements :
121
la classe "domain_indirect" ne contient que les numeros des elements :
122
122
pour acceder aux elements et aux coords des sommets,
123
123
il faut disposer de la classe "geo_abs_rep" associee, appellee alors
124
"background geo" (concretement : geo_rep ou domain_rep) :
124
"background geo" (concretement : geo_rep ou geo_domain_rep) :
126
struct domain_rep : geo_abs_rep {
126
struct geo_domain_rep : geo_abs_rep {
129
geo _bg; // background geo
128
domain_indirect _indirect;
129
geo _bg; // background geo
131
domain_rep (const geo_mask& mask, const geo& bg) :
132
_mask(mask), _bg(bg) {}
131
geo_domain_rep (const domain_indirect& indirect, const geo& bg) :
132
_indirect(indirect), _bg(bg) {}
133
133
// interface "geo" concret :
134
virtual string name () const { return _mask.data()._name; }
134
virtual string name () const { return _indirect.data()._name; }
135
135
const point& vertex (size_t iv) const { return _bg.vertex(iv); }
136
136
const geo_element& subgeo (size_t d,size_t ie) const {
137
if (d == _mask.data()._dim) return _bg.subgeo(d,_mask.data()._num[ie]);
137
if (d == _indirect.data()._dim) return _bg.subgeo(d,_indirect.data()._num[ie]);
138
138
else return _bg.subgeo(d,ie); }
139
geo_mask operator[] (string dom_name) const; // impl + loin
139
domain_indirect operator[] (string dom_name) const; // impl + loin
141
141
// constructeur d'un domaine avec l'interface "geo" :
142
geo::geo (const geo_mask& mask)
143
: smart_pointer<geo_abs_rep>(new domain_rep(mask, *this)) {}
142
geo::geo (const domain_indirect& indirect)
143
: smart_pointer<geo_abs_rep>(new geo_domain_rep(indirect, *this)) {}
147
147
les domaines conduisent a deux types de "geo" :
148
148
1) le plus simple est
149
149
geo gamma = omega["gamma"];
150
qui est represente' par un domain_rep : la numerotation
150
qui est represente' par un geo_domain_rep : la numerotation
151
151
des sommets suit celle du maillage "background".
152
152
Ce type de "geo" peut construire des espace pour assembler
153
153
des matrices de masse pour la condition de robin, par ex.
154
Ce cas est traite' par le constructeur de domain_rep precedent :
154
Ce cas est traite' par le constructeur de geo_domain_rep precedent :
156
domain_rep (const geo_mask& mask, const geo& bg);
156
geo_domain_rep (const domain_indirect& indirect, const geo& bg);
158
158
2) lorsqu'on veut une matrice de masse avec une numerotation
159
159
compactee, ou` seuls les sommets intervenant dans le domaine
163
163
Dans ce cas, le domain_tst construit precedement
164
164
est convertis en geo_tst :
166
geo_rep (const domain_rep& dom);
166
geo_rep (const geo_domain_rep& dom);
168
168
c'est l'implementation qui suit :
170
geo_rep::geo_rep (const domain_rep& dom)
171
: _dim (dom._mask.data()._dim),
172
_name (dom._mask.data()._name + "@" + dom._bg.data().name()),
170
geo_rep::geo_rep (const geo_domain_rep& dom)
171
: _dim (dom._indirect.data()._dim),
172
_name (dom._indirect.data()._name + "@" + dom._bg.data().name()),
178
178
// 1) _vertex : copie paresseuse de la table des sommets
179
179
// 2) _subgeo : renum compactee de ts les elements, y compris sommets
180
// 3) _domains : intersection des domaines de _bg avec le dom._mask :
180
// 3) _domains : intersection des domaines de _bg avec le dom._indirect :
181
181
// on ne garde que les
184
184
Enfin, un domaine d'un maillage peut avoir des sous-domaines,
185
185
par exemple les bords du bord. Il s'agit de faire l'intersection
186
du domaine designe' par _mask avec celui donne' par dom_name
186
du domaine designe' par _indirect avec celui donne' par dom_name
187
187
et qui designe un domain dans _bg, le maillage de fond.
188
188
Le resultat est un nouveau masque de _bg.
191
domain_rep::operator[] (string dom_name) const {
191
geo_domain_rep::operator[] (string dom_name) const {
192
192
// ici, extraction de sous-sous-domaines.
193
return domain_indirect();
added
removed
nfem/ptst/geo_specs_tst.cc
