← Back to branch summary

~ubuntu-branches/ubuntu/trusty/rheolef/trusty

« back to all changes in this revision

Viewing changes to nfem/basis/basis_symbolic_hermite_cxx.cc

  • Committer: Package Import Robot
  • Author(s): Pierre Saramito
  • Date: 2012-04-06 09:12:21 UTC
  • mfrom: (1.1.5)
  • Revision ID: package-import@ubuntu.com-20120406091221-m58me99p1nxqui49
Tags: 6.0-1
http://bugs.debian.org/667356
http://bugs.debian.org/661689
* New upstream release 6.0 (major changes):
  - massively distributed and parallel support
  - full FEM characteristic method (Lagrange-Gakerkin method) support
  - enhanced users documentation 
  - source code supports g++-4.7 (closes: #667356)
* debian/control: dependencies for MPI distributed solvers added
* debian/rules: build commands simplified
* debian/librheolef-dev.install: man1/* to man9/* added
* debian/changelog: package description rewritted (closes: #661689)

Show diffs side-by-side

added added

removed removed

Lines of Context:
nfem/basis/basis_symbolic_hermite_cxx.cc
77
77
      << "  static point grad_eval(" << endl
78
78
      << "    size_type    i_dof_local," << endl
79
79
      << "    const point& hat_x);" << endl
80
 
      << "  static basic_point<point> hessian_eval(" << endl
 
80
      << "  static tensor hessian_eval(" << endl
81
81
      << "    size_type    i_dof_local," << endl
82
82
      << "    const point& hat_x);" << endl
83
83
      << "  static void eval(" << endl
88
88
      << "    vector<point>& values);" << endl
89
89
      << "  static void hessian_eval(" << endl
90
90
      << "    const point&   hat_x," << endl
91
 
      << "    vector<basic_point<point> >& values);" << endl
 
91
      << "    vector<tensor >& values);" << endl
92
92
      << "  static void hat_node(" << endl
93
93
      << "    vector<point>& hat_node);" << endl
94
94
      << "};" << endl;
118
118
  }
119
119
  out << "    default : {" << endl
120
120
      << "      error_macro (\"dof_family: invalid i_dof_local = \" << i_dof_local);" << endl
121
 
      << "      return reference_element::dof_family_max;" << endl
 
121
      << "      return element_constant::dof_family_max;" << endl
122
122
      << "    }" << endl
123
123
      << "  }" << endl
124
124
      << "}" << endl; 
179
179
  // --------------------------------------------------
180
180
  // hessian_eval
181
181
  // --------------------------------------------------
182
 
  out << "basic_point<point>" << endl
 
182
  out << "tensor" << endl
183
183
      << class_name.str() << "::hessian_eval(" << endl
184
184
      << "  size_type    i_dof_local," << endl
185
185
      << "  const point& hat_x)" << endl
186
186
      << "{" << endl
187
187
      << "  typedef Float T;" << endl
188
 
      << "  point ini_p(0);" << endl
189
 
      << "  basic_point<point> val(ini_p,ini_p,ini_p);" << endl
 
188
      << "  tensor val(0.);" << endl
190
189
      << "  switch (i_dof_local) {" << endl;
191
190
  for (size_type i = 0; i < _basis.size(); i++) {
192
191
    out << "    case " << i << ": {" << endl;
193
192
    for (size_type j = 0; j < d; j++) 
194
193
    for (size_type k = 0; k < d; k++) {
195
194
        ex expr = indexed_symbol(_hessian_basis[i][j][k]);
196
 
        out << "      val[" << j << "][" << k << "] = ";
 
195
        out << "      val(" << j << "," << k << ") = ";
197
196
        expr.print(print_csrc_double(cout));
198
197
        out << ";" << endl;
199
198
    }
249
248
  out << "void" << endl
250
249
      << class_name.str() << "::hessian_eval(" << endl
251
250
      << "  const point&   hat_x," << endl
252
 
      << "  vector<basic_point<point> >& values)" << endl
 
251
      << "  vector<tensor >& values)" << endl
253
252
      << "{" << endl
254
 
      << "  point ini_p(0);" << endl
255
 
      << "  basic_point<point> ini_val(ini_p,ini_p,ini_p);" << endl
 
253
      << "  tensor ini_val(0.);" << endl
256
254
      << "  values.resize(" << _basis.size() << ",ini_val);" << endl
257
255
      << "  typedef Float T;" << endl;
258
256
  for (size_type i = 0; i < _basis.size(); i++) {
259
257
    for (size_type j = 0; j < d; j++) 
260
258
    for (size_type k = 0; k < d; k++) {
261
259
      ex expr = indexed_symbol(_hessian_basis[i][j][k]);
262
 
      out << "  values[" << i << "][" << j << "][" << k << "] = ";
 
260
      out << "  values[" << i << "](" << j << "," << k << ") = ";
263
261
      expr.print(print_csrc_double(cout));
264
262
      out << ";" << endl;
265
263
    }
299
297
    out << "#ifndef _RHEOLEF_" << name() << "_H" << endl
300
298
        << "#define _RHEOLEF_" << name() << "_H" << endl
301
299
        << "#include \"rheolef/basis.h\"" << endl
 
300
        << "#include \"rheolef/tensor.h\"" << endl
302
301
        << "namespace rheolef {" << endl
303
302
        << endl
304
303
        << "class " << class_name.str() << ": public basis_rep {" << endl
305
304
        << "public:" << endl
306
305
        << "  typedef size_t size_type;" << endl
307
 
        << "  " << class_name.str() << "() : basis_rep(reference_element::Hermite) {}" << endl
 
306
        << "  " << class_name.str() << "() : basis_rep(\"" << name() << "\", element_constant::Hermite) {}" << endl
308
307
        << "  ~" << class_name.str() << "();" << endl
309
308
        << "  size_type degree () const;" << endl
310
309
        << "  size_type size (" << endl
320
319
        << "    reference_element hat_K," << endl
321
320
        << "    size_type         i_dof_local," << endl
322
321
        << "    const point&      hat_x) const;" << endl
323
 
        << "  basic_point<point> hessian_eval(" << endl
 
322
        << "  tensor hessian_eval(" << endl
324
323
        << "    reference_element hat_K," << endl
325
324
        << "    size_type         i_dof_local," << endl
326
325
        << "    const point&      hat_x) const;" << endl
335
334
        << "  void hessian_eval(" << endl
336
335
        << "    reference_element hat_K," << endl
337
336
        << "    const point&      hat_x," << endl
338
 
        << "    std::vector<basic_point<point> >&    values) const;" << endl
 
337
        << "    std::vector<tensor >&    values) const;" << endl
339
338
        << "  void hat_node(" << endl
340
339
        << "    reference_element hat_K," << endl
341
340
        << "    std::vector<point>&    hat_node) const;" << endl
352
351
    out << "#include \"" << name() << ".h\"" << endl;
353
352
    out << "using namespace rheolef;" << endl;
354
353
    out << "using namespace std;" << endl;
355
 
    for (size_type i = 0; i < reference_element::max_size; i++) {
 
354
    for (size_type i = 0; i < reference_element::max_variant; i++) {
356
355
      operator[](i).put_cxx_header(out);
357
356
    }
358
 
    for (size_type i = 0; i < reference_element::max_size; i++) {
 
357
    for (size_type i = 0; i < reference_element::max_variant; i++) {
359
358
      operator[](i).put_cxx_body(out);
360
359
    }
361
360
    stringstream class_name;
382
381
        << class_name.str() << "::size (" << endl
383
382
        << "    reference_element hat_K, basis_rep::dof_family_type family) const" << endl
384
383
        << "{" << endl
385
 
        << "    if (family==reference_element::dof_family_max)" << endl
386
 
        << "    switch (hat_K.type()) {" << endl;
387
 
    for (size_type i = 0; i < reference_element::max_size; i++) {
 
384
        << "    if (family == element_constant::dof_family_max)" << endl
 
385
        << "    switch (hat_K.variant()) {" << endl;
 
386
    for (size_type i = 0; i < reference_element::max_variant; i++) {
388
387
      const basis_symbolic_hermite_on_geo& b = operator[](i);
389
388
      if (b.size() == 0) continue;
390
389
      out << "      case reference_element::" << b.hat_K().name() << ": {" << endl
396
395
        << "        return 0;" << endl
397
396
        << "      }" << endl
398
397
        << "    }" << endl
399
 
        << "   else if (family==reference_element::Lagrange)" << endl 
400
 
        << "    switch (hat_K.type()) {" << endl;
401
 
    for (size_type i = 0; i < reference_element::max_size; i++) {
 
398
        << "   else if (family == element_constant::Lagrange)" << endl 
 
399
        << "    switch (hat_K.variant()) {" << endl;
 
400
    for (size_type i = 0; i < reference_element::max_variant; i++) {
402
401
      const basis_symbolic_hermite_on_geo& b = operator[](i);
403
402
      if (b.size() == 0) continue;
404
403
      out << "      case reference_element::" << b.hat_K().name() << ": {" << endl
405
 
          << "        return " << b.size_family(reference_element::Lagrange) << ";" << endl
 
404
          << "        return " << b.size_family(element_constant::Lagrange) << ";" << endl
406
405
          << "      }" << endl;
407
406
    }
408
407
    out << "      default : {" << endl
410
409
        << "        return 0;" << endl
411
410
        << "      }" << endl
412
411
        << "    }" << endl      
413
 
        << "   else if (family==reference_element::Hermite)" << endl 
414
 
        << "    switch (hat_K.type()) {" << endl;
415
 
    for (size_type i = 0; i < reference_element::max_size; i++) {
 
412
        << "   else if (family == element_constant::Hermite)" << endl 
 
413
        << "    switch (hat_K.variant()) {" << endl;
 
414
    for (size_type i = 0; i < reference_element::max_variant; i++) {
416
415
      const basis_symbolic_hermite_on_geo& b = operator[](i);
417
416
      if (b.size() == 0) continue;
418
417
      out << "      case reference_element::" << b.hat_K().name() << ": {" << endl
419
 
          << "        return " << b.size_family(reference_element::Hermite) << ";" << endl
 
418
          << "        return " << b.size_family(element_constant::Hermite) << ";" << endl
420
419
          << "      }" << endl;
421
420
    }
422
421
    out << "      default : {" << endl
436
435
        << "    reference_element hat_K," << endl
437
436
        << "    size_type         i_dof_local) const" << endl
438
437
        << "{" << endl
439
 
        << "    switch (hat_K.type()) {" << endl;
440
 
    for (size_type i = 0; i < reference_element::max_size; i++) {
 
438
        << "    switch (hat_K.variant()) {" << endl;
 
439
    for (size_type i = 0; i < reference_element::max_variant; i++) {
441
440
      const basis_symbolic_hermite_on_geo& b = operator[](i);
442
441
      if (b.size() == 0) continue;
443
442
      out << "      case reference_element::" << b.hat_K().name() << ": {" << endl
446
445
    }
447
446
    out << "      default : {" << endl
448
447
        << "        error_macro (\"eval: unsupported `\" << hat_K.name() << \"' element type\");" << endl
449
 
        << "        return reference_element::dof_family_max;" << endl
 
448
        << "        return element_constant::dof_family_max;" << endl
450
449
        << "      }" << endl
451
450
        << "    }" << endl
452
451
        << "}" << endl;
459
458
        << "    size_type         i_dof_local," << endl
460
459
        << "    const point&      hat_x) const" << endl
461
460
        << "{" << endl
462
 
        << "    switch (hat_K.type()) {" << endl;
463
 
    for (size_type i = 0; i < reference_element::max_size; i++) {
 
461
        << "    switch (hat_K.variant()) {" << endl;
 
462
    for (size_type i = 0; i < reference_element::max_variant; i++) {
464
463
      const basis_symbolic_hermite_on_geo& b = operator[](i);
465
464
      if (b.size() == 0) continue;
466
465
      out << "      case reference_element::" << b.hat_K().name() << ": {" << endl
482
481
        << "    size_type         i_dof_local," << endl
483
482
        << "    const point&      hat_x) const" << endl
484
483
        << "{" << endl
485
 
        << "    switch (hat_K.type()) {" << endl;
486
 
    for (size_type i = 0; i < reference_element::max_size; i++) {
 
484
        << "    switch (hat_K.variant()) {" << endl;
 
485
    for (size_type i = 0; i < reference_element::max_variant; i++) {
487
486
      const basis_symbolic_hermite_on_geo& b = operator[](i);
488
487
      if (b.size() == 0) continue;
489
488
      out << "      case reference_element::" << b.hat_K().name() << ": {" << endl
499
498
     // --------------------------------------------------
500
499
    // hessian_eval
501
500
    // --------------------------------------------------
502
 
    out << "basic_point<point>" << endl
 
501
    out << "tensor" << endl
503
502
        << class_name.str() << "::hessian_eval(" << endl
504
503
        << "    reference_element hat_K," << endl
505
504
        << "    size_type         i_dof_local," << endl
506
505
        << "    const point&      hat_x) const" << endl
507
506
        << "{" << endl
508
 
        << "    switch (hat_K.type()) {" << endl;
509
 
    for (size_type i = 0; i < reference_element::max_size; i++) {
 
507
        << "    switch (hat_K.variant()) {" << endl;
 
508
    for (size_type i = 0; i < reference_element::max_variant; i++) {
510
509
      const basis_symbolic_hermite_on_geo& b = operator[](i);
511
510
      if (b.size() == 0) continue;
512
511
      out << "      case reference_element::" << b.hat_K().name() << ": {" << endl
515
514
    }
516
515
    out << "      default : {" << endl
517
516
        << "        error_macro (\"hessian_eval: unsupported `\" << hat_K.name() << \"' element type\");" << endl
518
 
        << "        point ini_p(0);" << endl
519
 
        << "        basic_point<point> ini_val(ini_p,ini_p,ini_p);" << endl
520
 
        << "        return ini_val;" << endl
 
517
        << "        return tensor(0.);" << endl
521
518
        << "      }" << endl
522
519
        << "    }" << endl
523
520
        << "}" << endl;
530
527
        << "    const point&      hat_x," << endl
531
528
        << "    vector<Float>&    values) const" << endl
532
529
        << "{" << endl
533
 
        << "    switch (hat_K.type()) {" << endl;
534
 
    for (size_type i = 0; i < reference_element::max_size; i++) {
 
530
        << "    switch (hat_K.variant()) {" << endl;
 
531
    for (size_type i = 0; i < reference_element::max_variant; i++) {
535
532
      const basis_symbolic_hermite_on_geo& b = operator[](i);
536
533
      if (b.size() == 0) continue;
537
534
      out << "      case reference_element::" << b.hat_K().name() << ": {" << endl
552
549
        << "    const point&      hat_x," << endl
553
550
        << "    vector<point>&    values) const" << endl
554
551
        << "{" << endl
555
 
        << "    switch (hat_K.type()) {" << endl;
556
 
    for (size_type i = 0; i < reference_element::max_size; i++) {
 
552
        << "    switch (hat_K.variant()) {" << endl;
 
553
    for (size_type i = 0; i < reference_element::max_variant; i++) {
557
554
      const basis_symbolic_hermite_on_geo& b = operator[](i);
558
555
      if (b.size() == 0) continue;
559
556
      out << "      case reference_element::" << b.hat_K().name() << ": {" << endl
572
569
        << class_name.str() << "::hessian_eval(" << endl
573
570
        << "    reference_element hat_K," << endl
574
571
        << "    const point&      hat_x," << endl
575
 
        << "    vector<basic_point<point> >&    values) const" << endl
 
572
        << "    vector<tensor >&    values) const" << endl
576
573
        << "{" << endl
577
 
        << "    switch (hat_K.type()) {" << endl;
578
 
    for (size_type i = 0; i < reference_element::max_size; i++) {
 
574
        << "    switch (hat_K.variant()) {" << endl;
 
575
    for (size_type i = 0; i < reference_element::max_variant; i++) {
579
576
      const basis_symbolic_hermite_on_geo& b = operator[](i);
580
577
      if (b.size() == 0) continue;
581
578
      out << "      case reference_element::" << b.hat_K().name() << ": {" << endl
595
592
        << "    reference_element hat_K," << endl
596
593
        << "    vector<point>&    hat_node) const" << endl
597
594
        << "{" << endl
598
 
        << "    switch (hat_K.type()) {" << endl;
599
 
    for (size_type i = 0; i < reference_element::max_size; i++) {
 
595
        << "    switch (hat_K.variant()) {" << endl;
 
596
    for (size_type i = 0; i < reference_element::max_variant; i++) {
600
597
      const basis_symbolic_hermite_on_geo& b = operator[](i);
601
598
      if (b.size() == 0) continue;
602
599
      out << "      case reference_element::" << b.hat_K().name() << ": {" << endl