numerics_structure.hpp

Go to the documentation of this file.

#pragma once

#include "../../Common/include/mpi_structure.hpp"

#include <cmath>
#include <iostream>
#include <limits>
#include <cstdlib>

#include "../../Common/include/config_structure.hpp"
#include "../../Common/include/gauss_structure.hpp"
#include "../../Common/include/element_structure.hpp"
#include "variable_structure.hpp"

using namespace std;

class CNumerics {
protected:
  unsigned short nDim, nVar;  
  su2double Gamma;        
  su2double Gamma_Minus_One;    
  su2double Gas_Constant;         
  su2double *Vector; 
  su2double *Enthalpy_formation;
  su2double Prandtl_Lam;        
  su2double Prandtl_Turb;    
public:
  
  su2double
  **Flux_Tensor,  
  *Proj_Flux_Tensor;    
  su2double
  **tau,    
  **delta;      
  su2double
  *Diffusion_Coeff_i, 
  *Diffusion_Coeff_j; 
  su2double Laminar_Viscosity_i,  
  Laminar_Viscosity_j,    
  Laminar_Viscosity_id,  
  Laminar_Viscosity_jd;    
  su2double Thermal_Conductivity_i, 
  Thermal_Conductivity_j, 
  Thermal_Conductivity_ve_i, 
  Thermal_Conductivity_ve_j; 
  su2double Cp_i, 
  Cp_j;         
  su2double *Theta_v; 
  su2double Eddy_Viscosity_i,  
  Eddy_Viscosity_j;      
  su2double turb_ke_i,  
  turb_ke_j;      
  su2double Pressure_i,  
  Pressure_j;      
  su2double GravityForce_i,  
  GravityForce_j;      
  su2double Density_i,  
  Density_j;      
  su2double DensityInc_i,  
  DensityInc_j;      
  su2double BetaInc2_i,  
  BetaInc2_j;      
  su2double Lambda_i,  
  Lambda_j;      
  su2double LambdaComb_i,  
  LambdaComb_j;      
  su2double SoundSpeed_i,  
  SoundSpeed_j;      
  su2double Enthalpy_i,  
  Enthalpy_j;      
  su2double dist_i,  
  dist_j;      
  su2double Temp_i,  
  Temp_j;      
  su2double *Temp_tr_i, 
  *Temp_tr_j;
  su2double *Temp_vib_i, 
  *Temp_vib_j;
  su2double *Und_Lapl_i, 
  *Und_Lapl_j;    
  su2double Sensor_i,  
  Sensor_j;      
  su2double *GridVel_i,  
  *GridVel_j;      
  su2double *U_i,    
  *U_id,    
  *UZeroOrder_i,  
  *U_j,        
  *UZeroOrder_j,  
  *U_jd,        
  *U_0,        
  *U_1,        
  *U_2,        
  *U_3;        
  su2double *V_i,    
  *V_j;        
  su2double *S_i,    
  *S_j;        
  su2double *Psi_i,    
  *Psi_j;        
  su2double *DeltaU_i,  
  *DeltaU_j;      
  su2double *TurbVar_i,  
  *TurbVar_id,  
  *TurbVar_j,      
  *TurbVar_jd;  
  su2double *TransVar_i,  
  *TransVar_j;      
  su2double *TurbPsi_i,  
  *TurbPsi_j;      
  su2double **ConsVar_Grad_i,  
  **ConsVar_Grad_j,      
  **ConsVar_Grad_0,      
  **ConsVar_Grad_1,      
  **ConsVar_Grad_2,      
  **ConsVar_Grad_3,      
  **ConsVar_Grad;        
  su2double **PrimVar_Grad_i,  
  **PrimVar_Grad_j;      
  su2double *PrimVar_Lim_i,  
  *PrimVar_Lim_j;      
  su2double *PsiVar_Lim_i,    
  *PsiVar_Lim_j;      
  su2double **PsiVar_Grad_i,    
  **PsiVar_Grad_j;      
  su2double **TurbVar_Grad_i,  
  **TurbVar_Grad_j;      
  su2double **TransVar_Grad_i,  
  **TransVar_Grad_j;      
  su2double **TurbPsi_Grad_i,  
  **TurbPsi_Grad_j;      
  su2double *AuxVar_Grad_i,    
  *AuxVar_Grad_j;        
  su2double *Coord_i,  
  *Coord_j,      
  *Coord_0,      
  *Coord_1,      
  *Coord_2,      
  *Coord_3;      
  unsigned short Neighbor_i,  
  Neighbor_j;          
  su2double *Normal,  
  *UnitNormal,    
  *UnitNormald;    
  su2double TimeStep,    
  Area,        
  Volume;        
  su2double Volume_n,  
  Volume_nM1,    
  Volume_nP1;    
  su2double *U_n,  
  *U_nM1,    
  *U_nP1;    
  su2double vel2_inf; 
  su2double *WindGust_i,  
  *WindGust_j;      
  su2double *WindGustDer_i,  
  *WindGustDer_j;      
  su2double *Vorticity_i, *Vorticity_j;  
  su2double StrainMag_i, StrainMag_j;   
  su2double *l, *m;
  
  CNumerics(void);
  
  CNumerics(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  virtual ~CNumerics(void);
  
  su2double Determinant_3x3(su2double A00, su2double A01, su2double A02,
                            su2double A10, su2double A11, su2double A12,
                            su2double A20, su2double A21, su2double A22);
  
  void SetPastSol(su2double *val_u_nM1, su2double *val_u_n, su2double *val_u_nP1);
  
  void SetPastVolume(su2double val_volume_nM1, su2double val_volume_n, su2double val_volume_nP1);
  
  void SetTimeStep(su2double val_timestep);
  
  virtual su2double GetPrecond_Beta();
  
  void SetVelocity2_Inf(su2double val_velocity2);
  
  void SetVorticity(su2double *val_vorticity_i, su2double *val_vorticity_j);
  
  void SetStrainMag(su2double val_strainmag_i, su2double val_strainmag_j);
  
  void SetConservative(su2double *val_u_i, su2double *val_u_j);
  
  void SetConservative_ZeroOrder(su2double *val_u_i, su2double *val_u_j);
  
  void SetPrimitive(su2double *val_v_i, su2double *val_v_j);
  
  void SetSecondary(su2double *val_s_i, su2double *val_s_j);
  
  void SetConservative(su2double *val_u_0, su2double *val_u_1, su2double *val_u_2);
  
  void SetConservative(su2double *val_u_0, su2double *val_u_1, su2double *val_u_2, su2double *val_u_3);
  
  void SetConsVarGradient(su2double **val_consvar_grad_i, su2double **val_consvar_grad_j);
  
  void SetConsVarGradient(su2double **val_consvar_grad_0,
                          su2double **val_consvar_grad_1,
                          su2double **val_consvar_grad_2);
  
  void SetConsVarGradient(su2double **val_consvar_grad_0,
                          su2double **val_consvar_grad_1,
                          su2double **val_consvar_grad_2,
                          su2double **val_consvar_grad_3);
  
  void SetConsVarGradient(su2double **val_consvar_grad);
  
  void SetPrimVarGradient(su2double **val_primvar_grad_i,
                          su2double **val_primvar_grad_j);
  
  void SetPrimVarLimiter(su2double *val_primvar_lim_i,
                         su2double *val_primvar_lim_j);
  
  void SetAdjointVar(su2double *val_psi_i, su2double *val_psi_j);
  
  void SetAdjointVarGradient(su2double **val_psivar_grad_i, su2double **val_psivar_grad_j);
  
  void SetAdjointVarLimiter(su2double *val_psivar_lim_i, su2double *val_psivar_lim_j);
  
  void SetTurbVar(su2double *val_turbvar_i, su2double *val_turbvar_j);
  
  void SetTransVar(su2double *val_transvar_i, su2double *val_transvar_j);
  
  void SetTurbVarGradient(su2double **val_turbvar_grad_i, su2double **val_turbvar_grad_j);
  
  void SetTransVarGradient(su2double **val_transvar_grad_i, su2double **val_transvar_grad_j);

  void SetTurbAdjointVar(su2double *val_turbpsivar_i, su2double *val_turbpsivar_j);
  
  void SetTurbAdjointGradient (su2double **val_turbpsivar_grad_i, su2double **val_turbpsivar_grad_j);
  
  virtual void SetF1blending(su2double val_F1_i, su2double val_F1_j) {/* empty */};
  
  virtual void SetF2blending(su2double val_F1_i, su2double val_F1_j) {/* empty */};
  
  virtual void SetCrossDiff(su2double val_CDkw_i, su2double val_CDkw_j) {/* empty */};
  
  void SetAuxVarGrad(su2double *val_auxvargrad_i, su2double *val_auxvargrad_j);
  
  void SetDiffusionCoeff(su2double* val_diffusioncoeff_i,
                         su2double* val_diffusioncoeff_j);
  
  void SetLaminarViscosity(su2double val_laminar_viscosity_i,
                           su2double val_laminar_viscosity_j);
  
  void SetThermalConductivity(su2double val_thermal_conductivity_i,
                              su2double val_thermal_conductivity_j);
  
  void SetThermalConductivity_ve(su2double val_thermal_conductivity_ve_i,
                                 su2double val_thermal_conductivity_ve_j);
  
  void SetEddyViscosity(su2double val_eddy_viscosity_i,
                        su2double val_eddy_viscosity_j);
  
  void SetTurbKineticEnergy(su2double val_turb_ke_i, su2double val_turb_ke_j);
  
  void SetDistance(su2double val_dist_i, su2double val_dist_j);
  
  void SetCoord(su2double *val_coord_i, su2double *val_coord_j);
  
  void SetCoord(su2double *val_coord_0, su2double *val_coord_1, su2double *val_coord_2);
  
  void SetCoord(su2double *val_coord_0, su2double *val_coord_1, su2double *val_coord_2,
                su2double *val_coord_3);
  
  void SetGridVel(su2double *val_gridvel_i, su2double *val_gridvel_j);
  
  void SetWindGust(su2double *val_windgust_i, su2double *val_windgust_j);
  
  void SetWindGustDer(su2double *val_windgustder_i, su2double *val_windgustder_j);
  
  void SetPressure(su2double val_pressure_i, su2double val_pressure_j);
  
  void SetDensity(su2double val_densityinc_i, su2double val_densityinc_j);
  
  void SetBetaInc2(su2double val_betainc2_i, su2double val_betainc2_j);
  
  void SetSoundSpeed(su2double val_soundspeed_i, su2double val_soundspeed_j);
  
  void SetTemperature(su2double val_temp_i, su2double val_temp_j);
  
  void SetEnthalpy(su2double val_enthalpy_i, su2double val_enthalpy_j);
  
  void SetLambda(su2double val_lambda_i, su2double val_lambda_j);
  
  void SetUndivided_Laplacian(su2double *val_und_lapl_i, su2double *val_und_lapl_j);
  
  void SetSensor(su2double val_sensor_i, su2double val_sensor_j);
  
  void SetNeighbor(unsigned short val_neighbor_i, unsigned short val_neighbor_j);
  
  void SetNormal(su2double *val_normal);
  
  void SetVolume(su2double val_volume);
  
  void SetRhosIndex(unsigned short val_Index);
  
  void SetRhoIndex(unsigned short val_Index);
  
  void SetPIndex(unsigned short val_Index);
  
  void SetTIndex(unsigned short val_Index);
  
  void SetTveIndex(unsigned short val_Index);
  
  void SetVelIndex(unsigned short val_Index);
  
  void SetHIndex(unsigned short val_Index);
  
  void SetAIndex(unsigned short val_Index);
  
  void SetRhoCvtrIndex(unsigned short val_Index);
  
  void SetRhoCvveIndex(unsigned short val_Index);
  
  void SetdPdU(su2double *val_dPdU_i, su2double *val_dPdU_j);
  
  void SetdTdU(su2double *val_dTdU_i, su2double *val_dTdU_j);
  
  void SetdTvedU(su2double *val_dTvedU_i, su2double *val_dTvedU_j);
  
  void GetInviscidFlux(su2double val_density, su2double *val_velocity, su2double val_pressure, su2double val_enthalpy);
  
  void GetViscousFlux(su2double *val_primvar, su2double **val_gradprimvar,
                      su2double val_laminar_viscosity, su2double val_eddy_viscosity,
                      su2double val_mach_inf);
  
  void GetInviscidProjFlux(su2double *val_density, su2double *val_velocity,
                           su2double *val_pressure, su2double *val_enthalpy,
                           su2double *val_normal, su2double *val_Proj_Flux);
    
  void GetInviscidArtCompProjFlux(su2double *val_density, su2double *val_velocity,
                                  su2double *val_pressure, su2double *val_betainc2,
                                  su2double *val_normal, su2double *val_Proj_Flux);
  
  void GetViscousProjFlux(su2double *val_primvar, su2double **val_gradprimvar,
                          su2double val_turb_ke, su2double *val_normal,
                          su2double val_laminar_viscosity,
                          su2double val_eddy_viscosity);
  void GetViscousProjFlux(su2double *val_primvar, su2double **val_gradprimvar,
                          su2double val_turb_ke, su2double *val_normal,
                          su2double val_laminar_viscosity,
                          su2double val_eddy_viscosity,
                          su2double val_thermal_conductivity,
                          su2double val_heat_capacity_cp);
    
  /*
   * \brief Compute the projection of the viscous fluxes into a direction (artificial compresibility method).
   * \param[in] val_primvar - Primitive variables.
   * \param[in] val_gradprimvar - Gradient of the primitive variables.
   * \param[in] val_normal - Normal vector, the norm of the vector is the area of the face.
   * \param[in] val_laminar_viscosity - Laminar viscosity.
   * \param[in] val_eddy_viscosity - Eddy viscosity.
   */
  
  void GetViscousArtCompProjFlux(su2double **val_gradprimvar,
                                 su2double *val_normal,
                                 su2double val_laminar_viscosity,
                                 su2double val_eddy_viscosity);
  
  void GetInviscidProjJac(su2double *val_velocity, su2double *val_energy,
                          su2double *val_normal, su2double val_scale,
                          su2double **val_Proj_Jac_tensor);
  
  void GetInviscidArtCompProjJac(su2double *val_density, su2double *val_velocity,
                                 su2double *val_betainc2, su2double *val_normal,
                                 su2double val_scale,
                                 su2double **val_Proj_Jac_tensor);
  
  void GetInviscidProjJac(su2double *val_velocity, su2double *val_enthalphy,
                          su2double *val_chi, su2double *val_kappa,
                          su2double *val_normal, su2double val_scale,
                          su2double **val_Proj_Jac_tensor);
  
  void GetViscousProjJacs(su2double *val_Mean_PrimVar,
                          su2double val_laminar_viscosity,
                          su2double val_eddy_viscosity,
                          su2double val_dist_ij,
                          su2double *val_normal, su2double val_dS,
                          su2double *val_Proj_Visc_Flux,
                          su2double **val_Proj_Jac_Tensor_i,
                          su2double **val_Proj_Jac_Tensor_j);
  
  void GetViscousProjJacs(su2double *val_Mean_PrimVar,
                          su2double **val_gradprimvar,
                          su2double *val_Mean_SecVar,
                          su2double val_laminar_viscosity,
                          su2double val_eddy_viscosity,
                          su2double val_thermal_conductivity,
                          su2double val_heat_capacity_cp,
                          su2double val_dist_ij,
                          su2double *val_normal, su2double val_dS,
                          su2double *val_Proj_Visc_Flux,
                          su2double **val_Proj_Jac_Tensor_i,
                          su2double **val_Proj_Jac_Tensor_j);
  
  void GetPrimitive2Conservative (su2double *val_Mean_PrimVar,
                                  su2double *val_Mean_SecVar,
                                  su2double **val_Jac_PC);
   
  void GetViscousArtCompProjJacs(su2double val_laminar_viscosity,
                                 su2double val_eddy_viscosity, su2double val_dist_ij,
                                 su2double *val_normal, su2double val_dS,
                                 su2double **val_Proj_Jac_Tensor_i,
                                 su2double **val_Proj_Jac_Tensor_j);
  
  void GetPMatrix(su2double *val_density, su2double *val_velocity,
                  su2double *val_soundspeed, su2double *val_enthalpy, su2double *val_chi, su2double *val_kappa,
                  su2double *val_normal, su2double **val_p_tensor);
  
  void GetPMatrix(su2double *val_density, su2double *val_velocity,
                  su2double *val_soundspeed, su2double *val_normal,
                  su2double **val_p_tensor);
  
  void GetinvRinvPe(su2double Beta2, su2double val_enthalpy, su2double val_soundspeed,
                    su2double val_density, su2double* val_velocity,
                    su2double** val_invR_invPe);
    
  void GetRMatrix(su2double val_pressure, su2double val_soundspeed,
                  su2double val_density, su2double* val_velocity,
                  su2double** val_invR_invPe);
  void GetRMatrix(su2double val_soundspeed, su2double val_density, su2double* val_normal, su2double **R_Matrix);



  void GetLMatrix(su2double val_soundspeed, su2double val_density, su2double* val_normal, su2double **L_Matrix);

  void GetPrecondJacobian(su2double Beta2, su2double r_hat, su2double s_hat, su2double t_hat, su2double rB2a2, su2double* val_Lambda, su2double* val_normal, su2double** val_absPeJac);
    
  void GetPArtCompMatrix(su2double *val_density, su2double *val_velocity,
                         su2double *val_betainv2, su2double *val_normal,
                         su2double **val_p_tensor);
  
  void GetPMatrix_inv(su2double **val_invp_tensor, su2double *val_density,
                      su2double *val_velocity, su2double *val_soundspeed,
                      su2double *val_chi, su2double *val_kappa,
                      su2double *val_normal);
  
  void GetPMatrix_inv(su2double *val_density, su2double *val_velocity,
                      su2double *val_soundspeed, su2double *val_normal,
                      su2double **val_invp_tensor);

  void GetPArtCompMatrix_inv(su2double *val_density, su2double *val_velocity,
                             su2double *val_betainv2, su2double *val_normal,
                             su2double **val_invp_tensor);
  
  void GetAdjViscousFlux_Jac(su2double Pressure_i, su2double Pressure_j, su2double Density_i, su2double Density_j,
                             su2double ViscDens_i, su2double ViscDens_j, su2double *Velocity_i, su2double *Velocity_j,
                             su2double sq_vel_i, su2double sq_vel_j,
                             su2double XiDens_i, su2double XiDens_j, su2double **Mean_GradPhi, su2double *Mean_GradPsiE,
                             su2double dPhiE_dn, su2double *Normal, su2double *Edge_Vector, su2double dist_ij_2, su2double *val_residual_i,
                             su2double *val_residual_j,
                             su2double **val_Jacobian_ii, su2double **val_Jacobian_ij, su2double **val_Jacobian_ji,
                             su2double **val_Jacobian_jj, bool implicit);
  
  void GetJacInviscidLambda_fabs(su2double *val_velocity, su2double val_soundspeed,
                                 su2double *val_normal, su2double *val_Lambda_Vector);
  
  virtual void ComputeResidual(su2double *val_residual, CConfig *config);
  
  virtual void ComputeResidual(su2double *val_residual_i, su2double *val_residual_j);
  
  virtual void ComputeResidual_TransLM(su2double *val_residual,
                                       su2double **val_Jacobian_i,
                                       su2double **val_Jacobian_j, CConfig *config,
                                       su2double &gamma_sep) ;
  
  virtual void ComputeResidual(su2double *val_residual_i,
                               su2double *val_residual_j, CConfig *config);
  
  virtual void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i,
                               su2double **val_Jacobian_j, CConfig *config);
  
  virtual void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i,
                               su2double **val_Jacobian_j,
                               su2double **val_JacobianMeanFlow_i,
                               su2double **val_JacobianMeanFlow_j,
                               CConfig *config);
  
  virtual void ComputeResidual(su2double **val_Jacobian_i, su2double **val_Jacobian_j,
                               CConfig *config);
  
  virtual void ComputeResidual(su2double *val_resconv, su2double *val_resvisc,
                               su2double **val_Jacobian_i, su2double **val_Jacobian_j,
                               CConfig *config);
  
  virtual void ComputeResidual(su2double *val_residual_i, su2double *val_residual_j,
                               su2double **val_Jacobian_ii,
                               su2double **val_Jacobian_ij,
                               su2double **val_Jacobian_ji,
                               su2double **val_Jacobian_jj, CConfig *config);
  
  virtual void ComputeResidual(su2double *val_resconv_i, su2double *val_resvisc_i,
                               su2double *val_resconv_j, su2double *val_resvisc_j,
                               su2double **val_Jacobian_ii,
                               su2double **val_Jacobian_ij,
                               su2double **val_Jacobian_ji,
                               su2double **val_Jacobian_jj, CConfig *config);
  
  virtual void ComputeResidual(su2double **val_stiffmatrix_elem, CConfig *config);
  
  virtual void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i,
                               CConfig *config);
  
  virtual void GetEq_Rxn_Coefficients(su2double **EqnRxnConstants, CConfig *config);
  
  virtual void ComputeResidual_Axisymmetric(su2double *val_residual, CConfig *config);
  
  virtual void ComputeResidual_Axisymmetric_ad(su2double *val_residual, su2double *val_residuald, CConfig *config);
  
  virtual void SetJacobian_Axisymmetric(su2double **val_Jacobian_i, CConfig *config);
  
  virtual void ComputeVibRelaxation(su2double *val_residual, su2double **val_Jacobian_i, CConfig *config);
  
  virtual void ComputeChemistry(su2double *val_residual, su2double **val_Jacobian_i, CConfig *config);
  
  virtual void GetKeqConstants(su2double *A, unsigned short val_reaction, CConfig *config);
  
  virtual void SetIntermittency(su2double intermittency_in);
  
  virtual void SetProduction(su2double val_production);
  
  virtual void SetDestruction(su2double val_destruction);
  
  virtual void SetCrossProduction(su2double val_crossproduction);
  
  virtual su2double GetProduction(void);
  
  virtual su2double GetDestruction(void);
  
  virtual su2double GetCrossProduction(void);
  
  virtual void ComputeResidual(su2double **val_Jacobian_i,
                               su2double *val_Jacobian_mui,
                               su2double ***val_Jacobian_gradi, CConfig *config);
  
  virtual void ComputeResidual(su2double **val_Jacobian_i,
                               su2double *val_Jacobian_mui,
                               su2double ***val_Jacobian_gradi,
                               su2double **val_Jacobian_j,
                               su2double *val_Jacobian_muj,
                               su2double ***val_Jacobian_gradj, CConfig *config);

  virtual void Compute_Tangent_Matrix(CElement *element_container, CConfig *config);

  virtual void Compute_MeanDilatation_Term(CElement *element_container, CConfig *config);

  virtual void Compute_NodalStress_Term(CElement *element_container, CConfig *config);

  virtual void Compute_Plane_Stress_Term(CElement *element_container, CConfig *config);

  virtual void Compute_Constitutive_Matrix(CElement *element_container, CConfig *config);

  virtual void Compute_Stress_Tensor(CElement *element_container, CConfig *config);

  virtual void Compute_Mass_Matrix(CElement *element_container, CConfig *config);

  virtual void Compute_Dead_Load(CElement *element_container, CConfig *config);

  virtual void Compute_Averaged_NodalStress(CElement *element_container, CConfig *config);

  void CreateBasis(su2double *val_Normal);
  
};

class CUpwCUSP_Flow : public CNumerics {
  
private:
  unsigned short iDim, iVar, jVar; 
  su2double *Diff_U, *Diff_Flux, 
  *Velocity_i, *Velocity_j, 
  *MeanVelocity, ProjVelocity,  
  Density_i, Density_j, Energy_i, Energy_j,  
  sq_vel_i, sq_vel_j,   
  MeanDensity, MeanPressure, MeanEnthalpy, MeanEnergy, 
  *ProjFlux, *ProjFlux_i, *ProjFlux_j,  
  cte_0, cte_1, 
  LamdaNeg, LamdaPos, Beta, Nu_c, U_i[5], U_j[5], MeanSoundSpeed, Mach,
  **Jacobian;  
  bool implicit, 
  grid_movement; 
public:
  
  CUpwCUSP_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CUpwCUSP_Flow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j,
                       CConfig *config);
};

class CUpwRoe_Flow : public CNumerics {
private:
  bool implicit, grid_movement;
  su2double *Diff_U;
  su2double *Velocity_i, *Velocity_j, *RoeVelocity;
  su2double *ProjFlux_i, *ProjFlux_j;
  su2double *delta_wave, *delta_vel;
  su2double *Lambda, *Epsilon, MaxLambda, Delta;
  su2double **P_Tensor, **invP_Tensor;
  su2double sq_vel, Proj_ModJac_Tensor_ij, Density_i, Energy_i, SoundSpeed_i, Pressure_i, Enthalpy_i,
  Density_j, Energy_j, SoundSpeed_j, Pressure_j, Enthalpy_j, R, RoeDensity, RoeEnthalpy, RoeSoundSpeed,
  ProjVelocity, ProjVelocity_i, ProjVelocity_j, RoeSoundSpeed2, kappa;
  unsigned short iDim, iVar, jVar, kVar;
  
public:
  
  CUpwRoe_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CUpwRoe_Flow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
};


class CUpwGeneralRoe_Flow : public CNumerics {
private:

  bool implicit, grid_movement;

  su2double *Diff_U;
  su2double *Velocity_i, *Velocity_j, *RoeVelocity;
  su2double *ProjFlux_i, *ProjFlux_j;
  su2double *delta_wave, *delta_vel;
  su2double *Lambda, *Epsilon, MaxLambda, Delta;
  su2double **P_Tensor, **invP_Tensor;
  su2double sq_vel, Proj_ModJac_Tensor_ij, Density_i, Energy_i, SoundSpeed_i, Pressure_i, Enthalpy_i,

  Density_j, Energy_j, SoundSpeed_j, Pressure_j, Enthalpy_j, R, RoeDensity, RoeEnthalpy, RoeSoundSpeed, RoeSoundSpeed2,
  ProjVelocity, ProjVelocity_i, ProjVelocity_j, proj_delta_vel, delta_p, delta_rho, kappa;
  unsigned short iDim, iVar, jVar, kVar;


  su2double StaticEnthalpy_i, StaticEnergy_i, StaticEnthalpy_j, StaticEnergy_j, Kappa_i, Kappa_j, Chi_i, Chi_j, Velocity2_i, Velocity2_j;
  su2double RoeKappa, RoeChi, RoeKappaStaticEnthalpy;

public:
  
  CUpwGeneralRoe_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CUpwGeneralRoe_Flow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
  
  void ComputeRoeAverage();
};


class CUpwMSW_Flow : public CNumerics {
private:
  bool implicit;
  su2double *Diff_U;
  su2double *u_i, *u_j, *ust_i, *ust_j;
  su2double *Fc_i, *Fc_j;
  su2double *Lambda_i, *Lambda_j;
  su2double rhos_i, rhos_j;
  su2double *Ust_i, *Ust_j, *Vst_i, *Vst_j, *Velst_i, *Velst_j;
  su2double **P_Tensor, **invP_Tensor;
  unsigned short nPrimVar, nVar, nDim;
  
public:
  
  CUpwMSW_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CUpwMSW_Flow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
  
};

class CUpwTurkel_Flow : public CNumerics {
private:
  bool implicit, grid_movement;
  su2double *Diff_U;
  su2double *Velocity_i, *Velocity_j, *RoeVelocity;
  su2double *ProjFlux_i, *ProjFlux_j;
  su2double *Lambda, *Epsilon;
  su2double **absPeJac, **invRinvPe, **R_Tensor, **Matrix, **Art_Visc;
  su2double sq_vel, Density_i, Energy_i, SoundSpeed_i, Pressure_i, Enthalpy_i,
  Density_j, Energy_j, SoundSpeed_j, Pressure_j, Enthalpy_j, R, RoePressure, RoeDensity, RoeEnthalpy, RoeSoundSpeed,
  ProjVelocity, ProjVelocity_i, ProjVelocity_j;
  unsigned short iDim, iVar, jVar, kVar;
  su2double Beta, Beta_min, Beta_max;
  su2double r_hat, s_hat, t_hat, rhoB2a2, sqr_one_m_Betasqr_Lam1;
  su2double Beta2, one_m_Betasqr, one_p_Betasqr, sqr_two_Beta_c_Area;
  su2double local_Mach;
  
public:
  
  CUpwTurkel_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CUpwTurkel_Flow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
  
  su2double GetPrecond_Beta();
};

class CUpwArtComp_Flow : public CNumerics {
private:
  bool implicit;
  bool gravity;
  su2double Froude;
  su2double *Diff_U;
  su2double *Velocity_i, *Velocity_j, *MeanVelocity;
  su2double *ProjFlux_i, *ProjFlux_j;
  su2double *Lambda, *Epsilon;
  su2double **P_Tensor, **invP_Tensor;
  su2double Proj_ModJac_Tensor_ij, Pressure_i,
  Pressure_j, MeanDensity, MeanSoundSpeed, MeanPressure, MeanBetaInc2,
  ProjVelocity;
  unsigned short iDim, iVar, jVar, kVar;
  
public:
  
  CUpwArtComp_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CUpwArtComp_Flow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
};

class CUpwRoe_AdjFlow : public CNumerics {
private:
  su2double *Residual_Roe;
  su2double area, Sx, Sy, Sz, rarea, nx, ny, nz, rho_l, u_l, v_l, w_l, h_l, rho_r,
  u_r, v_r, w_r, h_r, psi1, psi2, psi3, psi4, psi5;
  su2double h, u, v, w, c, psi1_l, psi2_l, psi3_l, psi4_l, psi5_l,
  psi1_r, psi2_r, psi3_r, psi4_r, psi5_r, q_l, q_r, Q_l, Q_r, vn,
  rrho_l, weight, rweight1, cc;
  su2double l1psi, l2psi, absQ, absQp, absQm, q2, alpha, beta_u, beta_v, beta_w, Q, l1l2p, l1l2m, eta;
  su2double RoeDensity, RoeSoundSpeed, *RoeVelocity, *Lambda, *Velocity_i, *Velocity_j, **ProjFlux_i, **ProjFlux_j,
  Proj_ModJac_Tensor_ij, **Proj_ModJac_Tensor, Energy_i, Energy_j, **P_Tensor, **invP_Tensor;
  unsigned short iDim, iVar, jVar, kVar;
  bool implicit, grid_movement;
  
public:
  
  CUpwRoe_AdjFlow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CUpwRoe_AdjFlow(void);
  
  void ComputeResidual(su2double *val_residual_i, su2double *val_residual_j, su2double **val_Jacobian_ii,
                       su2double **val_Jacobian_ij, su2double **val_Jacobian_ji, su2double **val_Jacobian_jj, CConfig *config);
};

class CUpwRoeArtComp_AdjFlow : public CNumerics {
private:
  su2double Area, *Lambda, *Velocity_i, *Velocity_j, **Proj_Jac_Tensor_i, **Proj_Jac_Tensor_j,
  Proj_ModJac_Tensor_ij, **Proj_ModJac_Tensor, **P_Tensor, **invP_Tensor, MeanDensity,
  MeanPressure, MeanBetaInc2, ProjVelocity, *MeanVelocity, MeanSoundSpeed;
  unsigned short iDim, iVar, jVar, kVar;
  bool implicit;
  
public:
  
  CUpwRoeArtComp_AdjFlow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CUpwRoeArtComp_AdjFlow(void);
  
  void ComputeResidual(su2double *val_residual_i, su2double *val_residual_j, su2double **val_Jacobian_ii,
                       su2double **val_Jacobian_ij, su2double **val_Jacobian_ji, su2double **val_Jacobian_jj, CConfig *config);
};

class CUpwAUSM_Flow : public CNumerics {
private:
  bool implicit;
  su2double *Diff_U;
  su2double *Velocity_i, *Velocity_j, *RoeVelocity;
  su2double *ProjFlux_i, *ProjFlux_j;
  su2double *delta_wave, *delta_vel;
  su2double *Lambda, *Epsilon;
  su2double **P_Tensor, **invP_Tensor;
  su2double sq_vel, Proj_ModJac_Tensor_ij, Density_i, Energy_i, SoundSpeed_i, Pressure_i, Enthalpy_i,
  Density_j, Energy_j, SoundSpeed_j, Pressure_j, Enthalpy_j, R, RoeDensity, RoeEnthalpy, RoeSoundSpeed,
  ProjVelocity, ProjVelocity_i, ProjVelocity_j;
  unsigned short iDim, iVar, jVar, kVar;
  su2double mL, mR, mLP, mRM, mF, pLP, pRM, pF, Phi;
  
public:
  
  CUpwAUSM_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CUpwAUSM_Flow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
};

class CUpwHLLC_Flow : public CNumerics {
private:
  bool implicit, grid_movement;
  unsigned short iDim, jDim, iVar, jVar;
  
  su2double *IntermediateState;
  su2double *Velocity_i, *Velocity_j, *RoeVelocity;

  su2double sq_vel_i, Density_i, Energy_i, SoundSpeed_i, Pressure_i, Enthalpy_i, ProjVelocity_i;
  su2double sq_vel_j, Density_j, Energy_j, SoundSpeed_j, Pressure_j, Enthalpy_j, ProjVelocity_j;
  
  su2double sq_velRoe, RoeDensity, RoeEnthalpy, RoeSoundSpeed, RoeProjVelocity, ProjInterfaceVel;

  su2double sL, sR, sM, pStar, EStar, rhoSL, rhoSR, Rrho, kappa;

  su2double Omega, RHO, OmegaSM;
  su2double *dSm_dU, *dPI_dU, *drhoStar_dU, *dpStar_dU, *dEStar_dU;
  
public:
  
  CUpwHLLC_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CUpwHLLC_Flow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);

};

class CUpwGeneralHLLC_Flow : public CNumerics {
private:
  bool implicit, grid_movement;
  unsigned short iDim, jDim, iVar, jVar;
  
  su2double *IntermediateState;
  su2double *Velocity_i, *Velocity_j, *RoeVelocity;

  su2double sq_vel_i, Density_i, Energy_i, SoundSpeed_i, Pressure_i, Enthalpy_i, ProjVelocity_i, StaticEnthalpy_i, StaticEnergy_i;
  su2double sq_vel_j, Density_j, Energy_j, SoundSpeed_j, Pressure_j, Enthalpy_j, ProjVelocity_j, StaticEnthalpy_j, StaticEnergy_j;
  
  su2double sq_velRoe, RoeDensity, RoeEnthalpy, RoeSoundSpeed, RoeProjVelocity, ProjInterfaceVel;
  su2double Kappa_i, Kappa_j, Chi_i, Chi_j, RoeKappa, RoeChi, RoeKappaStaticEnthalpy;

  su2double sL, sR, sM, pStar, EStar, rhoSL, rhoSR, Rrho, kappa;

  su2double Omega, RHO, OmegaSM;
  su2double *dSm_dU, *dPI_dU, *drhoStar_dU, *dpStar_dU, *dEStar_dU;

  
public:
  
  CUpwGeneralHLLC_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CUpwGeneralHLLC_Flow(void);
  
   void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);

   void VinokurMontagne();
};

class CUpwLin_TransLM : public CNumerics {
private:
  su2double *Velocity_i;
  su2double *Velocity_j;
  bool implicit, grid_movement, incompressible;
  su2double Density_i, Density_j, q_ij, a0, a1;
  unsigned short iDim;
  
public:
  
  CUpwLin_TransLM(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CUpwLin_TransLM(void);
  
  void ComputeResidual (su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
};

class CUpwLin_AdjTurb : public CNumerics {
private:
  su2double *Velocity_i;
  
public:
  
  CUpwLin_AdjTurb(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CUpwLin_AdjTurb(void);
  
  void ComputeResidual (su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
};

class CUpwSca_TurbSA : public CNumerics {
private:
  su2double *Velocity_i, *Velocity_j;
  bool implicit, grid_movement, incompressible;
  su2double q_ij, a0, a1;
  unsigned short iDim;
  
public:
  
  CUpwSca_TurbSA(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CUpwSca_TurbSA(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
};

class CUpwSca_TurbML : public CNumerics {
private:
  su2double *Velocity_i, *Velocity_j;
  bool implicit, grid_movement, incompressible;
  su2double q_ij, a0, a1;
  unsigned short iDim;
  
public:
  
  CUpwSca_TurbML(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CUpwSca_TurbML(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
};

class CUpwSca_TurbSST : public CNumerics {
private:
  su2double *Velocity_i, *Velocity_j;
  bool implicit, grid_movement, incompressible;
  su2double Density_i, Density_j,
  q_ij,
  a0, a1;
  unsigned short iDim;
  
public:
  
  CUpwSca_TurbSST(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CUpwSca_TurbSST(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
};

class CUpwSca_TransLM : public CNumerics {
private:
  su2double *Velocity_i, *Velocity_j;
  bool implicit, grid_movement;
  su2double q_ij, a0, a1;
  unsigned short iDim;
  
public:
  
  CUpwSca_TransLM(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CUpwSca_TransLM(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
};

class CUpwSca_AdjTurb : public CNumerics {
private:
  su2double *Velocity_i, *Velocity_j;
  
public:
  
  CUpwSca_AdjTurb(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CUpwSca_AdjTurb(void);
  
  void ComputeResidual(su2double *val_residual_i, su2double *val_residual_j, su2double **val_Jacobian_ii, su2double **val_Jacobian_ij,
                       su2double **val_Jacobian_ji, su2double **val_Jacobian_jj, CConfig *config);
};


class CCentJST_KE_Flow : public CNumerics {
  
private:
  unsigned short iDim, iVar, jVar; 
  su2double *Diff_U, *Diff_Lapl, 
  *Velocity_i, *Velocity_j, 
  *MeanVelocity, ProjVelocity, ProjVelocity_i, ProjVelocity_j,  
  Density_i, Density_j, Energy_i, Energy_j,  
  sq_vel_i, sq_vel_j,   
  MeanDensity, MeanPressure, MeanEnthalpy, MeanEnergy, 
  Param_p, Param_Kappa_2, Param_Kappa_4, 
  Local_Lambda_i, Local_Lambda_j, MeanLambda, 
  Phi_i, Phi_j, sc2, sc4, StretchingFactor, 
  *ProjFlux,  
  Epsilon_2, cte_0, cte_1, 
  ProjGridVel;  
  bool implicit, 
  grid_movement; 
public:
  
  CCentJST_KE_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CCentJST_KE_Flow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j,
                       CConfig *config);
};

class CCentJST_Flow : public CNumerics {
  
private:
  unsigned short iDim, iVar, jVar; 
  su2double *Diff_U, *Diff_Lapl, 
  *Velocity_i, *Velocity_j, 
  *MeanVelocity, ProjVelocity, ProjVelocity_i, ProjVelocity_j,  
  Density_i, Density_j, Energy_i, Energy_j,  
  sq_vel_i, sq_vel_j,   
  MeanDensity, MeanPressure, MeanEnthalpy, MeanEnergy, 
  Param_p, Param_Kappa_2, Param_Kappa_4, 
  Local_Lambda_i, Local_Lambda_j, MeanLambda, 
  Phi_i, Phi_j, sc2, sc4, StretchingFactor, 
  *ProjFlux,  
  Epsilon_2, Epsilon_4, cte_0, cte_1, 
  ProjGridVel;  
  bool implicit, 
  grid_movement; 
public:
  
  CCentJST_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CCentJST_Flow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j,
                       CConfig *config);
};

class CCentJSTArtComp_Flow : public CNumerics {
  
private:
  unsigned short iDim, iVar, jVar; 
  su2double *Diff_U, *Diff_Lapl, 
  *Velocity_i, *Velocity_j, 
  *MeanVelocity, ProjVelocity_i, ProjVelocity_j,  
  sq_vel_i, sq_vel_j,   
  MeanDensity, MeanPressure, MeanBetaInc2, 
  Param_p, Param_Kappa_2, Param_Kappa_4, 
  Local_Lambda_i, Local_Lambda_j, MeanLambda, 
  Phi_i, Phi_j, sc2, sc4, StretchingFactor, 
  *ProjFlux,  
  Epsilon_2, Epsilon_4, cte_0, cte_1; 
  bool implicit, 
  grid_movement, 
  gravity; 
  su2double Froude; 
public:
  
  CCentJSTArtComp_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CCentJSTArtComp_Flow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j,
                       CConfig *config);
};

class CCentJST_AdjFlow : public CNumerics {
private:
  su2double *Diff_Psi, *Diff_Lapl;
  su2double *Velocity_i, *Velocity_j;
  su2double *MeanPhi;
  unsigned short iDim, jDim, iVar, jVar;
  su2double Residual, ProjVelocity_i, ProjVelocity_j, ProjPhi, ProjPhi_Vel, sq_vel, phis1, phis2;
  su2double MeanPsiRho, MeanPsiE, Param_p, Param_Kappa_4, Param_Kappa_2, Local_Lambda_i, Local_Lambda_j, MeanLambda;
  su2double Phi_i, Phi_j, sc4, StretchingFactor, Epsilon_4, Epsilon_2;
  bool implicit, grid_movement;
  
public:
  
  CCentJST_AdjFlow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CCentJST_AdjFlow(void);
  
  void ComputeResidual (su2double *val_resconv_i, su2double *val_resvisc_i, su2double *val_resconv_j, su2double *val_resvisc_j,
                        su2double **val_Jacobian_ii, su2double **val_Jacobian_ij, su2double **val_Jacobian_ji, su2double **val_Jacobian_jj,
                        CConfig *config);
};

class CCentJSTArtComp_AdjFlow : public CNumerics {
private:
  su2double sc2, *Diff_Psi, *Diff_Lapl;
  su2double *Velocity_i, *Velocity_j;
  su2double **Proj_Jac_Tensor_i, **Proj_Jac_Tensor_j;
  unsigned short iDim, iVar, jVar;
  su2double Residual, ProjVelocity_i, ProjVelocity_j;
  su2double Param_p, Param_Kappa_4, Param_Kappa_2, Local_Lambda_i, Local_Lambda_j, MeanLambda;
  su2double Phi_i, Phi_j, sc4, StretchingFactor, Epsilon_4, Epsilon_2;
  bool implicit;
  
public:
  
  CCentJSTArtComp_AdjFlow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CCentJSTArtComp_AdjFlow(void);
  
  void ComputeResidual (su2double *val_resconv_i, su2double *val_resvisc_i, su2double *val_resconv_j, su2double *val_resvisc_j,
                        su2double **val_Jacobian_ii, su2double **val_Jacobian_ij, su2double **val_Jacobian_ji, su2double **val_Jacobian_jj,
                        CConfig *config);
};

class CCentLax_Flow : public CNumerics {
private:
  unsigned short iDim, iVar, jVar; 
  su2double *Diff_U, 
  *Velocity_i, *Velocity_j, 
  *MeanVelocity, ProjVelocity, ProjVelocity_i, ProjVelocity_j,  
  *ProjFlux,  
  Density_i, Density_j, Energy_i, Energy_j,  
  sq_vel_i, sq_vel_j,   
  MeanDensity, MeanPressure, MeanEnthalpy, MeanEnergy, 
  Param_p, Param_Kappa_0, 
  Local_Lambda_i, Local_Lambda_j, MeanLambda, 
  Phi_i, Phi_j, sc0, StretchingFactor, 
  Epsilon_0, cte; 
  bool implicit, 
  grid_movement; 
  su2double ProjGridVel;
  
public:
  
  CCentLax_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CCentLax_Flow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j,
                       CConfig *config);
};

class CCentLaxArtComp_Flow : public CNumerics {
private:
  unsigned short iDim, iVar, jVar; 
  su2double *Diff_U, 
  *Velocity_i, *Velocity_j, 
  *MeanVelocity, ProjVelocity_i, ProjVelocity_j,  
  *ProjFlux,  
  sq_vel_i, sq_vel_j,   
  MeanDensity, MeanPressure, MeanBetaInc2, 
  Param_p, Param_Kappa_0, 
  Local_Lambda_i, Local_Lambda_j, MeanLambda, 
  Phi_i, Phi_j, sc0, StretchingFactor, 
  Epsilon_0; 
  bool implicit, 
  grid_movement, 
  gravity; 
  su2double Froude;
  
public:
  
  CCentLaxArtComp_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CCentLaxArtComp_Flow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j,
                       CConfig *config);
};

class CCentLax_AdjFlow : public CNumerics {
private:
  su2double *Diff_Psi;
  su2double *Velocity_i, *Velocity_j;
  su2double *MeanPhi;
  unsigned short iDim, jDim, iVar, jVar;
  su2double Residual, ProjVelocity_i, ProjVelocity_j, ProjPhi, ProjPhi_Vel, sq_vel, phis1, phis2,
  MeanPsiRho, MeanPsiE, Param_p, Param_Kappa_0, Local_Lambda_i, Local_Lambda_j, MeanLambda,
  Phi_i, Phi_j, sc2, StretchingFactor, Epsilon_0;
  bool implicit, grid_movement;
  
public:
  
  CCentLax_AdjFlow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CCentLax_AdjFlow(void);
  
  void ComputeResidual (su2double *val_resconv_i, su2double *val_resvisc_i, su2double *val_resconv_j, su2double *val_resvisc_j,
                        su2double **val_Jacobian_ii, su2double **val_Jacobian_ij, su2double **val_Jacobian_ji, su2double **val_Jacobian_jj,
                        CConfig *config);
};

class CCentLaxArtComp_AdjFlow : public CNumerics {
private:
  su2double *Diff_Psi;
  su2double *Velocity_i, *Velocity_j;
  su2double *MeanPhi, **Proj_Jac_Tensor_i, **Proj_Jac_Tensor_j;
  unsigned short iDim, iVar, jVar;
  su2double Residual, ProjVelocity_i, ProjVelocity_j, Param_p, Param_Kappa_0,
  Local_Lambda_i, Local_Lambda_j, MeanLambda,
  Phi_i, Phi_j, sc2, StretchingFactor, Epsilon_0;
  bool implicit;
  
public:
  
  CCentLaxArtComp_AdjFlow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CCentLaxArtComp_AdjFlow(void);
  
  void ComputeResidual (su2double *val_resconv_i, su2double *val_resvisc_i, su2double *val_resconv_j, su2double *val_resvisc_j,
                        su2double **val_Jacobian_ii, su2double **val_Jacobian_ij, su2double **val_Jacobian_ji, su2double **val_Jacobian_jj,
                        CConfig *config);
};

class CAvgGrad_Flow : public CNumerics {
private:
  unsigned short iDim, iVar, jVar;     
  su2double *Mean_PrimVar,           
  *PrimVar_i, *PrimVar_j,           
  **Mean_GradPrimVar,             
  Mean_Laminar_Viscosity,                
  Mean_Eddy_Viscosity,                   
  Mean_turb_ke,        
  dist_ij;            
  bool implicit; 
public:
  
  CAvgGrad_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CAvgGrad_Flow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
};

class CGeneralAvgGrad_Flow : public CNumerics {
private:
  unsigned short iDim, iVar, jVar;     
  su2double *Mean_PrimVar,           
  *Mean_SecVar,                   
  *PrimVar_i, *PrimVar_j,           
  **Mean_GradPrimVar,             
  Mean_Laminar_Viscosity,                
  Mean_Eddy_Viscosity,                   
  Mean_Thermal_Conductivity,             
  Mean_Cp,                               
  Mean_turb_ke,        
  dist_ij;            
  bool implicit; 
public:
  
  CGeneralAvgGrad_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CGeneralAvgGrad_Flow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
};

class CAvgGradArtComp_Flow : public CNumerics {
private:
  unsigned short iDim, iVar, jVar;  
  su2double **Mean_GradPrimVar,          
  Mean_Laminar_Viscosity, Mean_Eddy_Viscosity, 
  dist_ij;              
  bool implicit;        
public:
  
  CAvgGradArtComp_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CAvgGradArtComp_Flow(void);
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
};

class CAvgGrad_TurbSA : public CNumerics {
private:
  
  su2double **Mean_GradTurbVar;
  su2double *Proj_Mean_GradTurbVar_Kappa, *Proj_Mean_GradTurbVar_Edge;
  su2double *Edge_Vector;
  bool implicit, incompressible;
  su2double sigma;
  su2double nu_i, nu_j, nu_e;
  su2double dist_ij_2;
  su2double proj_vector_ij;
  unsigned short iVar, iDim;
  
public:
  
  CAvgGrad_TurbSA(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CAvgGrad_TurbSA(void);
  
  void ComputeResidual(su2double *val_residual, su2double **Jacobian_i, su2double **Jacobian_j, CConfig *config);
};

class CAvgGrad_TurbSA_Neg : public CNumerics {
private:
  
  su2double **Mean_GradTurbVar;
  su2double *Proj_Mean_GradTurbVar_Kappa, *Proj_Mean_GradTurbVar_Edge;
  su2double *Edge_Vector;
  bool implicit, incompressible;
  su2double sigma;
  su2double cn1, fn, Xi;
  su2double nu_i, nu_j, nu_ij, nu_tilde_ij, nu_e;
  su2double dist_ij_2;
  su2double proj_vector_ij;
  unsigned short iVar, iDim;
  
public:
  
  CAvgGrad_TurbSA_Neg(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CAvgGrad_TurbSA_Neg(void);
  
  void ComputeResidual(su2double *val_residual, su2double **Jacobian_i, su2double **Jacobian_j, CConfig *config);
};

class CAvgGrad_TurbML : public CNumerics {
private:
  su2double **Mean_GradTurbVar;
  su2double *Proj_Mean_GradTurbVar_Kappa, *Proj_Mean_GradTurbVar_Edge;
  su2double *Edge_Vector;
  bool implicit, incompressible;
  su2double sigma;
  su2double nu_i, nu_j, nu_e;
  su2double dist_ij_2;
  su2double proj_vector_ij;
  unsigned short iVar, iDim;
  
public:
  
  CAvgGrad_TurbML(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CAvgGrad_TurbML(void);
  
  void ComputeResidual(su2double *val_residual, su2double **Jacobian_i, su2double **Jacobian_j, CConfig *config);
};

class CAvgGrad_TransLM : public CNumerics {
private:
  su2double **Mean_GradTransVar;
  su2double *Proj_Mean_GradTransVar_Kappa, *Proj_Mean_GradTransVar_Edge;
  su2double *Edge_Vector;
  bool implicit, incompressible;
  su2double sigma;
  //su2double dist_ij_2;
  //su2double proj_vector_ij;
  //unsigned short iVar, iDim;
  
public:
  
  CAvgGrad_TransLM(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CAvgGrad_TransLM(void);
  
  void ComputeResidual(su2double *val_residual, su2double **Jacobian_i, su2double **Jacobian_j, CConfig *config);
};

class CAvgGrad_AdjFlow : public CNumerics {
private:
  su2double *Velocity_i;  
  su2double *Velocity_j;  
  su2double *Mean_Velocity;
  su2double *Mean_GradPsiE;  
  su2double **Mean_GradPhi;  
  su2double *Edge_Vector;  
  bool implicit;      
public:
  
  CAvgGrad_AdjFlow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CAvgGrad_AdjFlow(void);
  
  void ComputeResidual(su2double *val_residual_i, su2double *val_residual_j,
                       su2double **val_Jacobian_ii, su2double **val_Jacobian_ij,
                       su2double **val_Jacobian_ji, su2double **val_Jacobian_jj, CConfig *config);
};

class CAvgGradArtComp_AdjFlow : public CNumerics {
private:
  unsigned short iDim, iVar, jVar;  
  su2double **Mean_GradPsiVar,          
  Mean_Laminar_Viscosity, Mean_Eddy_Viscosity, 
  dist_ij;              
  bool implicit;        
public:
  
  CAvgGradArtComp_AdjFlow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CAvgGradArtComp_AdjFlow(void);
  
  void ComputeResidual(su2double *val_residual_i, su2double *val_residual_j,
                       su2double **val_Jacobian_ii, su2double **val_Jacobian_ij,
                       su2double **val_Jacobian_ji, su2double **val_Jacobian_jj, CConfig *config);
};

class CAvgGradCorrected_Flow : public CNumerics {
private:
  unsigned short iDim, iVar, jVar;    
  su2double *Mean_PrimVar,          
  *PrimVar_i, *PrimVar_j,        
  *Edge_Vector,                  
  **Mean_GradPrimVar, *Proj_Mean_GradPrimVar_Edge,  
  Mean_Laminar_Viscosity,      
  Mean_Eddy_Viscosity,         
  Mean_turb_ke,         
  dist_ij_2;           
  bool implicit;      
  bool limiter;      
public:
  
  CAvgGradCorrected_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CAvgGradCorrected_Flow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
};


class CGeneralAvgGradCorrected_Flow : public CNumerics {
private:
  unsigned short iDim, iVar, jVar;    
  su2double *Mean_PrimVar,          
  *Mean_SecVar,                  
  *PrimVar_i, *PrimVar_j,            
  *Edge_Vector,                  
  **Mean_GradPrimVar, *Proj_Mean_GradPrimVar_Edge,  
  Mean_Laminar_Viscosity,      
  Mean_Eddy_Viscosity,         
  Mean_Thermal_Conductivity,   
  Mean_Cp,                     
  Mean_turb_ke,         
  dist_ij_2;           
  bool implicit;      
public:
  
  CGeneralAvgGradCorrected_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CGeneralAvgGradCorrected_Flow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
};

class CAvgGradCorrectedArtComp_Flow : public CNumerics {
private:
  unsigned short iDim, iVar, jVar;  
  su2double *PrimVar_i, *PrimVar_j,      
  *Edge_Vector,                
  **Mean_GradPrimVar, *Proj_Mean_GradPrimVar_Edge,  
  Mean_Laminar_Viscosity, Mean_Eddy_Viscosity,      
  dist_ij_2;          
  bool implicit;      
public:
  
  CAvgGradCorrectedArtComp_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CAvgGradCorrectedArtComp_Flow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
};

class CAvgGradCorrected_TurbSA : public CNumerics {
private:
  su2double **Mean_GradTurbVar;
  su2double *Proj_Mean_GradTurbVar_Kappa, *Proj_Mean_GradTurbVar_Edge, *Proj_Mean_GradTurbVar_Corrected;
  su2double *Edge_Vector;
  bool implicit, incompressible;
  su2double sigma, nu_i, nu_j, nu_e, dist_ij_2, proj_vector_ij;
  unsigned short iVar, iDim;
  
public:
  
  CAvgGradCorrected_TurbSA(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CAvgGradCorrected_TurbSA(void);
  
  void ComputeResidual(su2double *val_residual, su2double **Jacobian_i, su2double **Jacobian_j, CConfig *config);
};

class CAvgGradCorrected_TurbSA_Neg : public CNumerics {
private:
  
  su2double **Mean_GradTurbVar;
  su2double *Proj_Mean_GradTurbVar_Kappa, *Proj_Mean_GradTurbVar_Edge, *Proj_Mean_GradTurbVar_Corrected;
  su2double *Edge_Vector;
  su2double sigma;
  su2double cn1, fn, Xi;
  su2double nu_ij, nu_tilde_ij;
  bool implicit, incompressible;
  su2double nu_i, nu_j, nu_e, dist_ij_2, proj_vector_ij;
  unsigned short iVar, iDim;
  
public:
  
  CAvgGradCorrected_TurbSA_Neg(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CAvgGradCorrected_TurbSA_Neg(void);
  
  void ComputeResidual(su2double *val_residual, su2double **Jacobian_i, su2double **Jacobian_j, CConfig *config);
};

class CAvgGradCorrected_TurbML : public CNumerics {
private:
  su2double **Mean_GradTurbVar;
  su2double *Proj_Mean_GradTurbVar_Kappa, *Proj_Mean_GradTurbVar_Edge, *Proj_Mean_GradTurbVar_Corrected;
  su2double *Edge_Vector;
  bool implicit, incompressible;
  su2double sigma, nu_i, nu_j, nu_e, dist_ij_2, proj_vector_ij;
  unsigned short iVar, iDim;
  
public:
  
  CAvgGradCorrected_TurbML(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CAvgGradCorrected_TurbML(void);
  
  void ComputeResidual(su2double *val_residual, su2double **Jacobian_i, su2double **Jacobian_j, CConfig *config);
};

class CAvgGradCorrected_TransLM : public CNumerics {
private:
  su2double **Mean_GradTurbVar;
  su2double *Proj_Mean_GradTurbVar_Kappa, *Proj_Mean_GradTurbVar_Edge, *Proj_Mean_GradTurbVar_Corrected;
  su2double *Edge_Vector;
  bool implicit, incompressible;
  su2double sigma;
  
public:
  
  CAvgGradCorrected_TransLM(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CAvgGradCorrected_TransLM(void);
  
  void ComputeResidual(su2double *val_residual, su2double **Jacobian_i, su2double **Jacobian_j, CConfig *config);
};

class CAvgGrad_TurbSST : public CNumerics {
private:
  su2double sigma_k1,                     
  sigma_k2,
  sigma_om1,
  sigma_om2;
  
  su2double diff_kine,                     
  diff_omega;                           
  su2double *Edge_Vector,                  
  dist_ij_2,                            
  proj_vector_ij;                       
  su2double **Mean_GradTurbVar,            
  *Proj_Mean_GradTurbVar_Normal,        
  *Proj_Mean_GradTurbVar_Edge,          
  *Proj_Mean_GradTurbVar_Corrected;
  
  su2double F1_i, F1_j;                    
  bool implicit, incompressible;
  unsigned short iVar, iDim;
  
public:
  
  CAvgGrad_TurbSST(unsigned short val_nDim, unsigned short val_nVar, su2double* constants, CConfig *config);
  
  ~CAvgGrad_TurbSST(void);
  
  void SetF1blending(su2double val_F1_i, su2double val_F1_j) { F1_i = val_F1_i; F1_j = val_F1_j;}
  
  void ComputeResidual(su2double *val_residual, su2double **Jacobian_i, su2double **Jacobian_j, CConfig *config);
  
};

class CAvgGradCorrected_TurbSST : public CNumerics {
private:
  su2double sigma_k1,                     
  sigma_k2,
  sigma_om1,
  sigma_om2;
  
  su2double diff_kine,                     
  diff_omega;                           
  su2double *Edge_Vector,                  
  dist_ij_2,                            
  proj_vector_ij;                       
  su2double **Mean_GradTurbVar,            
  *Proj_Mean_GradTurbVar_Normal,        
  *Proj_Mean_GradTurbVar_Edge,          
  *Proj_Mean_GradTurbVar_Corrected;
  
  su2double F1_i, F1_j;                    
  bool implicit, incompressible;
  unsigned short iVar, iDim;
  
public:
  
  CAvgGradCorrected_TurbSST(unsigned short val_nDim, unsigned short val_nVar, su2double* constants, CConfig *config);
  
  ~CAvgGradCorrected_TurbSST(void);
  
  void SetF1blending(su2double val_F1_i, su2double val_F1_j) { F1_i = val_F1_i; F1_j = val_F1_j;}
  
  void ComputeResidual(su2double *val_residual, su2double **Jacobian_i, su2double **Jacobian_j, CConfig *config);
  
};

class CAvgGradCorrected_AdjFlow : public CNumerics {
private:
  su2double *Velocity_i;  
  su2double *Velocity_j;  
  su2double *Mean_Velocity;
  su2double **Mean_GradPsiVar;  
  su2double *Edge_Vector;  
  su2double *Proj_Mean_GradPsiVar_Edge;  
  su2double *Mean_GradPsiE;  
  su2double **Mean_GradPhi;  
  bool implicit;          
public:
  
  CAvgGradCorrected_AdjFlow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CAvgGradCorrected_AdjFlow(void);
  
  void ComputeResidual(su2double *val_residual_i, su2double *val_residual_j, su2double **val_Jacobian_ii, su2double **val_Jacobian_ij,
                       su2double **val_Jacobian_ji, su2double **val_Jacobian_jj, CConfig *config);
};

class CAvgGradCorrectedArtComp_AdjFlow : public CNumerics {
private:
  unsigned short iDim, iVar, jVar;  
  su2double *PsiVar_i, *PsiVar_j,      
  *Edge_Vector,                
  **Mean_GradPsiVar, *Proj_Mean_GradPsiVar_Edge,  
  Mean_Laminar_Viscosity, Mean_Eddy_Viscosity,      
  dist_ij_2;          
  bool implicit;      
public:
  
  CAvgGradCorrectedArtComp_AdjFlow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CAvgGradCorrectedArtComp_AdjFlow(void);
  
  void ComputeResidual (su2double *val_residual_i, su2double *val_residual_j, su2double **val_Jacobian_ii, su2double **val_Jacobian_ij,
                        su2double **val_Jacobian_ji, su2double **val_Jacobian_jj, CConfig *config);
};

class CAvgGradCorrected_AdjTurb : public CNumerics {
private:
  su2double **Mean_GradTurbPsi;
  su2double *Proj_Mean_GradTurbPsi_Kappa, *Proj_Mean_GradTurbPsi_Edge, *Proj_Mean_GradTurbPsi_Corrected;
  su2double *Edge_Vector;
  
public:
  
  CAvgGradCorrected_AdjTurb(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CAvgGradCorrected_AdjTurb(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
  
  void ComputeResidual(su2double *val_residual_i, su2double *val_residual_j, su2double **val_Jacobian_ii, su2double **val_Jacobian_ij,
                       su2double **val_Jacobian_ji, su2double **val_Jacobian_jj, CConfig *config);
};

class CAvgGrad_AdjTurb : public CNumerics {
private:
  su2double **Mean_GradTurbPsi;
  su2double *Proj_Mean_GradTurbPsi_Kappa, *Proj_Mean_GradTurbPsi_Edge, *Proj_Mean_GradTurbPsi_Corrected;
  su2double *Edge_Vector;
  
public:
  
  CAvgGrad_AdjTurb(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CAvgGrad_AdjTurb(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
  
  void ComputeResidual(su2double *val_residual_i, su2double *val_residual_j, su2double **val_Jacobian_ii, su2double **val_Jacobian_ij,
                       su2double **val_Jacobian_ji, su2double **val_Jacobian_jj, CConfig *config);
};

class CGalerkin_Flow : public CNumerics {
public:
  
  CGalerkin_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CGalerkin_Flow(void);
  
  void ComputeResidual (su2double **val_stiffmatrix_elem, CConfig *config);
};

class CFEM_Elasticity : public CNumerics {

protected:

  su2double E;        
  su2double Nu;      
  su2double Rho_s;    
  su2double Mu;      
  su2double Lambda;    
  su2double Kappa;    
  bool plane_stress;    
  su2double **Ba_Mat,   
  **Bb_Mat;        
  su2double *Ni_Vec;      
  su2double **D_Mat;     
  su2double **KAux_ab;   
  su2double **GradNi_Ref_Mat;
  su2double **GradNi_Curr_Mat;
  su2double *FAux_Dead_Load;    
public:

  CFEM_Elasticity(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);

  virtual ~CFEM_Elasticity(void);

  void Compute_Mass_Matrix(CElement *element_container, CConfig *config);

  void Compute_Dead_Load(CElement *element_container, CConfig *config);

  virtual void Compute_Tangent_Matrix(CElement *element_container, CConfig *config);

  virtual void Compute_MeanDilatation_Term(CElement *element_container, CConfig *config);

  virtual void Compute_NodalStress_Term(CElement *element_container, CConfig *config);

  virtual void Compute_Averaged_NodalStress(CElement *element_container, CConfig *config);

  virtual void Compute_Plane_Stress_Term(CElement *element_container, CConfig *config);

  virtual void Compute_Constitutive_Matrix(CElement *element_container, CConfig *config);
  
  virtual void Compute_Stress_Tensor(CElement *element_container, CConfig *config);

};

class CFEM_LinearElasticity : public CFEM_Elasticity {

  su2double **nodalDisplacement;

public:

  CFEM_LinearElasticity(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);

  ~CFEM_LinearElasticity(void);

  void Compute_Tangent_Matrix(CElement *element_container, CConfig *config);

  void Compute_Constitutive_Matrix(void);
  using CNumerics::Compute_Constitutive_Matrix;

  void Compute_Averaged_NodalStress(CElement *element_container, CConfig *config);

//  virtual void Compute_Stress_Tensor(void);

//  virtual void Compute_MeanDilatation_Term(CElement *element_container, CConfig *config);

//  virtual void Compute_NodalStress_Term(CElement *element_container, CConfig *config);

};

class CFEM_NonlinearElasticity : public CFEM_Elasticity {

protected:

  su2double **F_Mat;         
  su2double **b_Mat;         
  su2double **currentCoord;     
  su2double **Stress_Tensor;    
  su2double **KAux_P_ab;      
  su2double *KAux_t_a;      
  su2double J_F;           
  su2double f33;           
public:

  CFEM_NonlinearElasticity(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);

  virtual ~CFEM_NonlinearElasticity(void);

  void Compute_Tangent_Matrix(CElement *element_container, CConfig *config);

  void Compute_MeanDilatation_Term(CElement *element_container, CConfig *config);

  void Compute_NodalStress_Term(CElement *element_container, CConfig *config);

  void Compute_Averaged_NodalStress(CElement *element_container, CConfig *config);

  virtual void Compute_Plane_Stress_Term(CElement *element_container, CConfig *config);

  virtual void Compute_Constitutive_Matrix(CElement *element_container, CConfig *config);

  virtual void Compute_Stress_Tensor(CElement *element_container, CConfig *config);


};

class CFEM_NeoHookean_Comp : public CFEM_NonlinearElasticity {

public:

  CFEM_NeoHookean_Comp(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);

  ~CFEM_NeoHookean_Comp(void);

  void Compute_Plane_Stress_Term(CElement *element_container, CConfig *config);

  void Compute_Constitutive_Matrix(CElement *element_container, CConfig *config);
  using CNumerics::Compute_Constitutive_Matrix;

  void Compute_Stress_Tensor(CElement *element_container, CConfig *config);

};

class CFEM_NeoHookean_Incomp : public CFEM_NonlinearElasticity {

public:

  CFEM_NeoHookean_Incomp(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);

  ~CFEM_NeoHookean_Incomp(void);

  void Compute_Plane_Stress_Term(CElement *element_container, CConfig *config);

  void Compute_Constitutive_Matrix(CElement *element_container, CConfig *config);
  using CNumerics::Compute_Constitutive_Matrix;

  void Compute_Stress_Tensor(CElement *element_container, CConfig *config);

};



class CSourceNothing : public CNumerics {
public:
  
  CSourceNothing(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CSourceNothing(void);
};

class CSourcePieceWise_TurbSA : public CNumerics {
private:
  su2double cv1_3;
  su2double k2;
  su2double cb1;
  su2double cw2;
  su2double ct3;
  su2double ct4;
  su2double cw3_6;
  su2double cb2_sigma;
  su2double sigma;
  su2double cb2;
  su2double cw1;
  unsigned short iDim;
  su2double nu, Ji, fv1, fv2, ft2, Omega, S, Shat, inv_Shat, dist_i_2, Ji_2, Ji_3, inv_k2_d2;
  su2double r, g, g_6, glim, fw;
  su2double norm2_Grad;
  su2double dfv1, dfv2, dShat;
  su2double dr, dg, dfw;
  bool incompressible;
  bool rotating_frame;
  bool transition;
  su2double intermittency;
  su2double Production, Destruction, CrossProduction;
  
public:
  
  CSourcePieceWise_TurbSA(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CSourcePieceWise_TurbSA(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
  
  void SetIntermittency(su2double intermittency_in);
  
  void SetProduction(su2double val_production);
  
  void SetDestruction(su2double val_destruction);
  
  void SetCrossProduction(su2double val_crossproduction);
  
  su2double GetProduction(void);
  
  su2double GetDestruction(void);
  
  su2double GetCrossProduction(void);
};

class CSourcePieceWise_TurbSA_Neg : public CNumerics {
private:
  su2double cv1_3;
  su2double k2;
  su2double cb1;
  su2double cw2;
  su2double ct3;
  su2double ct4;
  su2double cw3_6;
  su2double cb2_sigma;
  su2double sigma;
  su2double cb2;
  su2double cw1;
  unsigned short iDim;
  su2double nu, Ji, fv1, fv2, ft2, Omega, S, Shat, inv_Shat, dist_i_2, Ji_2, Ji_3, inv_k2_d2;
  su2double r, g, g_6, glim, fw;
  su2double norm2_Grad;
  su2double dfv1, dfv2, dShat;
  su2double dr, dg, dfw;
  bool incompressible;
  bool rotating_frame;
  su2double intermittency;
  su2double Production, Destruction, CrossProduction;
  
public:
  
  CSourcePieceWise_TurbSA_Neg(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CSourcePieceWise_TurbSA_Neg(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
  
  void SetIntermittency(su2double intermittency_in);
  
  void SetProduction(su2double val_production);
  
  void SetDestruction(su2double val_destruction);
  
  void SetCrossProduction(su2double val_crossproduction);
  
  su2double GetProduction(void);
  
  su2double GetDestruction(void);
  
  su2double GetCrossProduction(void);
};

class CSourcePieceWise_TransLM : public CNumerics {
private:
  
  /*-- SA model constants --*/
  su2double cv1_3;
  su2double k2;
  su2double cb1;
  su2double cw2;
  su2double cw3_6;
  su2double sigma;
  su2double cb2;
  su2double cw1;
  
  /*-- gamma-theta model constants --*/
  su2double c_e1;
  su2double c_a1;
  su2double c_e2;
  su2double c_a2;
  su2double sigmaf;
  su2double s1;
  su2double c_theta;
  su2double sigmat;
  
  /*-- Correlation constants --*/
  su2double flen_global;
  su2double alpha_global;
  su2double Vorticity;

  bool implicit;
  
public:
  bool debugme; // For debugging only, remove this. -AA
  
  CSourcePieceWise_TransLM(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CSourcePieceWise_TransLM(void);
  
  void ComputeResidual_TransLM(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config, su2double &gamma_sep);
  
  void CSourcePieceWise_TransLM__ComputeResidual_TransLM_d(su2double *TransVar_i, su2double *TransVar_id, su2double *val_residual, su2double *val_residuald, CConfig *config);
};

class CSourcePieceWise_TurbSST : public CNumerics {
private:
  su2double F1_i,
  F1_j,
  F2_i,
  F2_j;
  
  su2double alfa_1,
  alfa_2,
  beta_1,
  beta_2,
  sigma_omega_1,
  sigma_omega_2,
  beta_star,
  a1;
  
  su2double CDkw_i, CDkw_j;
  
  bool incompressible;
  
public:
  
  CSourcePieceWise_TurbSST(unsigned short val_nDim, unsigned short val_nVar, su2double* constants, CConfig *config);
  
  ~CSourcePieceWise_TurbSST(void);
  
  void SetF1blending(su2double val_F1_i, su2double val_F1_j);
  
  void SetF2blending(su2double val_F2_i, su2double val_F2_j);
  
  virtual void SetCrossDiff(su2double val_CDkw_i, su2double val_CDkw_j);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
  
};

class CSourceGravity : public CNumerics {
  su2double Froude;
  bool compressible, incompressible;
  
public:
  
  CSourceGravity(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CSourceGravity(void);
  
  void ComputeResidual(su2double *val_residual, CConfig *config);
};

class CSourceViscous_AdjFlow : public CNumerics {
private:
  su2double *Velocity, *GradDensity, *GradInvDensity, *dPoDensity2, *alpha, *beta, *Sigma_5_vec;
  su2double **GradVel_o_Rho, **sigma, **Sigma_phi, **Sigma_5_Tensor, **Sigma;
  
public:
  
  CSourceViscous_AdjFlow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CSourceViscous_AdjFlow(void);
  
  void ComputeResidual (su2double *val_residual, CConfig *config);
  
};

class CSourcePieceWise_AdjTurb : public CNumerics {
private:
  su2double **tau, *Velocity;
  
public:
  
  CSourcePieceWise_AdjTurb(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CSourcePieceWise_AdjTurb(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
};

class CSourceConservative_AdjFlow : public CNumerics {
private:
  su2double *Velocity, *Residual_i, *Residual_j, *Mean_Residual;
  su2double **Mean_PrimVar_Grad;
  
public:
  
  CSourceConservative_AdjFlow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CSourceConservative_AdjFlow(void);
  
  void ComputeResidual(su2double *val_residual, CConfig *config);
};

class CSourceConservative_AdjTurb : public CNumerics {
public:
  
  CSourceConservative_AdjTurb(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CSourceConservative_AdjTurb(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
};

class CSourceRotatingFrame_Flow : public CNumerics {
public:
  
  CSourceRotatingFrame_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CSourceRotatingFrame_Flow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, CConfig *config);
};

class CSourceRotatingFrame_AdjFlow : public CNumerics {
public:
  
  CSourceRotatingFrame_AdjFlow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CSourceRotatingFrame_AdjFlow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, CConfig *config);
};

class CSourceAxisymmetric_Flow : public CNumerics {
public:
  
  CSourceAxisymmetric_Flow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CSourceAxisymmetric_Flow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **Jacobian_i, CConfig *config);
  
};

class CSourceAxisymmetric_AdjFlow : public CNumerics {
public:
  
  CSourceAxisymmetric_AdjFlow(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CSourceAxisymmetric_AdjFlow(void);
  
  void ComputeResidual(su2double *val_residual, su2double **Jacobian_i, CConfig *config);
};

class CSourceWindGust : public CNumerics {
public:
  
  CSourceWindGust(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CSourceWindGust(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, CConfig *config);
};

class CSource_Template : public CNumerics {
public:
  
  CSource_Template(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, CConfig *config);
  
  ~CSource_Template(void);
};

class CConvective_Template : public CNumerics {
private:
  
  /* define private variables here */
  bool implicit;
  su2double *Diff_U;
  su2double *Velocity_i, *Velocity_j, *RoeVelocity;
  su2double *ProjFlux_i, *ProjFlux_j;
  su2double *delta_wave, *delta_vel;
  su2double *Lambda, *Epsilon;
  su2double **P_Tensor, **invP_Tensor;
  su2double sq_vel, Proj_ModJac_Tensor_ij, Density_i, Energy_i, SoundSpeed_i, Pressure_i, Enthalpy_i,
  Density_j, Energy_j, SoundSpeed_j, Pressure_j, Enthalpy_j, R, RoeDensity, RoeEnthalpy, RoeSoundSpeed,
  ProjVelocity, ProjVelocity_i, ProjVelocity_j, proj_delta_vel, delta_p, delta_rho;
  unsigned short iDim, iVar, jVar, kVar;
  
public:
  
  CConvective_Template(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CConvective_Template(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
};

class CViscous_Template : public CNumerics {
private:
  
public:
  
  CViscous_Template(unsigned short val_nDim, unsigned short val_nVar, CConfig *config);
  
  ~CViscous_Template(void);
  
  void ComputeResidual(su2double *val_residual, su2double **val_Jacobian_i, su2double **val_Jacobian_j, CConfig *config);
};

#include "numerics_structure.inl"