1 /* $Header: /var/cvs/mbdyn/mbdyn/mbdyn-1.0/mbdyn/aero/aerodyn.h,v 1.49 2017/01/12 14:45:58 masarati Exp $ */ 2 /* 3 * MBDyn (C) is a multibody analysis code. 4 * http://www.mbdyn.org 5 * 6 * Copyright (C) 1996-2017 7 * 8 * Pierangelo Masarati <masarati@aero.polimi.it> 9 * Paolo Mantegazza <mantegazza@aero.polimi.it> 10 * 11 * Dipartimento di Ingegneria Aerospaziale - Politecnico di Milano 12 * via La Masa, 34 - 20156 Milano, Italy 13 * http://www.aero.polimi.it 14 * 15 * Changing this copyright notice is forbidden. 16 * 17 * This program is free software; you can redistribute it and/or modify 18 * it under the terms of the GNU General Public License as published by 19 * the Free Software Foundation (version 2 of the License). 20 * 21 * 22 * This program is distributed in the hope that it will be useful, 23 * but WITHOUT ANY WARRANTY; without even the implied warranty of 24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 25 * GNU General Public License for more details. 26 * 27 * You should have received a copy of the GNU General Public License 28 * along with this program; if not, write to the Free Software 29 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 30 */ 31 32 /* Elementi aerodinamici 33 * 34 * - Proprieta' dell'aria: 35 * elemento unico, contiene: 36 * - direzione e modulo del vento relativo. Il modulo e' associato 37 * ad un driver che ne consente la variazione, per consentire la 38 * simulazione di un transitorio di galleria. 39 * Verra' aggiunta una variazione della direzione per simulare la raffica. 40 * - densita' dell'aria 41 * - celerita' del suono 42 * - ... 43 * 44 * - Elemento di rotore: 45 * classe virtuale che possiede alcuni dati topologici e geometrici di rotore 46 * ed i metodi per calcolare grandezze utili agli elementi aerodinamici che 47 * fanno parte di un rotore 48 * 49 * - Elemento aerodinamico: 50 * stazionario o quasi-stazionario, con metodo p-k di ordine 0, 1 o 2, 51 * associato ad un corpo rigido, basato sulla strip theory. 52 * 53 * - Elemento aerodinamico: 54 * analogo al precedente, ma associato alla trave a Volumi Finiti a tre nodi 55 * 56 * - Elemento aerodinamico instazionario: 57 * in fase di sviluppo, modella dinamicamente alcuni stati a dare 58 * il comportamento instazionario di una superficie aerodinamica 59 * modellata con la strip theory 60 * 61 * - Elemento Aerodinamico modale: 62 * in fase di sviluppo, contiene una rappresentazione agli stati delle forze 63 * aerodinamiche generalizzate associate ai modi di vibrare e alle raffiche 64 * deve essere associato ad un elemento modale su cui il modello si appoggia. 65 * 66 * -Elemento aerodinamico external: 67 * in fase di sviluppo, elemento che permette di svolgere simulazioni 68 * integrate di interazioni fluido-struttura interfacciando MBDyn con 69 * codici aerodynamici esterni. L'elemento manda all'esterno le informazioni 70 * riguardo alla posizione dei nodi associati e ottiene i carichi che il codice 71 * aerodinamico esterno genera 72 * 73 * 74 */ 75 76 #ifndef AERODYN_H 77 #define AERODYN_H 78 79 #include "elem.h" 80 #include "tpldrive.h" 81 #include "rbk.h" 82 #include "gust.h" 83 84 extern const char* psAeroNames[]; 85 86 /* AirProperties - begin */ 87 88 class AirProperties 89 : virtual public Elem, public InitialAssemblyElem, public TplDriveOwner<Vec3> { 90 protected: 91 mutable Vec3 Velocity; 92 std::vector<const Gust *> gust; 93 94 // rigid body kinematics 95 const RigidBodyKinematics *pRBK; 96 97 public: 98 AirProperties(const TplDriveCaller<Vec3>* pDC, 99 std::vector<const Gust *>& pg, 100 const RigidBodyKinematics *pRBK, 101 flag fOut); 102 virtual ~AirProperties(void); 103 104 virtual void AddGust(const Gust *pG); 105 106 /* Scrive il contributo dell'elemento al file di restart */ 107 virtual std::ostream& Restart(std::ostream& out) const; 108 109 /* Tipo dell'elemento (usato per debug ecc.) */ GetElemType(void)110 virtual Elem::Type GetElemType(void) const { 111 return Elem::AIRPROPERTIES; 112 }; 113 114 /* funzioni di servizio */ 115 116 /* Il metodo iGetNumDof() serve a ritornare il numero di gradi di liberta' 117 * propri che l'elemento definisce. Non e' virtuale in quanto serve a 118 * ritornare 0 per gli elementi che non possiedono gradi di liberta'. 119 * Viene usato nella costruzione dei DofOwner e quindi deve essere 120 * indipendente da essi. In genere non comporta overhead in quanto il 121 * numero di dof aggiunti da un tipo e' una costante e non richede dati 122 * propri. 123 * Il metodo pGetDofOwner() ritorna il puntatore al DofOwner dell'oggetto. 124 * E' usato da tutti quelli che agiscono direttamente sui DofOwner. 125 * Non e' virtuale in quanto ritorna NULL per tutti i tipi che non hanno 126 * dof propri. 127 * Il metodo GetDofType() ritorna, per ogni dof dell'elemento, l'ordine. 128 * E' usato per completare i singoli Dof relativi all'elemento. 129 */ 130 131 /* funzioni proprie */ 132 133 /* Dimensioni del workspace */ 134 virtual void 135 WorkSpaceDim(integer* piNumRows, integer* piNumCols) const; 136 137 /* assemblaggio jacobiano */ 138 virtual VariableSubMatrixHandler& 139 AssJac(VariableSubMatrixHandler& WorkMat, doublereal /* dCoef */ , 140 const VectorHandler& /* XCurr */ , 141 const VectorHandler& /* XPrimeCurr */ ); 142 143 /* assemblaggio residuo */ 144 virtual SubVectorHandler& 145 AssRes(SubVectorHandler& WorkVec, doublereal /* dCoef */ , 146 const VectorHandler& /* XCurr */ , 147 const VectorHandler& /* XPrimeCurr */ ); 148 149 /* Numero di GDL iniziali */ 150 virtual unsigned int iGetInitialNumDof(void) const; 151 152 /* Dimensioni initiali del workspace */ 153 virtual void 154 InitialWorkSpaceDim(integer* piNumRows, integer* piNumCols) const; 155 156 /* assemblaggio jacobiano */ 157 virtual VariableSubMatrixHandler& 158 InitialAssJac(VariableSubMatrixHandler& WorkMat, 159 const VectorHandler& /* XCurr */ ); 160 161 /* assemblaggio residuo */ 162 virtual SubVectorHandler& 163 InitialAssRes(SubVectorHandler& WorkVec, const VectorHandler& XCurr); 164 165 virtual void Output(OutputHandler&) const; 166 167 /* 168 * Deprecated; use GetAirProps instead 169 */ 170 virtual Vec3 GetVelocity(const Vec3& /* X */ ) const; 171 virtual bool GetVelocity(const Vec3& /* X */ , Vec3& V) const; 172 virtual doublereal dGetAirDensity(const Vec3& /* X */ ) const = 0; 173 virtual doublereal dGetAirPressure(const Vec3& /* X */ ) const = 0; 174 virtual doublereal dGetAirTemperature(const Vec3& /* X */ ) const = 0; 175 virtual doublereal dGetSoundSpeed(const Vec3& /* X */ ) const = 0; 176 177 /* 178 * End of deprecated; use GetAirProps instead 179 */ 180 181 virtual bool 182 GetAirProps(const Vec3& X, doublereal& rho, doublereal& c, 183 doublereal& p, doublereal& T) const = 0; 184 185 /* *******PER IL SOLUTORE BLOCK JACOBI-BROYDEN******** */ 186 /* Fornisce il tipo e la label dei nodi che sono connessi all'elemento 187 * utile per l'assemblaggio della matrice di connessione fra i dofs */ GetNumConnectedNodes(void)188 virtual int GetNumConnectedNodes(void) const { 189 return 0; 190 }; 191 192 /* Dati privati */ 193 virtual unsigned int iGetNumPrivData(void) const; 194 virtual unsigned int iGetPrivDataIdx(const char *s) const; 195 virtual doublereal dGetPrivData(unsigned int i) const; 196 }; 197 198 class DataManager; 199 200 extern Elem * 201 ReadAirProperties(DataManager* pDM, MBDynParser& HP); 202 203 /* AirProperties - end */ 204 205 206 /* AirPropOwner - begin */ 207 208 class AirPropOwner { 209 protected: 210 const AirProperties* pAirProperties; 211 public: 212 AirPropOwner(void); 213 virtual ~AirPropOwner(void); 214 215 virtual void PutAirProperties(const AirProperties* pAP); 216 217 /* 218 * Deprecated; use GetAirProps instead 219 */ 220 virtual flag fGetAirVelocity(Vec3& Velocity, const Vec3& X) const; 221 virtual doublereal dGetAirDensity(const Vec3& X) const; 222 virtual doublereal dGetAirPressure(const Vec3& X) const; 223 virtual doublereal dGetAirTemperature(const Vec3& X) const; 224 virtual doublereal dGetSoundSpeed(const Vec3& X) const; 225 226 /* 227 * End of deprecated; use GetAirProps instead 228 */ 229 230 virtual bool 231 GetAirProps(const Vec3& X, doublereal& rho, doublereal& c, 232 doublereal& p, doublereal& T) const; 233 }; 234 235 /* AirPropOwner - end */ 236 237 238 /* AerodynamicElem - begin */ 239 240 class AerodynamicElem : 241 virtual public Elem, 242 public ElemWithDofs, 243 public AirPropOwner 244 { 245 public: 246 /* Tipi di elementi aerodinamici */ 247 enum Type { 248 UNKNOWN = -1, 249 250 INDUCEDVELOCITY = 0, 251 AEROMODAL, 252 AERODYNAMICBODY, 253 AERODYNAMICBEAM, 254 AERODYNAMICEXTERNAL, 255 AERODYNAMICEXTERNALMODAL, 256 AERODYNAMICLOADABLE, 257 AIRCRAFTINSTRUMENTS, 258 GENERICFORCE, 259 260 LASTAEROTYPE 261 }; 262 263 protected: 264 265 public: 266 AerodynamicElem(unsigned int uL, const DofOwner *pDO, flag fOut); 267 virtual ~AerodynamicElem(void); 268 269 /* Tipo di elemento aerodinamico */ 270 virtual AerodynamicElem::Type GetAerodynamicElemType(void) const = 0; 271 272 virtual bool NeedsAirProperties(void) const; 273 virtual const InducedVelocity *pGetInducedVelocity(void) const; 274 }; 275 276 /* AerodynamicElem - end */ 277 278 #endif // AERODYN_H 279 280