MBDyn-1.7.3
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups
rotor.h File Reference
#include "indvel.h"
Include dependency graph for rotor.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  Rotor
 
class  NoRotor
 
class  UniformRotor
 
class  UniformRotor2
 
class  GlauertRotor
 
class  ManglerRotor
 
class  DynamicInflowRotor
 
class  PetersHeRotor
 

Functions

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

Variables

const char * psRotorNames []
 

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);
2655  }
2656  }
2657 
2658  ppres = ReadResSets(pDM, HP);
2659 
2660  flag fOut = pDM->fReadOutput(HP, Elem::INDUCEDVELOCITY);
2661 
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: {
2674  if (InducedType == GLAUERT && HP.IsKeyWord("type")) {
2675  if (HP.IsKeyWord("glauert")) {
2676  gtype = GlauertRotor::GLAUERT;
2677 
2678  } else if (HP.IsKeyWord("coleman")) {
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")) {
2689 
2690  } else if (HP.IsKeyWord("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);
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);
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);
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);
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);
2764  }
2765 
2766  if (bGotInitialValues) {
2767  silent_cerr("Rotor(" << uLabel << "): "
2768  "providing \"initial value\" another time "
2769  "at line " << HP.GetLineData()
2770  << std::endl);
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);
2787  }
2788 
2789  if (pdW != 0) {
2790  silent_cerr("Rotor(" << uLabel << "): "
2791  "providing another \"delay\" driver "
2792  "at line " << HP.GetLineData()
2793  << std::endl);
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);
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 << ")");
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);
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 << ")");
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);
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 << ")");
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);
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);
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);
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);
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);
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);
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 
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 
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");
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);
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);
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);
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);
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);
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 << ")");
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);
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 << ")");
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);
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 << ")");
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);
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);
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);
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 
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);
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);
3229  }
3230 
3231  ASSERT(pEl != 0);
3232  return pEl;
3233 } /* End of DataManager::ReadRotor() */
flag fReadOutput(MBDynParser &HP, const T &t) const
Definition: dataman.h:1064
Mat3x3 GetRotRel(const ReferenceFrame &rf)
Definition: mbpar.cc:1795
long int flag
Definition: mbdyn.h:43
#define MBDYN_EXCEPT_ARGS
Definition: except.h:63
virtual integer GetInt(integer iDefval=0)
Definition: parser.cc:1050
#define ASSERTMSG(expr, msg)
Definition: myassert.h:219
const Mat3x3 Eye3(1., 0., 0., 0., 1., 0., 0., 0., 1.)
Definition: rotor.h:209
#define SAFENEW(pnt, item)
Definition: mynewmem.h:695
virtual bool IsKeyWord(const char *sKeyWord)
Definition: parser.cc:910
#define DEBUGCOUT(msg)
Definition: myassert.h:232
#define ASSERT(expression)
Definition: colamd.c:977
KeyWords
Definition: dataman4.cc:94
#define SAFENEWWITHCONSTRUCTOR(pnt, item, constructor)
Definition: mynewmem.h:698
ResForceSet ** ReadResSets(DataManager *pDM, MBDynParser &HP)
Definition: resforces.cc:263
virtual bool IsArg(void)
Definition: parser.cc:807
Definition: elem.h:75
virtual int GetWord(void)
Definition: parser.cc:1083
DriveCaller * GetDriveCaller(bool bDeferred=false)
Definition: mbpar.cc:2033
double doublereal
Definition: colamd.c:52
virtual HighParser::ErrOut GetLineData(void) const
Definition: parsinc.cc:697
Node * ReadNode(MBDynParser &HP, Node::Type type) const
Definition: dataman3.cc:2309
virtual doublereal GetReal(const doublereal &dDefval=0.0)
Definition: parser.cc:1056

Here is the call graph for this function:

Variable Documentation

const char* psRotorNames[]

Definition at line 330 of file enums.cc.