MBDyn-1.7.3
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups
Functions | Variables
rotor.cc File Reference
#include "mbconfig.h"
#include <limits>
#include <cmath>
#include "rotor.h"
#include "dataman.h"
Include dependency graph for rotor.cc:

Go to the source code of this file.

Functions

Elem * ReadRotor (DataManager *pDM, MBDynParser &HP, const DofOwner *pDO, unsigned int uLabel)
 

Variables

static const doublereal dVTipTreshold = 1e-6
 
static const doublereal dM11 = 128./(75.*M_PI)
 
static const doublereal dM22 = -16./(45.*M_PI)
 
static const doublereal dM33 = -16./(45.*M_PI)
 

Function Documentation

Elem* ReadRotor ( DataManager *  pDM,
MBDynParser &  HP,
const DofOwner *  pDO,
unsigned int  uLabel 
)

Definition at line 2573 of file rotor.cc.

References ASSERT, ASSERTMSG, GlauertRotor::COLEMAN_ET_AL, DEBUGCOUT, GlauertRotor::DREES_1, GlauertRotor::DREES_2, Eye3, DataManager::fReadOutput(), MBDynParser::GetDriveCaller(), HighParser::GetInt(), IncludeParser::GetLineData(), HighParser::GetReal(), MBDynParser::GetRotRel(), HighParser::GetWord(), GlauertRotor::GLAUERT, GlauertRotor::HOWLETT, Elem::INDUCEDVELOCITY, INDUCEDVELOCITY, HighParser::IsArg(), HighParser::IsKeyWord(), LASTKEYWORD, MBDYN_EXCEPT_ARGS, GlauertRotor::PAYNE, GlauertRotor::PITT_AND_PETERS, DataManager::ReadNode(), ReadResSets(), SAFENEW, SAFENEWWITHCONSTRUCTOR, Node::STRUCTURAL, and GlauertRotor::WHITE_AND_BLAKE.

Referenced by DataManager::ReadOneElem().

2577 {
2578  DEBUGCOUT("Entering ReadRotor()" << std::endl);
2579 
2580  /* demote to pedantic; syntax changed a long ago... */
2581  pedantic_cout("WARNING: the syntax changed; use a comma ',' "
2582  "instead of a colon ':' after the keyword "
2583  "\"induced velocity\"" << std::endl);
2584 
2585  const char* sKeyWords[] = {
2586  "induced" "velocity",
2587  "no",
2588  "uniform",
2589  "uniform" "sectional",
2590  "glauert",
2591  "mangler",
2592  "dynamic" "inflow",
2593 
2594  NULL
2595  };
2596 
2597  /* enum delle parole chiave */
2598  enum KeyWords {
2599  UNKNOWN = -1,
2600  INDUCEDVELOCITY = 0,
2601  NO,
2602  UNIFORM,
2603  UNIFORM_SECTIONAL,
2604  GLAUERT,
2605  MANGLER,
2606  DYNAMICINFLOW,
2607  PETERS_HE,
2608 
2609  LASTKEYWORD
2610  };
2611 
2612  /* tabella delle parole chiave */
2613  KeyTable K(HP, sKeyWords);
2614 
2615  /* aircraft node */
2616  const StructNode* pCraft = pDM->ReadNode<const StructNode, Node::STRUCTURAL>(HP);
2617 
2618  /* rotor orientation with respect to aircraft */
2619  Mat3x3 rrot(Eye3);
2620  if (HP.IsKeyWord("orientation")) {
2621  ReferenceFrame RF(pCraft);
2622  rrot = HP.GetRotRel(RF);
2623 
2624  } else if (HP.IsKeyWord("hinge")) {
2625  silent_cerr("InducedVelocity(" << uLabel << "): deprecated keyword \"hinge\"; use \"orientation\" instead at line " << HP.GetLineData() << std::endl);
2626 
2627  ReferenceFrame RF(pCraft);
2628  rrot = HP.GetRotRel(RF);
2629  }
2630 
2631  /* rotor node */
2632  const StructNode* pRotor = pDM->ReadNode<const StructNode, Node::STRUCTURAL>(HP);
2633 
2634  KeyWords InducedType = NO;
2635  if (HP.IsArg() && HP.IsKeyWord("induced" "velocity")) {
2636  InducedType = KeyWords(HP.GetWord());
2637  }
2638 
2639  Elem* pEl = 0;
2640  ResForceSet **ppres = 0;
2641 
2642  switch (InducedType) {
2643  case NO: {
2644  DEBUGCOUT("No induced velocity is considered" << std::endl);
2645 
2646  doublereal dR = 0.;
2647  if (HP.IsKeyWord("radius")) {
2648  dR = HP.GetReal();
2649  if (dR <= 0) {
2650  silent_cerr("Rotor(" << uLabel << "): "
2651  "invalid radius " << dR
2652  << " at line " << HP.GetLineData()
2653  << std::endl);
2654  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2655  }
2656  }
2657 
2658  ppres = ReadResSets(pDM, HP);
2659 
2660  flag fOut = pDM->fReadOutput(HP, Elem::INDUCEDVELOCITY);
2661 
2662  SAFENEWWITHCONSTRUCTOR(pEl,
2663  NoRotor,
2664  NoRotor(uLabel, pDO, pCraft, rrot, pRotor,
2665  ppres, dR, fOut));
2666  } break;
2667 
2668  case UNIFORM:
2669  case UNIFORM_SECTIONAL:
2670  case GLAUERT:
2671  case MANGLER:
2672  case DYNAMICINFLOW: {
2673  GlauertRotor::Type gtype(GlauertRotor::GLAUERT);
2674  if (InducedType == GLAUERT && HP.IsKeyWord("type")) {
2675  if (HP.IsKeyWord("glauert")) {
2676  gtype = GlauertRotor::GLAUERT;
2677 
2678  } else if (HP.IsKeyWord("coleman")) {
2679  gtype = GlauertRotor::COLEMAN_ET_AL;
2680 
2681  } else if (HP.IsKeyWord("drees")) {
2682  gtype = GlauertRotor::DREES_1;
2683 
2684  } else if (HP.IsKeyWord("payne")) {
2685  gtype = GlauertRotor::PAYNE;
2686 
2687  } else if (HP.IsKeyWord("white" "and" "blake")) {
2688  gtype = GlauertRotor::WHITE_AND_BLAKE;
2689 
2690  } else if (HP.IsKeyWord("pitt" "and" "peters")) {
2691  gtype = GlauertRotor::PITT_AND_PETERS;
2692 
2693  } else if (HP.IsKeyWord("howlett")) {
2694  gtype = GlauertRotor::HOWLETT;
2695 
2696  } else if (HP.IsKeyWord("drees" "2")) {
2697  silent_cerr("warning, \"drees 2\" deprecated at line " << HP.GetLineData() << "; use \"drees\" instead" << std::endl);
2698  gtype = GlauertRotor::DREES_2;
2699 
2700  } else {
2701  silent_cerr("Rotor(" << uLabel << "): "
2702  "unknown variant of Glauert's induced velocity at line "
2703  << HP.GetLineData() << std::endl);
2704  throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
2705  }
2706  }
2707 
2708  doublereal dOR = HP.GetReal();
2709  DEBUGCOUT("Reference rotation speed: " << dOR << std::endl);
2710  if (dOR <= 0.) {
2711  silent_cerr("Rotor(" << uLabel << "): "
2712  "invalid reference speed " << dOR
2713  << " at line " << HP.GetLineData()
2714  << std::endl);
2715  throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
2716  }
2717 
2718  doublereal dR = HP.GetReal();
2719  DEBUGCOUT("Radius: " << dR << std::endl);
2720  if (dR <= 0.) {
2721  silent_cerr("Rotor(" << uLabel << "): "
2722  "invalid radius " << dR
2723  << " at line " << HP.GetLineData()
2724  << std::endl);
2725  throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
2726  }
2727 
2728  // optional parameters
2729  bool bGotInitialValues(false);
2730  doublereal dVConst = 0.;
2731  doublereal dVSine = 0.;
2732  doublereal dVCosine = 0.;
2733  DriveCaller *pdW = 0;
2734  const StructNode *pGround = 0;
2735  unsigned iMaxIter = unsigned(-1);
2736  doublereal dTolerance = std::numeric_limits<double>::max();
2737  doublereal dEta = -1.;
2738  doublereal dCH = -1.;
2739  doublereal dCFF = -1.;
2740 
2741  while (HP.IsArg()) {
2742  if (HP.IsKeyWord("ground")) {
2743  /*
2744  * ground node for ground effect modeling
2745  */
2746  if (pGround != 0) {
2747  silent_cerr("Rotor(" << uLabel << "): "
2748  "providing another \"ground\" node "
2749  "at line " << HP.GetLineData()
2750  << std::endl);
2751  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2752  }
2753 
2754  /* ground node */
2755  pGround = pDM->ReadNode<const StructNode, Node::STRUCTURAL>(HP);
2756 
2757  } else if (HP.IsKeyWord("initial" "value")) {
2758  if (InducedType != DYNAMICINFLOW) {
2759  silent_cerr("Rotor(" << uLabel << "): "
2760  "invalid parameter \"initial value\" "
2761  "at line " << HP.GetLineData()
2762  << std::endl);
2763  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2764  }
2765 
2766  if (bGotInitialValues) {
2767  silent_cerr("Rotor(" << uLabel << "): "
2768  "providing \"initial value\" another time "
2769  "at line " << HP.GetLineData()
2770  << std::endl);
2771  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2772  }
2773 
2774  dVConst = HP.GetReal();
2775  dVSine = HP.GetReal();
2776  dVCosine = HP.GetReal();
2777 
2778  bGotInitialValues = true;
2779 
2780  } else if (HP.IsKeyWord("weight") || HP.IsKeyWord("delay")) {
2781  if (InducedType == DYNAMICINFLOW) {
2782  silent_cerr("Rotor(" << uLabel << "): "
2783  "invalid parameter \"delay\" "
2784  "at line " << HP.GetLineData()
2785  << std::endl);
2786  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2787  }
2788 
2789  if (pdW != 0) {
2790  silent_cerr("Rotor(" << uLabel << "): "
2791  "providing another \"delay\" driver "
2792  "at line " << HP.GetLineData()
2793  << std::endl);
2794  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2795  }
2796 
2797  /*
2798  * Legge il coefficiente di peso della velocita'
2799  * indotta ("weight" e' deprecato, si preferisce
2800  * "delay")
2801  *
2802  * nota:
2803  *
2804  * U = U_n * ( 1 - dW ) + U_n-1 * dW
2805  *
2806  * quindi dW rappresenta il peso che si da'
2807  * al valore al passo precedente; in questo modo
2808  * si introduce un ritardo euristico (attenzione:
2809  * il ritardo vero dipende dal passo temporale)
2810  * che aiuta ad evitare problemi di convergenza.
2811  * Se si desidera un ritardo "fisico", conviene
2812  * provare il "Dynamic Inflow".
2813  */
2814  pdW = HP.GetDriveCaller();
2815 
2816  } else if (HP.IsKeyWord("max" "iterations")) {
2817  if (iMaxIter != unsigned(-1)) {
2818  silent_cerr("Rotor(" << uLabel << "): "
2819  "providing another \"max iterations\" value "
2820  "at line " << HP.GetLineData()
2821  << std::endl);
2822  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2823  }
2824 
2825  /* max iterations when computing reference inflow velocity;
2826  * after iMaxIter iterations, the current value is accepted
2827  * regardless of convergence; thus, 1 reproduces original
2828  * behavior */
2829  int i = HP.GetInt();
2830  if (i <= 0) {
2831  silent_cerr("illegal max iterations "
2832  << i << " for Rotor(" << uLabel << ")");
2833  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2834  }
2835  iMaxIter = i;
2836 
2837  } else if (HP.IsKeyWord("tolerance")) {
2838  if (dTolerance != std::numeric_limits<double>::max()) {
2839  silent_cerr("Rotor(" << uLabel << "): "
2840  "providing another \"tolerance\" value "
2841  "at line " << HP.GetLineData()
2842  << std::endl);
2843  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2844  }
2845 
2846  /* tolerance when computing reference inflow velocity;
2847  * when the difference in inflow velocity between two
2848  * iterations is less than tolerance in module, the
2849  * cycle breaks */
2850 
2851  dTolerance = HP.GetReal();
2852  if (dTolerance <= 0.) {
2853  silent_cerr("illegal tolerance "
2854  << dTolerance << " for Rotor(" << uLabel << ")");
2855  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2856  }
2857 
2858  } else if (HP.IsKeyWord("eta")) {
2859  if (dEta != -1.) {
2860  silent_cerr("Rotor(" << uLabel << "): "
2861  "providing another \"eta\" relaxation factor "
2862  "at line " << HP.GetLineData()
2863  << std::endl);
2864  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2865  }
2866 
2867  /* increment factor when computing reference inflow velocity;
2868  * only a fraction dEta of the difference between two iterations
2869  * is applied */
2870 
2871  dEta = HP.GetReal();
2872  if (dEta <= 0.) {
2873  silent_cerr("illegal eta "
2874  << dEta << " for Rotor(" << uLabel << ")");
2875  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2876  }
2877 
2878  } else if (HP.IsKeyWord("correction")) {
2879  if (dCH != -1.) {
2880  silent_cerr("Rotor(" << uLabel << "): "
2881  "providing another \"correction\" factor "
2882  "at line " << HP.GetLineData()
2883  << std::endl);
2884  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2885  }
2886 
2887  /* Legge la correzione della velocita' indotta */
2888  dCH = HP.GetReal();
2889  DEBUGCOUT("Hover correction: " << dCH << std::endl);
2890  if (dCH <= 0.) {
2891  silent_cerr("Rotor(" << uLabel << "): "
2892  "illegal null or negative hover inflow correction "
2893  "at line " << HP.GetLineData()
2894  << std::endl);
2895  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2896  }
2897 
2898  dCFF = HP.GetReal();
2899  DEBUGCOUT("Forward-flight correction: " << dCFF << std::endl);
2900  if (dCFF <= 0.) {
2901  silent_cerr("Rotor(" << uLabel << "): "
2902  "illegal null or negative forward-flight inflow correction "
2903  "at line " << HP.GetLineData()
2904  << std::endl);
2905  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
2906  }
2907 
2908  } else {
2909  break;
2910  }
2911  }
2912 
2913  ppres = ReadResSets(pDM, HP);
2914 
2915  flag fOut = pDM->fReadOutput(HP, Elem::INDUCEDVELOCITY);
2916 
2917  // check consistency and initialize defaults
2918  if (InducedType != DYNAMICINFLOW && pdW == 0) {
2919  SAFENEW(pdW, NullDriveCaller);
2920  }
2921 
2922  if (iMaxIter == unsigned(-1)) {
2923  iMaxIter = 1;
2924 
2925  } else {
2926  if (dTolerance == std::numeric_limits<double>::max()) {
2927  silent_cerr("Rotor(" << uLabel << "): "
2928  "warning, \"max iterations\" is meaningless with default tolerance"
2929  << std::endl);
2930  }
2931  }
2932 
2933  if (dEta == -1.) {
2934  dEta = 1.;
2935  }
2936 
2937  if (dCH == -1.) {
2938  dCH = 1.;
2939  dCFF = 1.;
2940  }
2941 
2942  // create element
2943  switch (InducedType) {
2944  case UNIFORM:
2945  DEBUGCOUT("Uniform induced velocity" << std::endl);
2946  SAFENEWWITHCONSTRUCTOR(pEl,
2947  UniformRotor,
2948  UniformRotor(uLabel, pDO, pCraft, rrot,
2949  pRotor, pGround,
2950  ppres, dOR, dR, pdW,
2951  iMaxIter, dTolerance, dEta,
2952  dCH, dCFF,
2953  fOut));
2954  break;
2955 
2956  case UNIFORM_SECTIONAL:
2957  DEBUGCOUT("Uniform induced velocity" << std::endl);
2958  SAFENEWWITHCONSTRUCTOR(pEl,
2959  UniformRotor2,
2960  UniformRotor2(uLabel, pDO, pCraft, rrot,
2961  pRotor, pGround,
2962  ppres, dOR, dR, pdW,
2963  iMaxIter, dTolerance, dEta,
2964  dCH, dCFF,
2965  fOut));
2966  break;
2967 
2968  case GLAUERT:
2969  DEBUGCOUT("Glauert induced velocity" << std::endl);
2970  SAFENEWWITHCONSTRUCTOR(pEl,
2971  GlauertRotor,
2972  GlauertRotor(uLabel, pDO, pCraft, rrot,
2973  pRotor, pGround,
2974  ppres, dOR, dR, pdW,
2975  iMaxIter, dTolerance, dEta,
2976  dCH, dCFF, gtype,
2977  fOut));
2978  break;
2979 
2980  case MANGLER:
2981  DEBUGCOUT("Mangler induced velocity" << std::endl);
2982 
2983  SAFENEWWITHCONSTRUCTOR(pEl,
2984  ManglerRotor,
2985  ManglerRotor(uLabel, pDO, pCraft, rrot,
2986  pRotor, pGround,
2987  ppres, dOR, dR, pdW,
2988  iMaxIter, dTolerance, dEta,
2989  dCH, dCFF,
2990  fOut));
2991  break;
2992 
2993  case DYNAMICINFLOW:
2994  DEBUGCOUT("Dynamic inflow" << std::endl);
2995 
2996  SAFENEWWITHCONSTRUCTOR(pEl,
2997  DynamicInflowRotor,
2998  DynamicInflowRotor(uLabel, pDO,
2999  pCraft, rrot, pRotor,
3000  pGround, ppres,
3001  dOR, dR,
3002  iMaxIter, dTolerance, dEta,
3003  dCH, dCFF,
3004  dVConst, dVSine, dVCosine,
3005  fOut));
3006  break;
3007 
3008  default:
3009  ASSERTMSG(0, "You shouldn't have reached this point");
3010  throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
3011  }
3012  break;
3013  }
3014 
3015  case PETERS_HE: {
3016  doublereal dOR = HP.GetReal();
3017  DEBUGCOUT("Reference rotation speed: " << dOR << std::endl);
3018  if (dOR <= 0.) {
3019  silent_cerr("Rotor(" << uLabel << "): "
3020  "invalid reference speed " << dOR
3021  << " at line " << HP.GetLineData()
3022  << std::endl);
3023  throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
3024  }
3025 
3026  doublereal dR = HP.GetReal();
3027  DEBUGCOUT("Radius: " << dR << std::endl);
3028  if (dR <= 0.) {
3029  silent_cerr("Rotor(" << uLabel << "): "
3030  "invalid radius " << dR
3031  << " at line " << HP.GetLineData()
3032  << std::endl);
3033  throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
3034  }
3035 
3036  // optional parameters
3037  bool bGotInitialValues(false);
3038  doublereal dVConst = 0.;
3039  doublereal dVSine = 0.;
3040  doublereal dVCosine = 0.;
3041  const StructNode *pGround = 0;
3042  unsigned iMaxIter = unsigned(-1);
3043  doublereal dTolerance = std::numeric_limits<double>::max();
3044  doublereal dEta = -1.;
3045  doublereal dCH = -1.;
3046  doublereal dCFF = -1.;
3047 
3048  while (HP.IsArg()) {
3049  if (HP.IsKeyWord("ground")) {
3050  /*
3051  * ground node for ground effect modeling
3052  */
3053  if (pGround != 0) {
3054  silent_cerr("Rotor(" << uLabel << "): "
3055  "providing another \"ground\" node "
3056  "at line " << HP.GetLineData()
3057  << std::endl);
3058  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
3059  }
3060 
3061  /* ground node */
3062  pGround = pDM->ReadNode<const StructNode, Node::STRUCTURAL>(HP);
3063 
3064  } else if (HP.IsKeyWord("initial" "value")) {
3065  if (bGotInitialValues) {
3066  silent_cerr("Rotor(" << uLabel << "): "
3067  "providing \"initial value\" another time "
3068  "at line " << HP.GetLineData()
3069  << std::endl);
3070  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
3071  }
3072 
3073  dVConst = HP.GetReal();
3074  dVSine = HP.GetReal();
3075  dVCosine = HP.GetReal();
3076 
3077  bGotInitialValues = true;
3078 
3079  } else if (HP.IsKeyWord("max" "iterations")) {
3080  if (iMaxIter != unsigned(-1)) {
3081  silent_cerr("Rotor(" << uLabel << "): "
3082  "providing another \"max iterations\" value "
3083  "at line " << HP.GetLineData()
3084  << std::endl);
3085  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
3086  }
3087 
3088  /* max iterations when computing reference inflow velocity;
3089  * after iMaxIter iterations, the current value is accepted
3090  * regardless of convergence; thus, 1 reproduces original
3091  * behavior */
3092  int i = HP.GetInt();
3093  if (i <= 0) {
3094  silent_cerr("illegal max iterations "
3095  << i << " for Rotor(" << uLabel << ")");
3096  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
3097  }
3098  iMaxIter = i;
3099 
3100  } else if (HP.IsKeyWord("tolerance")) {
3101  if (dTolerance != std::numeric_limits<double>::max()) {
3102  silent_cerr("Rotor(" << uLabel << "): "
3103  "providing another \"tolerance\" value "
3104  "at line " << HP.GetLineData()
3105  << std::endl);
3106  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
3107  }
3108 
3109  /* tolerance when computing reference inflow velocity;
3110  * when the difference in inflow velocity between two
3111  * iterations is less than tolerance in module, the
3112  * cycle breaks */
3113 
3114  dTolerance = HP.GetReal();
3115  if (dTolerance <= 0.) {
3116  silent_cerr("illegal tolerance "
3117  << dTolerance << " for Rotor(" << uLabel << ")");
3118  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
3119  }
3120 
3121  } else if (HP.IsKeyWord("eta")) {
3122  if (dEta != -1.) {
3123  silent_cerr("Rotor(" << uLabel << "): "
3124  "providing another \"eta\" relaxation factor "
3125  "at line " << HP.GetLineData()
3126  << std::endl);
3127  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
3128  }
3129 
3130  /* increment factor when computing reference inflow velocity;
3131  * only a fraction dEta of the difference between two iterations
3132  * is applied */
3133 
3134  dEta = HP.GetReal();
3135  if (dEta <= 0.) {
3136  silent_cerr("illegal eta "
3137  << dEta << " for Rotor(" << uLabel << ")");
3138  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
3139  }
3140 
3141  } else if (HP.IsKeyWord("correction")) {
3142  if (dCH != -1.) {
3143  silent_cerr("Rotor(" << uLabel << "): "
3144  "providing another \"correction\" factor "
3145  "at line " << HP.GetLineData()
3146  << std::endl);
3147  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
3148  }
3149 
3150  /* Legge la correzione della velocita' indotta */
3151  dCH = HP.GetReal();
3152  DEBUGCOUT("Hover correction: " << dCH << std::endl);
3153  if (dCH <= 0.) {
3154  silent_cerr("Rotor(" << uLabel << "): "
3155  "illegal null or negative hover inflow correction "
3156  "at line " << HP.GetLineData()
3157  << std::endl);
3158  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
3159  }
3160 
3161  dCFF = HP.GetReal();
3162  DEBUGCOUT("Forward-flight correction: " << dCFF << std::endl);
3163  if (dCFF <= 0.) {
3164  silent_cerr("Rotor(" << uLabel << "): "
3165  "illegal null or negative forward-flight inflow correction "
3166  "at line " << HP.GetLineData()
3167  << std::endl);
3168  throw ErrGeneric(MBDYN_EXCEPT_ARGS);
3169  }
3170 
3171  } else {
3172  break;
3173  }
3174  }
3175 
3176  ppres = ReadResSets(pDM, HP);
3177 
3178  flag fOut = pDM->fReadOutput(HP, Elem::INDUCEDVELOCITY);
3179 
3180  if (iMaxIter == unsigned(-1)) {
3181  iMaxIter = 1;
3182 
3183  } else {
3184  if (dTolerance == std::numeric_limits<double>::max()) {
3185  silent_cerr("Rotor(" << uLabel << "): "
3186  "warning, \"max iterations\" is meaningless with default tolerance"
3187  << std::endl);
3188  }
3189  }
3190 
3191  if (dEta == -1.) {
3192  dEta = 1.;
3193  }
3194 
3195  if (dCH == -1.) {
3196  dCH = 1.;
3197  dCFF = 1.;
3198  }
3199 
3200  // create element
3201  DEBUGCOUT("Dynamic inflow" << std::endl);
3202 
3203  SAFENEWWITHCONSTRUCTOR(pEl,
3204  PetersHeRotor,
3205  PetersHeRotor(uLabel, pDO,
3206  pCraft, rrot, pRotor,
3207  pGround, ppres,
3208  dOR, dR,
3209  iMaxIter, dTolerance, dEta,
3210  dCH, dCFF,
3211  dVConst, dVSine, dVCosine,
3212  fOut));
3213  break;
3214  }
3215 
3216  default:
3217  silent_cerr("Rotor(" << uLabel << "): "
3218  "unknown induced velocity type at line "
3219  << HP.GetLineData() << std::endl);
3220  throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
3221  }
3222 
3223  /* Se non c'e' il punto e virgola finale */
3224  if (HP.IsArg()) {
3225  silent_cerr("Rotor(" << uLabel << "): "
3226  "semicolon expected at line "
3227  << HP.GetLineData() << std::endl);
3228  throw DataManager::ErrGeneric(MBDYN_EXCEPT_ARGS);
3229  }
3230 
3231  ASSERT(pEl != 0);
3232  return pEl;
3233 } /* End of DataManager::ReadRotor() */
DataManager::fReadOutput
flag fReadOutput(MBDynParser &HP, const T &t) const
Definition: dataman.h:1064
MBDynParser::GetRotRel
Mat3x3 GetRotRel(const ReferenceFrame &rf)
Definition: mbpar.cc:1795
flag
long int flag
Definition: mbdyn.h:43
MBDYN_EXCEPT_ARGS
#define MBDYN_EXCEPT_ARGS
Definition: except.h:63
HighParser::GetInt
virtual integer GetInt(integer iDefval=0)
Definition: parser.cc:1050
ASSERTMSG
#define ASSERTMSG(expr, msg)
Definition: myassert.h:219
Eye3
const Mat3x3 Eye3(1., 0., 0., 0., 1., 0., 0., 0., 1.)
NoRotor
Definition: rotor.h:209
SAFENEW
#define SAFENEW(pnt, item)
Definition: mynewmem.h:695
HighParser::IsKeyWord
virtual bool IsKeyWord(const char *sKeyWord)
Definition: parser.cc:910
DEBUGCOUT
#define DEBUGCOUT(msg)
Definition: myassert.h:232
ASSERT
#define ASSERT(expression)
Definition: colamd.c:977
KeyWords
KeyWords
Definition: dataman4.cc:94
SAFENEWWITHCONSTRUCTOR
#define SAFENEWWITHCONSTRUCTOR(pnt, item, constructor)
Definition: mynewmem.h:698
ReadResSets
ResForceSet ** ReadResSets(DataManager *pDM, MBDynParser &HP)
Definition: resforces.cc:263
HighParser::IsArg
virtual bool IsArg(void)
Definition: parser.cc:807
Elem
Definition: elem.h:75
HighParser::GetWord
virtual int GetWord(void)
Definition: parser.cc:1083
MBDynParser::GetDriveCaller
DriveCaller * GetDriveCaller(bool bDeferred=false)
Definition: mbpar.cc:2033
doublereal
double doublereal
Definition: colamd.c:52
IncludeParser::GetLineData
virtual HighParser::ErrOut GetLineData(void) const
Definition: parsinc.cc:697
DataManager::ReadNode
Node * ReadNode(MBDynParser &HP, Node::Type type) const
Definition: dataman3.cc:2309
HighParser::GetReal
virtual doublereal GetReal(const doublereal &dDefval=0.0)
Definition: parser.cc:1056

Here is the call graph for this function:

Variable Documentation

const doublereal dM11 = 128./(75.*M_PI)
static

Definition at line 1529 of file rotor.cc.

Referenced by DynamicInflowRotor::AssJac(), PetersHeRotor::AssJac(), DynamicInflowRotor::AssRes(), and PetersHeRotor::AssRes().

const doublereal dM22 = -16./(45.*M_PI)
static

Definition at line 1532 of file rotor.cc.

Referenced by DynamicInflowRotor::AssJac(), PetersHeRotor::AssJac(), DynamicInflowRotor::AssRes(), and PetersHeRotor::AssRes().

const doublereal dM33 = -16./(45.*M_PI)
static

Definition at line 1533 of file rotor.cc.

Referenced by DynamicInflowRotor::AssJac(), PetersHeRotor::AssJac(), DynamicInflowRotor::AssRes(), and PetersHeRotor::AssRes().

const doublereal dVTipTreshold = 1e-6
static

Definition at line 55 of file rotor.cc.

Referenced by DynamicInflowRotor::AssRes(), PetersHeRotor::AssRes(), and Rotor::InitParam().