Hermes2D  2.0
weakforms_h1.cpp
1 // This file is part of Hermes2D.
2 //
3 // Hermes2D is free software: you can redistribute it and/or modify
4 // it under the terms of the GNU General Public License as published by
5 // the Free Software Foundation, either version 2 of the License, or
6 // (at your option) any later version.
7 //
8 // Hermes2D is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
11 // GNU General Public License for more details.
12 //
13 // You should have received a copy of the GNU General Public License
14 // along with Hermes2D. If not, see <http://www.gnu.org/licenses/>.
15 
16 #include "weakforms_h1.h"
17 #include "api2d.h"
18 namespace Hermes
19 {
20  namespace Hermes2D
21  {
22  namespace WeakFormsH1
23  {
24  template<>
25  DefaultMatrixFormVol<double>::DefaultMatrixFormVol
26  (int i, int j, std::string area, Hermes2DFunction<double>* coeff, SymFlag sym, GeomType gt)
27  : MatrixFormVol<double>(i, j), coeff(coeff), gt(gt)
28  {
29  this->set_area(area);
30  this->setSymFlag(sym);
31 
32  if(coeff == HERMES_ONE)
33  this->coeff = new Hermes2DFunction<double>(1.0);
34  }
35  template<>
36  DefaultMatrixFormVol<std::complex<double> >::DefaultMatrixFormVol
37  (int i, int j, std::string area, Hermes2DFunction<std::complex<double> >* coeff, SymFlag sym, GeomType gt)
38  : MatrixFormVol<std::complex<double> >(i, j), coeff(coeff), gt(gt)
39  {
40  this->set_area(area);
41  this->setSymFlag(sym);
42 
43  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
44  if(coeff == HERMES_ONE)
45  this->coeff = new Hermes2DFunction<std::complex<double> >(std::complex<double>(1.0, 1.0));
46  }
47 
48  template<>
49  DefaultMatrixFormVol<double>::DefaultMatrixFormVol
50  (int i, int j, Hermes::vector<std::string> areas,
51  Hermes2DFunction<double>* coeff, SymFlag sym, GeomType gt)
52  : MatrixFormVol<double>(i, j), coeff(coeff), gt(gt)
53  {
54  this->set_areas(areas);
55  this->setSymFlag(sym);
56 
57  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
58  if(coeff == HERMES_ONE)
59  this->coeff = new Hermes2DFunction<double>(1.0);
60  }
61  template<>
62  DefaultMatrixFormVol<std::complex<double> >::DefaultMatrixFormVol
63  (int i, int j, Hermes::vector<std::string> areas,
64  Hermes2DFunction<std::complex<double> >* coeff, SymFlag sym, GeomType gt)
65  : MatrixFormVol<std::complex<double> >(i, j), coeff(coeff), gt(gt)
66  {
67  this->set_areas(areas);
68  this->setSymFlag(sym);
69 
70  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
71  if(coeff == HERMES_ONE)
72  this->coeff = new Hermes2DFunction<std::complex<double> >(std::complex<double>(1.0, 1.0));
73  }
74 
75  template<typename Scalar>
76  DefaultMatrixFormVol<Scalar>::~DefaultMatrixFormVol()
77  {
78 
79  if(coeff == HERMES_ONE) delete coeff;
80  };
81 
82  template<typename Scalar>
83  Scalar DefaultMatrixFormVol<Scalar>::value(int n, double *wt, Func<Scalar> *u_ext[], Func<double> *u, Func<double> *v,
84  Geom<double> *e, Func<Scalar> **ext) const
85  {
86  Scalar result = 0;
87  if(gt == HERMES_PLANAR) {
88  for (int i = 0; i < n; i++) {
89  result += wt[i] * coeff->value(e->x[i], e->y[i]) * u->val[i] * v->val[i];
90  }
91  }
92  else {
93  if(gt == HERMES_AXISYM_X) {
94  for (int i = 0; i < n; i++) {
95  result += wt[i] * e->y[i] * coeff->value(e->x[i], e->y[i]) * u->val[i] * v->val[i];
96  }
97  }
98  else {
99  for (int i = 0; i < n; i++) {
100  result += wt[i] * e->x[i] * coeff->value(e->x[i], e->y[i]) * u->val[i] * v->val[i];
101  }
102  }
103  }
104 
105  return result;
106  }
107 
108  template<typename Scalar>
109  Ord DefaultMatrixFormVol<Scalar>::ord(int n, double *wt, Func<Ord> *u_ext[], Func<Ord> *u,
110  Func<Ord> *v, Geom<Ord> *e, Func<Ord> **ext) const
111  {
112  Ord result = Ord(0);
113  if(gt == HERMES_PLANAR) {
114  for (int i = 0; i < n; i++) {
115  result += wt[i] * coeff->value(e->x[i], e->y[i]) * u->val[i] * v->val[i];
116  }
117  }
118  else {
119  if(gt == HERMES_AXISYM_X) {
120  for (int i = 0; i < n; i++) {
121  result += wt[i] * e->y[i] * coeff->value(e->x[i], e->y[i]) * u->val[i] * v->val[i];
122  }
123  }
124  else {
125  for (int i = 0; i < n; i++) {
126  result += wt[i] * e->x[i] * coeff->value(e->x[i], e->y[i]) * u->val[i] * v->val[i];
127  }
128  }
129  }
130 
131  return result;
132  }
133 
134  template<typename Scalar>
135  MatrixFormVol<Scalar>* DefaultMatrixFormVol<Scalar>::clone() const
136  {
137  return new DefaultMatrixFormVol<Scalar>(*this);
138  }
139 
140  template<typename Scalar>
141  DefaultJacobianDiffusion<Scalar>::DefaultJacobianDiffusion(int i, int j, std::string area,
142  Hermes1DFunction<Scalar>* coeff,
143  SymFlag sym, GeomType gt)
144  : MatrixFormVol<Scalar>(i, j), idx_j(j), coeff(coeff), gt(gt)
145  {
146  this->set_area(area);
147  this->setSymFlag(sym);
148 
149  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
150  if(coeff == HERMES_ONE)
151  this->coeff = new Hermes1DFunction<Scalar>(1.0);
152  };
153 
154  template<typename Scalar>
155  DefaultJacobianDiffusion<Scalar>::DefaultJacobianDiffusion(int i, int j, Hermes::vector<std::string> areas,
156  Hermes1DFunction<Scalar>* coeff, SymFlag sym, GeomType gt)
157  : MatrixFormVol<Scalar>(i, j), idx_j(j), coeff(coeff), gt(gt)
158  {
159  this->set_areas(areas);
160  this->setSymFlag(sym);
161 
162  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
163  if(coeff == HERMES_ONE) this->coeff = new Hermes1DFunction<Scalar>(1.0);
164  }
165 
166  template<typename Scalar>
167  DefaultJacobianDiffusion<Scalar>::~DefaultJacobianDiffusion()
168  {
169  if(coeff==HERMES_ONE) delete coeff;
170  };
171 
172  template<typename Scalar>
173  Scalar DefaultJacobianDiffusion<Scalar>::value(int n, double *wt, Func<Scalar> *u_ext[], Func<double> *u,
174  Func<double> *v, Geom<double> *e, Func<Scalar> **ext) const
175  {
176  Scalar result = 0;
177  if(gt == HERMES_PLANAR) {
178  for (int i = 0; i < n; i++) {
179  result += wt[i] * (coeff->derivative(u_ext[idx_j]->val[i]) * u->val[i] *
180  (u_ext[idx_j]->dx[i] * v->dx[i] + u_ext[idx_j]->dy[i] * v->dy[i])
181  + coeff->value(u_ext[idx_j]->val[i])
182  * (u->dx[i] * v->dx[i] + u->dy[i] * v->dy[i]));
183  }
184  }
185  else {
186  if(gt == HERMES_AXISYM_X) {
187  for (int i = 0; i < n; i++) {
188  result += wt[i] * e->y[i] * (coeff->derivative(u_ext[idx_j]->val[i]) * u->val[i] *
189  (u_ext[idx_j]->dx[i] * v->dx[i] + u_ext[idx_j]->dy[i] * v->dy[i])
190  + coeff->value(u_ext[idx_j]->val[i])
191  * (u->dx[i] * v->dx[i] + u->dy[i] * v->dy[i]));
192  }
193  }
194  else {
195  for (int i = 0; i < n; i++) {
196  result += wt[i] * e->x[i] * (coeff->derivative(u_ext[idx_j]->val[i]) * u->val[i] *
197  (u_ext[idx_j]->dx[i] * v->dx[i] + u_ext[idx_j]->dy[i] * v->dy[i])
198  + coeff->value(u_ext[idx_j]->val[i])
199  * (u->dx[i] * v->dx[i] + u->dy[i] * v->dy[i]));
200  }
201  }
202  }
203 
204  return result;
205  }
206 
207  template<typename Scalar>
208  Ord DefaultJacobianDiffusion<Scalar>::ord(int n, double *wt, Func<Ord> *u_ext[], Func<Ord> *u, Func<Ord> *v,
209  Geom<Ord> *e, Func<Ord> **ext) const
210  {
211  Ord result = Ord(0);
212  if(gt == HERMES_PLANAR) {
213  for (int i = 0; i < n; i++) {
214  result += wt[i] * (coeff->derivative(u_ext[idx_j]->val[i]) * u->val[i] *
215  (u_ext[idx_j]->dx[i] * v->dx[i] + u_ext[idx_j]->dy[i] * v->dy[i])
216  + coeff->value(u_ext[idx_j]->val[i])
217  * (u->dx[i] * v->dx[i] + u->dy[i] * v->dy[i]));
218  }
219  }
220  else {
221  if(gt == HERMES_AXISYM_X) {
222  for (int i = 0; i < n; i++) {
223  result += wt[i] * e->y[i] * (coeff->derivative(u_ext[idx_j]->val[i]) * u->val[i] *
224  (u_ext[idx_j]->dx[i] * v->dx[i] + u_ext[idx_j]->dy[i] * v->dy[i])
225  + coeff->value(u_ext[idx_j]->val[i])
226  * (u->dx[i] * v->dx[i] + u->dy[i] * v->dy[i]));
227  }
228  }
229  else {
230  for (int i = 0; i < n; i++) {
231  result += wt[i] * e->x[i] * (coeff->derivative(u_ext[idx_j]->val[i]) * u->val[i] *
232  (u_ext[idx_j]->dx[i] * v->dx[i] + u_ext[idx_j]->dy[i] * v->dy[i])
233  + coeff->value(u_ext[idx_j]->val[i])
234  * (u->dx[i] * v->dx[i] + u->dy[i] * v->dy[i]));
235  }
236  }
237  }
238 
239  return result;
240  }
241 
242  template<typename Scalar>
243  MatrixFormVol<Scalar>* DefaultJacobianDiffusion<Scalar>::clone() const
244  {
245  return new DefaultJacobianDiffusion<Scalar>(*this);
246  }
247 
248  template<typename Scalar>
249  DefaultMatrixFormDiffusion<Scalar>::DefaultMatrixFormDiffusion(int i, int j, std::string area,
250  Hermes1DFunction<Scalar>* coeff,
251  SymFlag sym, GeomType gt)
252  : MatrixFormVol<Scalar>(i, j), idx_j(j), coeff(coeff), gt(gt)
253  {
254  this->set_area(area);
255  this->setSymFlag(sym);
256 
257  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
258  if(coeff == HERMES_ONE) this->coeff = new Hermes1DFunction<Scalar>(1.0);
259  };
260 
261  template<typename Scalar>
262  DefaultMatrixFormDiffusion<Scalar>::DefaultMatrixFormDiffusion(int i, int j, Hermes::vector<std::string> areas,
263  Hermes1DFunction<Scalar>* coeff, SymFlag sym, GeomType gt)
264  : MatrixFormVol<Scalar>(i, j), idx_j(j), coeff(coeff), gt(gt)
265  {
266  this->set_areas(areas);
267  this->setSymFlag(sym);
268 
269  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
270  if(coeff == HERMES_ONE) this->coeff = new Hermes1DFunction<Scalar>(1.0);
271  }
272 
273  template<typename Scalar>
274  DefaultMatrixFormDiffusion<Scalar>::~DefaultMatrixFormDiffusion()
275  {
276  if(coeff == HERMES_ONE) delete coeff;
277  };
278 
279  template<typename Scalar>
280  Scalar DefaultMatrixFormDiffusion<Scalar>::value(int n, double *wt, Func<Scalar> *u_ext[], Func<double> *u,
281  Func<double> *v, Geom<double> *e, Func<Scalar> **ext) const
282  {
283  Scalar result = 0;
284  if(gt == HERMES_PLANAR) {
285  for (int i = 0; i < n; i++) {
286  result += wt[i] * (u->dx[i] * v->dx[i] + u->dy[i] * v->dy[i]);
287  }
288  }
289  else {
290  if(gt == HERMES_AXISYM_X) {
291  for (int i = 0; i < n; i++) {
292  result += wt[i] * e->y[i] * (u->dx[i] * v->dx[i] + u->dy[i] * v->dy[i]);
293  }
294  }
295  else {
296  for (int i = 0; i < n; i++) {
297  result += wt[i] * e->x[i] * (u->dx[i] * v->dx[i] + u->dy[i] * v->dy[i]);
298  }
299  }
300  }
301 
302  return result;
303  }
304 
305  template<typename Scalar>
306  Ord DefaultMatrixFormDiffusion<Scalar>::ord(int n, double *wt, Func<Ord> *u_ext[], Func<Ord> *u, Func<Ord> *v,
307  Geom<Ord> *e, Func<Ord> **ext) const
308  {
309  Ord result = Ord(0);
310  if(gt == HERMES_PLANAR) {
311  for (int i = 0; i < n; i++) {
312  result += wt[i] * (u->dx[i] * v->dx[i] + u->dy[i] * v->dy[i]);
313  }
314  }
315  else {
316  if(gt == HERMES_AXISYM_X) {
317  for (int i = 0; i < n; i++) {
318  result += wt[i] * e->y[i] * (u->dx[i] * v->dx[i] + u->dy[i] * v->dy[i]);
319  }
320  }
321  else {
322  for (int i = 0; i < n; i++) {
323  result += wt[i] * e->x[i] * (u->dx[i] * v->dx[i] + u->dy[i] * v->dy[i]);
324  }
325  }
326  }
327 
328  return result;
329  }
330 
331  template<typename Scalar>
332  MatrixFormVol<Scalar>* DefaultMatrixFormDiffusion<Scalar>::clone() const
333  {
334  return new DefaultMatrixFormDiffusion<Scalar>(*this);
335  }
336 
337  template<typename Scalar>
338  DefaultJacobianAdvection<Scalar>::DefaultJacobianAdvection(int i, int j, std::string area,
339  Hermes1DFunction<Scalar>* coeff1,
340  Hermes1DFunction<Scalar>* coeff2,
341  GeomType gt)
342  : MatrixFormVol<Scalar>(i, j),
343  idx_j(j), coeff1(coeff1), coeff2(coeff2), gt(gt)
344  {
345  this->set_area(area);
346 
347  if(gt != HERMES_PLANAR) throw Hermes::Exceptions::Exception("Axisymmetric advection forms not implemented yet.");
348 
349  // If coeff1 == HERMES_ONE or coeff22 == HERMES_ONE, initialize it to be constant 1.0.
350  if(coeff1 == HERMES_ONE) this->coeff1 = new Hermes1DFunction<Scalar>(1.0);
351  if(coeff2 == HERMES_ONE) this->coeff2 = new Hermes1DFunction<Scalar>(1.0);
352  }
353 
354  template<typename Scalar>
355  DefaultJacobianAdvection<Scalar>::DefaultJacobianAdvection(int i, int j, Hermes::vector<std::string> areas,
356  Hermes1DFunction<Scalar>* coeff1,
357  Hermes1DFunction<Scalar>* coeff2,
358  GeomType gt)
359  : MatrixFormVol<Scalar>(i, j),
360  idx_j(j), coeff1(coeff1), coeff2(coeff2), gt(gt)
361  {
362  this->set_areas(areas);
363 
364  if(gt != HERMES_PLANAR) throw Hermes::Exceptions::Exception("Axisymmetric advection forms not implemented yet.");
365 
366  // If coeff1 == HERMES_ONE or coeff22 == HERMES_ONE, initialize it to be constant 1.0.
367  if(coeff1 == HERMES_ONE) this->coeff1 = new Hermes1DFunction<Scalar>(1.0);
368  if(coeff2 == HERMES_ONE) this->coeff2 = new Hermes1DFunction<Scalar>(1.0);
369  }
370 
371  template<typename Scalar>
372  DefaultJacobianAdvection<Scalar>::~DefaultJacobianAdvection()
373  {
374 
375  //if(coeff1 != HERMES_ONE) delete coeff1;
376  //if(coeff2 != HERMES_ONE) delete coeff2;
377  };
378 
379  template<typename Scalar>
380  Scalar DefaultJacobianAdvection<Scalar>::value(int n, double *wt, Func<Scalar> *u_ext[], Func<double> *u,
381  Func<double> *v, Geom<double> *e, Func<Scalar> **ext) const
382  {
383  Scalar result = 0;
384  for (int i = 0; i < n; i++) {
385  result += wt[i] * ( coeff1->derivative(u_ext[idx_j]->val[i]) * u->val[i] * u_ext[idx_j]->dx[i] * v->val[i]
386  + coeff1->value(u_ext[idx_j]->val[i]) * u->dx[i] * v->val[i]
387  + coeff2->derivative(u_ext[idx_j]->val[i]) * u->val[i] * u_ext[idx_j]->dy[i] * v->val[i]
388  + coeff2->value(u_ext[idx_j]->val[i]) * u->dy[i] * v->val[i]);
389  }
390  return result;
391  }
392 
393  template<typename Scalar>
394  Ord DefaultJacobianAdvection<Scalar>::ord(int n, double *wt, Func<Ord> *u_ext[], Func<Ord> *u, Func<Ord> *v,
395  Geom<Ord> *e, Func<Ord> **ext) const
396  {
397  Ord result = Ord(0);
398  for (int i = 0; i < n; i++) {
399  result += wt[i] * ( coeff1->derivative(u_ext[idx_j]->val[i]) * u->val[i] * u_ext[idx_j]->dx[i] * v->val[i]
400  + coeff1->value(u_ext[idx_j]->val[i]) * u->dx[i] * v->val[i]
401  + coeff2->derivative(u_ext[idx_j]->val[i]) * u->val[i] * u_ext[idx_j]->dy[i] * v->val[i]
402  + coeff2->value(u_ext[idx_j]->val[i]) * u->dy[i] * v->val[i]);
403  }
404  return result;
405  }
406 
407  // This is to make the form usable in rk_time_step_newton().
408  template<typename Scalar>
409  MatrixFormVol<Scalar>* DefaultJacobianAdvection<Scalar>::clone() const
410  {
411  return new DefaultJacobianAdvection<Scalar>(*this);
412  }
413 
414  template<typename Scalar>
415  DefaultVectorFormVol<Scalar>::DefaultVectorFormVol(int i, std::string area,
416  Hermes2DFunction<Scalar>* coeff,
417  GeomType gt)
418  : VectorFormVol<Scalar>(i), coeff(coeff), gt(gt)
419  {
420  this->set_area(area);
421 
422  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
423  if(coeff == HERMES_ONE) this->coeff = new Hermes2DFunction<Scalar>(1.0);
424  }
425 
426  template<typename Scalar>
427  DefaultVectorFormVol<Scalar>::DefaultVectorFormVol(int i, Hermes::vector<std::string> areas,
428  Hermes2DFunction<Scalar>* coeff,
429  GeomType gt)
430  : VectorFormVol<Scalar>(i), coeff(coeff), gt(gt)
431  {
432  this->set_areas(areas);
433 
434  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
435  if(coeff == HERMES_ONE) this->coeff = new Hermes2DFunction<Scalar>(1.0);
436  }
437 
438  template<typename Scalar>
439  DefaultVectorFormVol<Scalar>::~DefaultVectorFormVol()
440  {
441 
442  if(coeff == HERMES_ONE) delete coeff;
443  };
444 
445  template<typename Scalar>
446  Scalar DefaultVectorFormVol<Scalar>::value(int n, double *wt, Func<Scalar> *u_ext[], Func<double> *v,
447  Geom<double> *e, Func<Scalar> **ext) const
448  {
449  Scalar result = 0;
450  if(gt == HERMES_PLANAR) {
451  for (int i = 0; i < n; i++) {
452  result += wt[i] * coeff->value(e->x[i], e->y[i]) * v->val[i];
453  }
454  }
455  else {
456  if(gt == HERMES_AXISYM_X) {
457  for (int i = 0; i < n; i++) {
458  result += wt[i] * e->y[i] * coeff->value(e->x[i], e->y[i]) * v->val[i];
459  }
460  }
461  else {
462  for (int i = 0; i < n; i++) {
463  result += wt[i] * e->x[i] * coeff->value(e->x[i], e->y[i]) * v->val[i];
464  }
465  }
466  }
467  return result;
468  }
469 
470  template<typename Scalar>
471  Ord DefaultVectorFormVol<Scalar>::ord(int n, double *wt, Func<Ord> *u_ext[], Func<Ord> *v,
472  Geom<Ord> *e, Func<Ord> **ext) const
473  {
474  Ord result = Ord(0);
475  if(gt == HERMES_PLANAR) {
476  for (int i = 0; i < n; i++) {
477  result += wt[i] * coeff->value(e->x[i], e->y[i]) * v->val[i];
478  }
479  }
480  else {
481  if(gt == HERMES_AXISYM_X) {
482  for (int i = 0; i < n; i++) {
483  result += wt[i] * e->y[i] * coeff->value(e->x[i], e->y[i]) * v->val[i];
484  }
485  }
486  else {
487  for (int i = 0; i < n; i++) {
488  result += wt[i] * e->x[i] * coeff->value(e->x[i], e->y[i]) * v->val[i];
489  }
490  }
491  }
492 
493  return result;
494  }
495 
496  template<typename Scalar>
497  VectorFormVol<Scalar>* DefaultVectorFormVol<Scalar>::clone() const
498  {
499  return new DefaultVectorFormVol<Scalar>(*this);
500  }
501 
502  template<typename Scalar>
503  DefaultResidualVol<Scalar>::DefaultResidualVol(int i, std::string area,
504  Hermes2DFunction<Scalar>* coeff,
505  GeomType gt)
506  : VectorFormVol<Scalar>(i), idx_i(i), coeff(coeff), gt(gt)
507  {
508  this->set_area(area);
509 
510  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
511  if(coeff == HERMES_ONE) this->coeff = new Hermes2DFunction<Scalar>(1.0);
512  }
513 
514  template<typename Scalar>
515  DefaultResidualVol<Scalar>::DefaultResidualVol(int i, Hermes::vector<std::string> areas,
516  Hermes2DFunction<Scalar>* coeff,
517  GeomType gt)
518  : VectorFormVol<Scalar>(i), idx_i(i), coeff(coeff), gt(gt)
519  {
520  this->set_areas(areas);
521 
522  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
523  if(coeff == HERMES_ONE) this->coeff = new Hermes2DFunction<Scalar>(1.0);
524  }
525 
526  template<typename Scalar>
527  DefaultResidualVol<Scalar>::~DefaultResidualVol()
528  {
529 
530  if(coeff == HERMES_ONE) delete coeff;
531  };
532 
533  template<typename Scalar>
534  Scalar DefaultResidualVol<Scalar>::value(int n, double *wt, Func<Scalar> *u_ext[], Func<double> *v,
535  Geom<double> *e, Func<Scalar> **ext) const
536  {
537  Scalar result = 0;
538  if(gt == HERMES_PLANAR) {
539  for (int i = 0; i < n; i++) {
540  result += wt[i] * coeff->value(e->x[i], e->y[i]) * u_ext[idx_i]->val[i] * v->val[i];
541  }
542  }
543  else {
544  if(gt == HERMES_AXISYM_X) {
545  for (int i = 0; i < n; i++) {
546  result += wt[i] * e->y[i] * coeff->value(e->x[i], e->y[i]) * u_ext[idx_i]->val[i] * v->val[i];
547  }
548  }
549  else {
550  for (int i = 0; i < n; i++) {
551  result += wt[i] * e->x[i] * coeff->value(e->x[i], e->y[i]) * u_ext[idx_i]->val[i] * v->val[i];
552  }
553  }
554  }
555  return result;
556  }
557 
558  template<typename Scalar>
559  Ord DefaultResidualVol<Scalar>::ord(int n, double *wt, Func<Ord> *u_ext[], Func<Ord> *v,
560  Geom<Ord> *e, Func<Ord> **ext) const
561  {
562  Ord result = Ord(0);
563  if(gt == HERMES_PLANAR) {
564  for (int i = 0; i < n; i++) {
565  result += wt[i] * coeff->value(e->x[i], e->y[i]) * u_ext[idx_i]->val[i] * v->val[i];
566  }
567  }
568  else {
569  if(gt == HERMES_AXISYM_X) {
570  for (int i = 0; i < n; i++) {
571  result += wt[i] * e->y[i] * coeff->value(e->x[i], e->y[i]) * u_ext[idx_i]->val[i] * v->val[i];
572  }
573  }
574  else {
575  for (int i = 0; i < n; i++) {
576  result += wt[i] * e->x[i] * coeff->value(e->x[i], e->y[i]) * u_ext[idx_i]->val[i] * v->val[i];
577  }
578  }
579  }
580 
581  return result;
582  }
583 
584  template<typename Scalar>
585  VectorFormVol<Scalar>* DefaultResidualVol<Scalar>::clone() const
586  {
587  return new DefaultResidualVol(*this);
588  }
589 
590  template<typename Scalar>
591  DefaultResidualDiffusion<Scalar>::DefaultResidualDiffusion(int i, std::string area,
592  Hermes1DFunction<Scalar>* coeff, GeomType gt)
593  : VectorFormVol<Scalar>(i), idx_i(i), coeff(coeff), gt(gt)
594  {
595  this->set_area(area);
596 
597  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
598  if(coeff == HERMES_ONE) this->coeff = new Hermes1DFunction<Scalar>(1.0);
599  };
600 
601  template<typename Scalar>
602  DefaultResidualDiffusion<Scalar>::DefaultResidualDiffusion(int i, Hermes::vector<std::string> areas,
603  Hermes1DFunction<Scalar>* coeff, GeomType gt)
604  : VectorFormVol<Scalar>(i), idx_i(i), coeff(coeff), gt(gt)
605  {
606  this->set_areas(areas);
607 
608  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
609  if(coeff == HERMES_ONE) this->coeff = new Hermes1DFunction<Scalar>(1.0);
610  }
611 
612  template<typename Scalar>
613  DefaultResidualDiffusion<Scalar>::~DefaultResidualDiffusion()
614  {
615 
616  if(coeff == HERMES_ONE) delete coeff;
617  };
618 
619  template<typename Scalar>
620  Scalar DefaultResidualDiffusion<Scalar>::value(int n, double *wt, Func<Scalar> *u_ext[], Func<double> *v,
621  Geom<double> *e, Func<Scalar> **ext) const
622  {
623  Scalar result = 0;
624  if(gt == HERMES_PLANAR) {
625  for (int i = 0; i < n; i++) {
626  result += wt[i] * coeff->value(u_ext[idx_i]->val[i])
627  * (u_ext[idx_i]->dx[i] * v->dx[i] + u_ext[idx_i]->dy[i] * v->dy[i]);
628  }
629  }
630  else {
631  if(gt == HERMES_AXISYM_X) {
632  for (int i = 0; i < n; i++) {
633  result += wt[i] * e->y[i] * coeff->value(u_ext[idx_i]->val[i])
634  * (u_ext[idx_i]->dx[i] * v->dx[i] + u_ext[idx_i]->dy[i] * v->dy[i]);
635  }
636  }
637  else {
638  for (int i = 0; i < n; i++) {
639  result += wt[i] * e->x[i] * coeff->value(u_ext[idx_i]->val[i])
640  * (u_ext[idx_i]->dx[i] * v->dx[i] + u_ext[idx_i]->dy[i] * v->dy[i]);
641  }
642  }
643  }
644 
645  return result;
646  }
647 
648  template<typename Scalar>
649  Ord DefaultResidualDiffusion<Scalar>::ord(int n, double *wt, Func<Ord> *u_ext[], Func<Ord> *v,
650  Geom<Ord> *e, Func<Ord> **ext) const
651  {
652  Ord result = Ord(0);
653  for (int i = 0; i < n; i++) {
654  result += wt[i] * coeff->value(u_ext[idx_i]->val[i])
655  * (u_ext[idx_i]->dx[i] * v->dx[i] + u_ext[idx_i]->dy[i] * v->dy[i]);
656  }
657  if(gt != HERMES_PLANAR) result = result * Ord(1);
658 
659  return result;
660  }
661 
662  template<typename Scalar>
663  VectorFormVol<Scalar>* DefaultResidualDiffusion<Scalar>::clone() const
664  {
665  return new DefaultResidualDiffusion<Scalar>(*this);
666  }
667 
668  template<typename Scalar>
669  DefaultResidualAdvection<Scalar>::DefaultResidualAdvection(int i, std::string area,
670  Hermes1DFunction<Scalar>* coeff1,
671  Hermes1DFunction<Scalar>* coeff2,
672  GeomType gt)
673  : VectorFormVol<Scalar>(i), idx_i(i), coeff1(coeff1), coeff2(coeff2), gt(gt)
674  {
675  this->set_area(area);
676 
677  if(gt != HERMES_PLANAR) throw Hermes::Exceptions::Exception("Axisymmetric advection forms not implemented yet.");
678 
679  // If coeff1 == HERMES_ONE or coeff22 == HERMES_ONE, initialize it to be constant 1.0.
680  if(coeff1 == HERMES_ONE) this->coeff1 = new Hermes1DFunction<Scalar>(1.0);
681  if(coeff2 == HERMES_ONE) this->coeff2 = new Hermes1DFunction<Scalar>(1.0);
682  }
683 
684  template<typename Scalar>
685  DefaultResidualAdvection<Scalar>::DefaultResidualAdvection(int i, Hermes::vector<std::string> areas, \
686  Hermes1DFunction<Scalar>* coeff1,
687  Hermes1DFunction<Scalar>* coeff2,
688  GeomType gt)
689  : VectorFormVol<Scalar>(i),
690  idx_i(i), coeff1(coeff1), coeff2(coeff2), gt(gt)
691  {
692  this->set_areas(areas);
693 
694  if(gt != HERMES_PLANAR) throw Hermes::Exceptions::Exception("Axisymmetric advection forms not implemented yet.");
695 
696  // If coeff1 == HERMES_ONE or coeff22 == HERMES_ONE, initialize it to be constant 1.0.
697  if(coeff1 == HERMES_ONE) this->coeff1 = new Hermes1DFunction<Scalar>(1.0);
698  if(coeff2 == HERMES_ONE) this->coeff2 = new Hermes1DFunction<Scalar>(1.0);
699  }
700 
701  template<typename Scalar>
702  DefaultResidualAdvection<Scalar>::~DefaultResidualAdvection()
703  {
704 
705  //if(coeff1 != HERMES_ONE) delete coeff1;
706  //if(coeff2 != HERMES_ONE) delete coeff2;
707  };
708 
709  template<typename Scalar>
710  Scalar DefaultResidualAdvection<Scalar>::value(int n, double *wt, Func<Scalar> *u_ext[], Func<double> *v,
711  Geom<double> *e, Func<Scalar> **ext) const
712  {
713  Scalar result = 0;
714  Func<Scalar>* u_prev = u_ext[idx_i];
715  for (int i = 0; i < n; i++) {
716  result += wt[i] * (coeff1->value(u_prev->val[i]) * (u_prev->dx[i] * v->val[i])
717  + coeff2->value(u_prev->val[i]) * (u_prev->dy[i] * v->val[i]));
718  }
719  return result;
720  }
721 
722  template<typename Scalar>
723  Ord DefaultResidualAdvection<Scalar>::ord(int n, double *wt, Func<Ord> *u_ext[], Func<Ord> *v,
724  Geom<Ord> *e, Func<Ord> **ext) const
725  {
726  Ord result = Ord(0);
727  Func<Ord>* u_prev = u_ext[idx_i];
728  for (int i = 0; i < n; i++) {
729  result += wt[i] * (coeff1->value(u_prev->val[i]) * (u_prev->dx[i] * v->val[i])
730  + coeff2->value(u_prev->val[i]) * (u_prev->dy[i] * v->val[i]));
731  }
732  return result;
733  }
734 
735  template<typename Scalar>
736  VectorFormVol<Scalar>* DefaultResidualAdvection<Scalar>::clone() const
737  {
738  return new DefaultResidualAdvection<Scalar>(*this);
739  }
740 
741  template<typename Scalar>
742  DefaultMatrixFormSurf<Scalar>::DefaultMatrixFormSurf(int i, int j, std::string area,
743  Hermes2DFunction<Scalar>* coeff,
744  GeomType gt)
745  : MatrixFormSurf<Scalar>(i, j), coeff(coeff), gt(gt)
746  {
747  this->set_area(area);
748 
749  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
750  if(coeff == HERMES_ONE) this->coeff = new Hermes2DFunction<Scalar>(1.0);
751  }
752 
753  template<typename Scalar>
754  DefaultMatrixFormSurf<Scalar>::DefaultMatrixFormSurf(int i, int j, Hermes::vector<std::string> areas,
755  Hermes2DFunction<Scalar>* coeff,
756  GeomType gt)
757  : MatrixFormSurf<Scalar>(i, j), coeff(coeff), gt(gt)
758  {
759  this->set_areas(areas);
760 
761  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
762  if(coeff == HERMES_ONE) this->coeff = new Hermes2DFunction<Scalar>(1.0);
763  }
764 
765  template<typename Scalar>
766  DefaultMatrixFormSurf<Scalar>::~DefaultMatrixFormSurf()
767  {
768 
769  if(coeff == HERMES_ONE) delete coeff;
770  };
771 
772  template<typename Scalar>
773  Scalar DefaultMatrixFormSurf<Scalar>::value(int n, double *wt, Func<Scalar> *u_ext[], Func<double> *u, Func<double> *v,
774  Geom<double> *e, Func<Scalar> **ext) const
775  {
776  Scalar result = 0;
777  if(gt == HERMES_PLANAR) {
778  for (int i = 0; i < n; i++) {
779  result += wt[i] * coeff->value(e->x[i], e->y[i]) * u->val[i] * v->val[i];
780  }
781  }
782  else {
783  if(gt == HERMES_AXISYM_X) {
784  for (int i = 0; i < n; i++) {
785  result += wt[i] * e->y[i] * coeff->value(e->x[i], e->y[i]) * u->val[i] * v->val[i];
786  }
787  }
788  else {
789  for (int i = 0; i < n; i++) {
790  result += wt[i] * e->x[i] * coeff->value(e->x[i], e->y[i]) * u->val[i] * v->val[i];
791  }
792  }
793  }
794 
795  return result;
796  }
797 
798  template<typename Scalar>
799  Ord DefaultMatrixFormSurf<Scalar>::ord(int n, double *wt, Func<Ord> *u_ext[], Func<Ord> *u,
800  Func<Ord> *v, Geom<Ord> *e, Func<Ord> **ext) const
801  {
802  Ord result = Ord(0);
803  if(gt == HERMES_PLANAR) {
804  for (int i = 0; i < n; i++) {
805  result += wt[i] * coeff->value(e->x[i], e->y[i]) * u->val[i] * v->val[i];
806  }
807  }
808  else {
809  if(gt == HERMES_AXISYM_X) {
810  for (int i = 0; i < n; i++) {
811  result += wt[i] * e->y[i] * coeff->value(e->x[i], e->y[i]) * u->val[i] * v->val[i];
812  }
813  }
814  else {
815  for (int i = 0; i < n; i++) {
816  result += wt[i] * e->x[i] * coeff->value(e->x[i], e->y[i]) * u->val[i] * v->val[i];
817  }
818  }
819  }
820 
821  return result;
822  }
823 
824  template<typename Scalar>
825  MatrixFormSurf<Scalar>* DefaultMatrixFormSurf<Scalar>::clone() const
826  {
827  return new DefaultMatrixFormSurf<Scalar>(*this);
828  }
829 
830  template<typename Scalar>
831  DefaultJacobianFormSurf<Scalar>::DefaultJacobianFormSurf(int i, int j, std::string area,
832  Hermes1DFunction<Scalar>* coeff,
833  GeomType gt)
834  : MatrixFormSurf<Scalar>(i, j),
835  idx_j(j), coeff(coeff), gt(gt)
836  {
837  this->set_area(area);
838 
839  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
840  if(coeff == HERMES_ONE) this->coeff = new Hermes1DFunction<Scalar>(1.0);
841  }
842 
843  template<typename Scalar>
844  DefaultJacobianFormSurf<Scalar>::DefaultJacobianFormSurf(int i, int j, Hermes::vector<std::string> areas,
845  Hermes1DFunction<Scalar>* coeff,
846  GeomType gt)
847  : MatrixFormSurf<Scalar>(i, j), coeff(coeff), gt(gt)
848  {
849  this->set_areas(areas);
850 
851  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
852  if(coeff == HERMES_ONE) this->coeff = new Hermes1DFunction<Scalar>(1.0);
853  }
854 
855  template<typename Scalar>
856  DefaultJacobianFormSurf<Scalar>::~DefaultJacobianFormSurf()
857  {
858 
859  if(coeff == HERMES_ONE) delete coeff;
860  };
861 
862  template<typename Scalar>
863  Scalar DefaultJacobianFormSurf<Scalar>::value(int n, double *wt, Func<Scalar> *u_ext[], Func<double> *u, Func<double> *v,
864  Geom<double> *e, Func<Scalar> **ext) const
865  {
866  Scalar result = 0;
867  for (int i = 0; i < n; i++) {
868  result += wt[i] * (coeff->derivative(u_ext[idx_j]->val[i]) * u_ext[idx_j]->val[i]
869  + coeff->value(u_ext[idx_j]->val[i]))
870  * u->val[i] * v->val[i];
871  }
872  return result;
873  }
874 
875  template<typename Scalar>
876  Ord DefaultJacobianFormSurf<Scalar>::ord(int n, double *wt, Func<Ord> *u_ext[], Func<Ord> *u,
877  Func<Ord> *v, Geom<Ord> *e, Func<Ord> **ext) const
878  {
879  Ord result = Ord(0);
880  for (int i = 0; i < n; i++) {
881  result += wt[i] * (coeff->derivative(u_ext[idx_j]->val[i]) * u_ext[idx_j]->val[i]
882  + coeff->value(u_ext[idx_j]->val[i]))
883  * u->val[i] * v->val[i];
884  }
885  return result;
886  }
887 
888  template<typename Scalar>
889  MatrixFormSurf<Scalar>* DefaultJacobianFormSurf<Scalar>::clone() const
890  {
891  return new DefaultJacobianFormSurf<Scalar>(*this);
892  }
893 
894  template<typename Scalar>
895  DefaultVectorFormSurf<Scalar>::DefaultVectorFormSurf(int i, std::string area,
896  Hermes2DFunction<Scalar>* coeff,
897  GeomType gt)
898  : VectorFormSurf<Scalar>(i), coeff(coeff), gt(gt)
899  {
900  this->set_area(area);
901 
902  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
903  if(coeff == HERMES_ONE) this->coeff = new Hermes2DFunction<Scalar>(1.0);
904  }
905 
906  template<typename Scalar>
907  DefaultVectorFormSurf<Scalar>::DefaultVectorFormSurf(int i, Hermes::vector<std::string> areas,
908  Hermes2DFunction<Scalar>* coeff,
909  GeomType gt)
910  : VectorFormSurf<Scalar>(i), coeff(coeff), gt(gt)
911  {
912  this->set_areas(areas);
913 
914  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
915  if(coeff == HERMES_ONE) this->coeff = new Hermes2DFunction<Scalar>(1.0);
916  }
917 
918  template<typename Scalar>
919  DefaultVectorFormSurf<Scalar>::~DefaultVectorFormSurf()
920  {
921 
922  if(coeff == HERMES_ONE) delete coeff;
923  };
924 
925  template<typename Scalar>
926  Scalar DefaultVectorFormSurf<Scalar>::value(int n, double *wt, Func<Scalar> *u_ext[], Func<double> *v,
927  Geom<double> *e, Func<Scalar> **ext) const
928  {
929  Scalar result = 0;
930  if(gt == HERMES_PLANAR) {
931  for (int i = 0; i < n; i++) {
932  result += wt[i] * coeff->value(e->x[i], e->y[i]) * v->val[i];
933  }
934  }
935  else {
936  if(gt == HERMES_AXISYM_X) {
937  for (int i = 0; i < n; i++) {
938  result += wt[i] * e->y[i] * coeff->value(e->x[i], e->y[i]) * v->val[i];
939  }
940  }
941  else {
942  for (int i = 0; i < n; i++) {
943  result += wt[i] * e->x[i] * coeff->value(e->x[i], e->y[i]) * v->val[i];
944  }
945  }
946  }
947 
948  return result;
949  }
950 
951  template<typename Scalar>
952  Ord DefaultVectorFormSurf<Scalar>::ord(int n, double *wt, Func<Ord> *u_ext[], Func<Ord> *v,
953  Geom<Ord> *e, Func<Ord> **ext) const
954  {
955  Ord result = Ord(0);
956  if(gt == HERMES_PLANAR) {
957  for (int i = 0; i < n; i++) {
958  result += wt[i] * coeff->value(e->x[i], e->y[i]) * v->val[i];
959  }
960  }
961  else {
962  if(gt == HERMES_AXISYM_X) {
963  for (int i = 0; i < n; i++) {
964  result += wt[i] * e->y[i] * coeff->value(e->x[i], e->y[i]) * v->val[i];
965  }
966  }
967  else {
968  for (int i = 0; i < n; i++) {
969  result += wt[i] * e->x[i] * coeff->value(e->x[i], e->y[i]) * v->val[i];
970  }
971  }
972  }
973 
974  return result;
975  }
976 
977  template<typename Scalar>
978  VectorFormSurf<Scalar>* DefaultVectorFormSurf<Scalar>::clone() const
979  {
980  return new DefaultVectorFormSurf<Scalar>(*this);
981  }
982 
983  template<typename Scalar>
984  DefaultResidualSurf<Scalar>::DefaultResidualSurf(int i, std::string area,
985  Hermes2DFunction<Scalar>* coeff,
986  GeomType gt)
987  : VectorFormSurf<Scalar>(i), idx_i(i), coeff(coeff), gt(gt)
988  {
989  this->set_area(area);
990 
991  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
992  if(coeff == HERMES_ONE) this->coeff = new Hermes2DFunction<Scalar>(1.0);
993  }
994 
995  template<typename Scalar>
996  DefaultResidualSurf<Scalar>::DefaultResidualSurf(int i, Hermes::vector<std::string> areas,
997  Hermes2DFunction<Scalar>* coeff,
998  GeomType gt)
999  : VectorFormSurf<Scalar>(i), idx_i(i), coeff(coeff), gt(gt)
1000  {
1001  this->set_areas(areas);
1002 
1003  // If coeff is HERMES_ONE, initialize it to be constant 1.0.
1004  if(coeff == HERMES_ONE) this->coeff = new Hermes2DFunction<Scalar>(1.0);
1005  }
1006 
1007  template<typename Scalar>
1008  DefaultResidualSurf<Scalar>::~DefaultResidualSurf()
1009  {
1010 
1011  if(coeff == HERMES_ONE) delete coeff;
1012  };
1013 
1014  template<typename Scalar>
1015  Scalar DefaultResidualSurf<Scalar>::value(int n, double *wt, Func<Scalar> *u_ext[], Func<double> *v,
1016  Geom<double> *e, Func<Scalar> **ext) const
1017  {
1018  Scalar result = 0;
1019  if(gt == HERMES_PLANAR) {
1020  for (int i = 0; i < n; i++) {
1021  result += wt[i] * coeff->value(e->x[i], e->y[i]) * u_ext[idx_i]->val[i] * v->val[i];
1022  }
1023  }
1024  else {
1025  if(gt == HERMES_AXISYM_X) {
1026  for (int i = 0; i < n; i++) {
1027  result += wt[i] * e->y[i] * coeff->value(e->x[i], e->y[i]) * u_ext[idx_i]->val[i] * v->val[i];
1028  }
1029  }
1030  else {
1031  for (int i = 0; i < n; i++) {
1032  result += wt[i] * e->x[i] * coeff->value(e->x[i], e->y[i]) * u_ext[idx_i]->val[i] * v->val[i];
1033  }
1034  }
1035  }
1036 
1037  return result;
1038  }
1039 
1040  template<typename Scalar>
1041  Ord DefaultResidualSurf<Scalar>::ord(int n, double *wt, Func<Ord> *u_ext[], Func<Ord> *v,
1042  Geom<Ord> *e, Func<Ord> **ext) const
1043  {
1044  Ord result = Ord(0);
1045  if(gt == HERMES_PLANAR) {
1046  for (int i = 0; i < n; i++) {
1047  result += wt[i] * coeff->value(e->x[i], e->y[i]) * u_ext[idx_i]->val[i] * v->val[i];
1048  }
1049  }
1050  else {
1051  if(gt == HERMES_AXISYM_X) {
1052  for (int i = 0; i < n; i++) {
1053  result += wt[i] * e->y[i] * coeff->value(e->x[i], e->y[i]) * u_ext[idx_i]->val[i] * v->val[i];
1054  }
1055  }
1056  else {
1057  for (int i = 0; i < n; i++) {
1058  result += wt[i] * e->x[i] * coeff->value(e->x[i], e->y[i]) * u_ext[idx_i]->val[i] * v->val[i];
1059  }
1060  }
1061  }
1062 
1063  return result;
1064  }
1065 
1066  template<typename Scalar>
1067  VectorFormSurf<Scalar>* DefaultResidualSurf<Scalar>::clone() const
1068  {
1069  return new DefaultResidualSurf(*this);
1070  }
1071 
1072  template<typename Scalar>
1073  DefaultWeakFormLaplace<Scalar>::DefaultWeakFormLaplace(std::string area,
1074  Hermes1DFunction<Scalar>* coeff,
1075  GeomType gt) : WeakForm<Scalar>()
1076  {
1077  // Jacobian.
1078  this->add_matrix_form(new DefaultJacobianDiffusion<Scalar>(0, 0, area, coeff, HERMES_NONSYM, gt));
1079 
1080  // Residual.
1081  this->add_vector_form(new DefaultResidualDiffusion<Scalar>(0, area, coeff, gt));
1082  };
1083 
1084  template<typename Scalar>
1085  DefaultWeakFormPoisson<Scalar>::DefaultWeakFormPoisson() : WeakForm<Scalar>()
1086  {
1087  };
1088 
1089  template<typename Scalar>
1090  DefaultWeakFormPoisson<Scalar>::DefaultWeakFormPoisson(std::string area,
1091  Hermes1DFunction<Scalar>* coeff,
1092  Hermes2DFunction<Scalar>* f,
1093  GeomType gt) : WeakForm<Scalar>()
1094  {
1095  // Jacobian.
1096  // NOTE: The flag HERMES_NONSYM is important here.
1097  this->add_matrix_form(new DefaultJacobianDiffusion<Scalar>(0, 0, area, coeff, HERMES_NONSYM, gt));
1098 
1099  // Residual.
1100  this->add_vector_form(new DefaultResidualDiffusion<Scalar>(0, area, coeff, gt));
1101  this->add_vector_form(new DefaultVectorFormVol<Scalar>(0, area, f, gt));
1102  };
1103 
1104  template class HERMES_API DefaultMatrixFormVol<double>;
1105  template class HERMES_API DefaultMatrixFormVol<std::complex<double> >;
1106  template class HERMES_API DefaultJacobianDiffusion<double>;
1107  template class HERMES_API DefaultJacobianDiffusion<std::complex<double> >;
1108  template class HERMES_API DefaultMatrixFormDiffusion<double>;
1109  template class HERMES_API DefaultMatrixFormDiffusion<std::complex<double> >;
1110  template class HERMES_API DefaultResidualAdvection<double>;
1111  template class HERMES_API DefaultResidualAdvection<std::complex<double> >;
1112  template class HERMES_API DefaultJacobianAdvection<double>;
1113  template class HERMES_API DefaultJacobianAdvection<std::complex<double> >;
1114  template class HERMES_API DefaultResidualDiffusion<double>;
1115  template class HERMES_API DefaultResidualDiffusion<std::complex<double> >;
1116  template class HERMES_API DefaultMatrixFormSurf<double>;
1117  template class HERMES_API DefaultMatrixFormSurf<std::complex<double> >;
1118  template class HERMES_API DefaultVectorFormSurf<double>;
1119  template class HERMES_API DefaultVectorFormSurf<std::complex<double> >;
1120  template class HERMES_API DefaultVectorFormVol<double>;
1121  template class HERMES_API DefaultVectorFormVol<std::complex<double> >;
1122  template class HERMES_API DefaultJacobianFormSurf<double>;
1123  template class HERMES_API DefaultJacobianFormSurf<std::complex<double> >;
1124  template class HERMES_API DefaultWeakFormLaplace<double>;
1125  template class HERMES_API DefaultWeakFormLaplace<std::complex<double> >;
1126  template class HERMES_API DefaultWeakFormPoisson<double>;
1127  template class HERMES_API DefaultWeakFormPoisson<std::complex<double> >;
1128  template class HERMES_API DefaultResidualSurf<double>;
1129  template class HERMES_API DefaultResidualSurf<std::complex<double> >;
1130  template class HERMES_API DefaultResidualVol<double>;
1131  template class HERMES_API DefaultResidualVol<std::complex<double> >;
1132  };
1133  }
1134 }