option_structure.hpp

Go to the documentation of this file.

#pragma once

#include "./mpi_structure.hpp"

#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <cstdlib>
#include <algorithm>

using namespace std;

template <typename T, typename U>
class CCreateMap {
private:
  std::map<T, U> m_map;
public:
  CCreateMap(const T& key, const U& val) {
    m_map[key] = val;
  }
  CCreateMap<T, U>& operator()(const T& key, const U& val) {
    m_map[key] = val;
    return *this;
  }
  operator std::map<T, U>() {
    return m_map;
  }
};

inline void StringToUpperCase(string & str) {
  std::transform(str.begin(), str.end(), str.begin(), ::toupper);
}

inline string StringToUpperCase(const string & str) {
  string upp_str(str);
  std::transform(upp_str.begin(), upp_str.end(), upp_str.begin(), ::toupper);
  return upp_str;
}

enum SU2_COMPONENT {
  SU2_CFD = 1,  
  SU2_DEF = 2,  
  SU2_DOT = 3,  
  SU2_MSH = 4,  
  SU2_GEO = 5,  
  SU2_SOL = 6   
};

const unsigned int EXIT_DIVERGENCE = 2; 
const unsigned int BUFSIZE = 3000000;            
const unsigned int MAX_PARAMETERS = 10;        
const unsigned int MAX_NUMBER_PERIODIC = 10; 
const unsigned int MAX_STRING_SIZE = 200;    
const unsigned int MAX_NUMBER_FFD = 10;      
const unsigned int MAX_SOLS = 6;                 
const unsigned int MAX_TERMS = 6;                
const unsigned int MAX_ZONES = 3;            
const unsigned int MAX_FE_KINDS = 4;                
const unsigned int NO_RK_ITER = 0;             
const unsigned int OVERHEAD = 4; 
const unsigned int MESH_0 = 0; 
const unsigned int MESH_1 = 1; 
const unsigned int ZONE_0 = 0; 
const unsigned int ZONE_1 = 1; 
const su2double STANDART_GRAVITY = 9.80665;           
const su2double EPS = 1.0E-16;         
const su2double TURB_EPS = 1.0E-16; 
const su2double ONE2 = 0.5;            
const su2double TWO3 = 2.0 / 3.0;    
const su2double FOUR3 = 4.0 / 3.0;  
const su2double PI_NUMBER = 4.0 * atan(1.0);    
const int MASTER_NODE = 0;          
const int SINGLE_NODE = 1;          
const int SINGLE_ZONE = 1;          
const unsigned short N_ELEM_TYPES = 7;           
const unsigned short N_POINTS_LINE = 2;          
const unsigned short N_POINTS_TRIANGLE = 3;      
const unsigned short N_POINTS_QUADRILATERAL = 4; 
const unsigned short N_POINTS_TETRAHEDRON = 4;   
const unsigned short N_POINTS_HEXAHEDRON = 8;    
const unsigned short N_POINTS_PYRAMID = 5;       
const unsigned short N_POINTS_PRISM = 6;         
enum ANSWER {
  NONE = 0,
  NO = 0,    
  YES = 1   
};

enum VERB_LEVEL {
  VERB_NONE = 0,   
  VERB_MEDIUM = 1,   
  VERB_HIGH = 2         
};
static const map<string, VERB_LEVEL> Verb_Map = CCreateMap<string, VERB_LEVEL>
("NONE", VERB_NONE)
("MEDIUM", VERB_MEDIUM)
("HIGH", VERB_HIGH);

enum ENUM_SOLVER {
  NO_SOLVER = 0,                        
  EULER = 1,                            
  NAVIER_STOKES = 2,                    
  RANS = 3,                             
  POISSON_EQUATION = 4,                 
  WAVE_EQUATION = 10,                   
  HEAT_EQUATION = 29,                   
  FLUID_STRUCTURE_INTERACTION = 12,     
  FEM_ELASTICITY = 13,                  
  ADJ_EULER = 18,                       
  ADJ_NAVIER_STOKES = 19,               
  ADJ_RANS = 20,                        
  TEMPLATE_SOLVER = 30,                 
  DISC_ADJ_EULER = 35,
  DISC_ADJ_RANS = 36,
  DISC_ADJ_NAVIER_STOKES = 37
};
/* BEGIN_CONFIG_ENUMS */
static const map<string, ENUM_SOLVER> Solver_Map = CCreateMap<string, ENUM_SOLVER>
("NONE", NO_SOLVER)
("EULER", EULER)
("NAVIER_STOKES", NAVIER_STOKES)
("RANS", RANS)
("POISSON_EQUATION", POISSON_EQUATION)
("ADJ_EULER", ADJ_EULER)
("ADJ_NAVIER_STOKES", ADJ_NAVIER_STOKES)
("ADJ_RANS", ADJ_RANS )
("WAVE_EQUATION", WAVE_EQUATION)
("HEAT_EQUATION", HEAT_EQUATION)
("FEM_ELASTICITY", FEM_ELASTICITY)
("DISC_ADJ_EULER", DISC_ADJ_EULER)
("DISC_ADJ_RANS", DISC_ADJ_RANS)
("DISC_ADJ_NAVIERSTOKES", DISC_ADJ_EULER)
("FLUID_STRUCTURE_INTERACTION", FLUID_STRUCTURE_INTERACTION)

("TEMPLATE_SOLVER", TEMPLATE_SOLVER);


enum ENUM_FSI_FLUID_PROBLEM {
      NO_SOLVER_FFSI = 0,           
      EULER_FFSI = 1,               
      NAVIER_STOKES_FFSI = 2,       
      RANS_FFSI = 3                 
};
static const map<string, ENUM_FSI_FLUID_PROBLEM> FSI_Fluid_Solver_Map = CCreateMap<string, ENUM_FSI_FLUID_PROBLEM>
("NONE", NO_SOLVER_FFSI)
("EULER", EULER_FFSI)
("NAVIER_STOKES", NAVIER_STOKES_FFSI)
("RANS", RANS_FFSI);

enum ENUM_FSI_STRUC_PROBLEM {
  NO_SOLVER_SFSI = 0,               
  FEM_ELASTICITY_SFSI = 13,     
};
static const map<string, ENUM_FSI_STRUC_PROBLEM> FSI_Struc_Solver_Map = CCreateMap<string, ENUM_FSI_STRUC_PROBLEM>
("NONE", NO_SOLVER_SFSI)
("FEM_ELASTICITY", FEM_ELASTICITY_SFSI);

enum ENUM_STRUCT_SOLVER {
    SMALL_DEFORMATIONS = 0,         
    LARGE_DEFORMATIONS = 1,         
};
static const map<string, ENUM_STRUCT_SOLVER> Struct_Map = CCreateMap<string, ENUM_STRUCT_SOLVER>
("SMALL_DEFORMATIONS", SMALL_DEFORMATIONS)
("LARGE_DEFORMATIONS", LARGE_DEFORMATIONS);


enum ENUM_MATERIAL_MODEL {
    LINEAR_ELASTIC = 0,         
    NEO_HOOKEAN = 1,            
};
static const map<string, ENUM_MATERIAL_MODEL> Material_Map = CCreateMap<string, ENUM_MATERIAL_MODEL>
("LINEAR_ELASTIC", LINEAR_ELASTIC)
("NEO_HOOKEAN", NEO_HOOKEAN);

enum ENUM_MAT_COMPRESS {
  COMPRESSIBLE_MAT = 0,         
  INCOMPRESSIBLE_MAT = 1,       
};
static const map<string, ENUM_MAT_COMPRESS> MatComp_Map = CCreateMap<string, ENUM_MAT_COMPRESS>
("COMPRESSIBLE", COMPRESSIBLE_MAT)
("INCOMPRESSIBLE", INCOMPRESSIBLE_MAT);



enum ENUM_INTERPOLATOR {
  NEAREST_NEIGHBOR = 0,   
  ISOPARAMETRIC = 1, 
  CONSISTCONSERVE = 2,
};

static const map<string, ENUM_INTERPOLATOR> Interpolator_Map = CCreateMap<string, ENUM_INTERPOLATOR>
("NEAREST_NEIGHBOR", NEAREST_NEIGHBOR)
("ISOPARAMETRIC", ISOPARAMETRIC)
("CONSISTCONSERVE", CONSISTCONSERVE);


enum ENUM_REGIME {
  COMPRESSIBLE = 0,         
  INCOMPRESSIBLE = 1,               
};
static const map<string, ENUM_REGIME> Regime_Map = CCreateMap<string, ENUM_REGIME>
("COMPRESSIBLE", COMPRESSIBLE)
("INCOMPRESSIBLE", INCOMPRESSIBLE);
enum ENUM_KIND_NONDIM {
  DIMENSIONAL = 0,              
  FREESTREAM_PRESS_EQ_ONE = 1, 
  FREESTREAM_VEL_EQ_MACH = 2, 
  FREESTREAM_VEL_EQ_ONE = 3 
};
static const map<string, ENUM_KIND_NONDIM> NonDim_Map = CCreateMap<string, ENUM_KIND_NONDIM>
("DIMENSIONAL", DIMENSIONAL)
("FREESTREAM_PRESS_EQ_ONE", FREESTREAM_PRESS_EQ_ONE)
("FREESTREAM_VEL_EQ_MACH", FREESTREAM_VEL_EQ_MACH)
("FREESTREAM_VEL_EQ_ONE", FREESTREAM_VEL_EQ_ONE);

enum ENUM_MEASUREMENTS {
  SI = 0,           
  US = 1                
};
static const map<string, ENUM_MEASUREMENTS> Measurements_Map = CCreateMap<string, ENUM_MEASUREMENTS>
("SI", SI)
("US", US);

enum RUNTIME_TYPE {
  RUNTIME_FLOW_SYS = 2,         
  RUNTIME_TURB_SYS = 3,         
  RUNTIME_POISSON_SYS = 4,          
  RUNTIME_ADJPOT_SYS = 5,       
  RUNTIME_ADJFLOW_SYS = 6,      
  RUNTIME_ADJTURB_SYS = 7,      
  RUNTIME_WAVE_SYS = 8,     
  RUNTIME_MULTIGRID_SYS = 14,       
  RUNTIME_FEA_SYS = 20,     
  RUNTIME_HEAT_SYS = 21,        
  RUNTIME_TRANS_SYS = 22,           
};

const int FLOW_SOL = 0;     
const int ADJFLOW_SOL = 1;  
const int TURB_SOL = 2;     
const int ADJTURB_SOL = 3;  
const int TRANS_SOL = 4;    
const int POISSON_SOL = 2;      
const int WAVE_SOL = 1;     
const int HEAT_SOL = 2;     
const int FEA_SOL = 1;      
const int TEMPLATE_SOL = 0;     
const int CONV_TERM = 0;    
const int VISC_TERM = 1;        
const int SOURCE_FIRST_TERM = 2;        
const int SOURCE_SECOND_TERM = 3;   
const int CONV_BOUND_TERM = 4;       
const int VISC_BOUND_TERM = 5;       
const int FEA_TERM = 0;         
const int EL_TRIA = 0;      
const int EL_QUAD = 1;      
const int EL_TETRA = 0;     
const int EL_HEXA = 1;      
enum ENUM_MATH_PROBLEM {
  DIRECT = 0,       
  CONTINUOUS_ADJOINT = 1,       
  DISCRETE_ADJOINT = 2 /*< \brief AD-based discrete adjoint problem. */
};
static const map<string, ENUM_MATH_PROBLEM> Math_Problem_Map = CCreateMap<string, ENUM_MATH_PROBLEM>
("DIRECT", DIRECT)
("CONTINUOUS_ADJOINT", CONTINUOUS_ADJOINT)
("DISCRETE_ADJOINT", DISCRETE_ADJOINT);

enum ENUM_SPACE {
  NO_CONVECTIVE = 0, 
  SPACE_CENTERED = 1,       
  SPACE_UPWIND = 2      
};
static const map<string, ENUM_SPACE> Space_Map = CCreateMap<string, ENUM_SPACE>
("NONE", NO_CONVECTIVE)
("SPACE_CENTERED", SPACE_CENTERED)
("SPACE_UPWIND", SPACE_UPWIND);

enum ENUM_FLUIDMODEL {
    STANDARD_AIR = 0,
    IDEAL_GAS = 1, 
    VW_GAS = 2,
    PR_GAS = 3
};

static const map<string, ENUM_FLUIDMODEL> FluidModel_Map = CCreateMap<string, ENUM_FLUIDMODEL>
("STANDARD_AIR", STANDARD_AIR)
("IDEAL_GAS", IDEAL_GAS)
("VW_GAS", VW_GAS)
("PR_GAS", PR_GAS);

enum ENUM_INIT_OPTION {
    REYNOLDS = 0, 
    TD_CONDITIONS = 1

};

static const map<string, ENUM_INIT_OPTION> InitOption_Map = CCreateMap<string, ENUM_INIT_OPTION>
("REYNOLDS", REYNOLDS)
("TD_CONDITIONS", TD_CONDITIONS);

enum ENUM_FREESTREAM_OPTION {
    TEMPERATURE_FS = 0, 
    DENSITY_FS = 1

};

static const map<string, ENUM_FREESTREAM_OPTION> FreeStreamOption_Map = CCreateMap<string, ENUM_FREESTREAM_OPTION>
("TEMPERATURE_FS", TEMPERATURE_FS)
("DENSITY_FS", DENSITY_FS);

enum ENUM_VISCOSITYMODEL {
    CONSTANT_VISCOSITY = 0, 
    SUTHERLAND = 1
};

static const map<string, ENUM_VISCOSITYMODEL> ViscosityModel_Map = CCreateMap<string, ENUM_VISCOSITYMODEL>
("CONSTANT_VISCOSITY", CONSTANT_VISCOSITY)
("SUTHERLAND", SUTHERLAND);

enum ENUM_CONDUCTIVITYMODEL {
    CONSTANT_CONDUCTIVITY = 0, 
    CONSTANT_PRANDTL = 1
};

static const map<string, ENUM_CONDUCTIVITYMODEL> ConductivityModel_Map = CCreateMap<string, ENUM_CONDUCTIVITYMODEL>
("CONSTANT_CONDUCTIVITY", CONSTANT_CONDUCTIVITY)
("CONSTANT_PRANDTL", CONSTANT_PRANDTL);

enum ENUM_GRIDMOVEMENT {
  NO_MOVEMENT = 0, 
  DEFORMING = 1,        
  RIGID_MOTION = 2,     
  FLUID_STRUCTURE = 3,      
  EXTERNAL = 4,  
  EXTERNAL_ROTATION = 5,  
  AEROELASTIC = 6,    
  MOVING_WALL = 7,    
  ROTATING_FRAME = 8,    
  ELASTICITY = 9,    
  AEROELASTIC_RIGID_MOTION = 10, 
  STEADY_TRANSLATION = 11,    
  GUST = 12, 
  MOVING_HTP = 13    
};

static const map<string, ENUM_GRIDMOVEMENT> GridMovement_Map = CCreateMap<string, ENUM_GRIDMOVEMENT>
("NONE", NO_MOVEMENT)
("DEFORMING", DEFORMING)
("RIGID_MOTION", RIGID_MOTION)
("FLUID_STRUCTURE", FLUID_STRUCTURE)
("EXTERNAL", EXTERNAL)
("EXTERNAL_ROTATION", EXTERNAL_ROTATION)
("AEROELASTIC", AEROELASTIC)
("ROTATING_FRAME", ROTATING_FRAME)
("ELASTICITY", ELASTICITY)
("MOVING_WALL", MOVING_WALL)
("MOVING_HTP", MOVING_HTP)
("AEROELASTIC_RIGID_MOTION", AEROELASTIC_RIGID_MOTION)
("STEADY_TRANSLATION", STEADY_TRANSLATION)
("GUST", GUST);

enum ENUM_GUST_TYPE {
  NO_GUST = 0,      
  TOP_HAT = 1,      
  SINE = 2,         
  ONE_M_COSINE = 3, 
  VORTEX = 4,       
  EOG = 5           
};
static const map<string, ENUM_GUST_TYPE> Gust_Type_Map = CCreateMap<string, ENUM_GUST_TYPE>
("NONE", NO_GUST)
("TOP_HAT", TOP_HAT)
("SINE", SINE)
("ONE_M_COSINE", ONE_M_COSINE)
("VORTEX", VORTEX)
("EOG", EOG);

enum ENUM_GUST_DIR {
  X_DIR = 0,        
  Y_DIR = 1          
};
static const map<string, ENUM_GUST_DIR> Gust_Dir_Map = CCreateMap<string, ENUM_GUST_DIR>
("X_DIR", X_DIR)
("Y_DIR", Y_DIR);

// If you add to ENUM_CENTERED, you must also add the option to ENUM_CONVECTIVE
enum ENUM_CENTERED {
  NO_CENTERED = 0,    
  JST = 1,            
  LAX = 2,            
  JST_KE = 4          
};
static const map<string, ENUM_CENTERED> Centered_Map = CCreateMap<string, ENUM_CENTERED>
("NONE", NO_CENTERED)
("JST", JST)
("JST_KE", JST_KE)
("LAX-FRIEDRICH", LAX);


// If you add to ENUM_UPWIND, you must also add the option to ENUM_CONVECTIVE
enum ENUM_UPWIND {
  NO_UPWIND = 0,              
  ROE = 1,                    
  SCALAR_UPWIND = 2,          
  AUSM = 3,                   
  HLLC = 4,                   
  SW = 5,                     
  MSW = 6,                    
  TURKEL = 7,                 
  AUSMPWPLUS = 8,             
  CUSP = 9,                   
  CONVECTIVE_TEMPLATE = 10    
};
static const map<string, ENUM_UPWIND> Upwind_Map = CCreateMap<string, ENUM_UPWIND>
("NONE", NO_UPWIND)
("ROE", ROE)
("TURKEL_PREC", TURKEL)
("AUSM", AUSM)
("AUSMPW+", AUSMPWPLUS)
("HLLC", HLLC)
("SW", SW)
("MSW", MSW)
("CUSP", CUSP)
("SCALAR_UPWIND", SCALAR_UPWIND)
("CONVECTIVE_TEMPLATE", CONVECTIVE_TEMPLATE);

enum ENUM_SPATIAL_ORDER {
  FIRST_ORDER = 0,        
  SECOND_ORDER = 1,        
  SECOND_ORDER_LIMITER = 2 
};
static const map<string, ENUM_SPATIAL_ORDER> SpatialOrder_Map = CCreateMap<string, ENUM_SPATIAL_ORDER>
("1ST_ORDER", FIRST_ORDER)
("2ND_ORDER", SECOND_ORDER)
("2ND_ORDER_LIMITER", SECOND_ORDER_LIMITER);

enum ENUM_LIMITER {
  VENKATAKRISHNAN = 0,  
  BARTH_JESPERSEN = 1,  
  SHARP_EDGES = 2,       
  SOLID_WALL_DISTANCE = 3       
};
static const map<string, ENUM_LIMITER> Limiter_Map = CCreateMap<string, ENUM_LIMITER>
("VENKATAKRISHNAN", VENKATAKRISHNAN)
("BARTH_JESPERSEN", BARTH_JESPERSEN)
("SHARP_EDGES", SHARP_EDGES)
("WALL_DISTANCE", SOLID_WALL_DISTANCE);

enum ENUM_TURB_MODEL {
  NO_TURB_MODEL = 0, 
  SA      = 1, 
  SA_NEG  = 2, 
  SST     = 3, 
};
static const map<string, ENUM_TURB_MODEL> Turb_Model_Map = CCreateMap<string, ENUM_TURB_MODEL>
("NONE", NO_TURB_MODEL)
("SA", SA)
("SA_NEG", SA_NEG)
("SST", SST);

enum ENUM_TRANS_MODEL {
  NO_TRANS_MODEL = 0,            
  LM = 1,   
  BC = 2    
};
static const map<string, ENUM_TRANS_MODEL> Trans_Model_Map = CCreateMap<string, ENUM_TRANS_MODEL>
("NONE", NO_TRANS_MODEL)
("LM", LM)
("BC", BC); //BAS-CAKMAKCIOGLU

enum ENUM_TIME_INT {
  RUNGE_KUTTA_EXPLICIT = 1, 
  EULER_EXPLICIT = 2,       
  EULER_IMPLICIT = 3    
};
static const map<string, ENUM_TIME_INT> Time_Int_Map = CCreateMap<string, ENUM_TIME_INT>
("RUNGE-KUTTA_EXPLICIT", RUNGE_KUTTA_EXPLICIT)
("EULER_EXPLICIT", EULER_EXPLICIT)
("EULER_IMPLICIT", EULER_IMPLICIT);

enum ENUM_TIME_INT_FEA {
  CD_EXPLICIT = 1,          
  NEWMARK_IMPLICIT = 2,     
  GENERALIZED_ALPHA = 3         
};
static const map<string, ENUM_TIME_INT_FEA> Time_Int_Map_FEA = CCreateMap<string, ENUM_TIME_INT_FEA>
("CD_EXPLICIT", CD_EXPLICIT)
("NEWMARK_IMPLICIT", NEWMARK_IMPLICIT)
("GENERALIZED_ALPHA", GENERALIZED_ALPHA);

enum ENUM_SPACE_ITE_FEA {
  NEWTON_RAPHSON = 1,           
  MODIFIED_NEWTON_RAPHSON = 2   
};
static const map<string, ENUM_SPACE_ITE_FEA> Space_Ite_Map_FEA = CCreateMap<string, ENUM_SPACE_ITE_FEA>
("NEWTON_RAPHSON", NEWTON_RAPHSON)
("MODIFIED_NEWTON_RAPHSON", MODIFIED_NEWTON_RAPHSON);

enum ENUM_TRANSFER_METHOD {
  BROADCAST_DATA = 1,   
  SCATTER_DATA = 2,     
  ALLGATHER_DATA = 3,   
  LEGACY_METHOD = 4     
};
static const map<string, ENUM_TRANSFER_METHOD> Transfer_Method_Map = CCreateMap<string, ENUM_TRANSFER_METHOD>
("BROADCAST_DATA", BROADCAST_DATA)
("SCATTER_DATA", SCATTER_DATA)
("ALLGATHER_DATA", ALLGATHER_DATA)
("LEGACY_METHOD", LEGACY_METHOD);

enum ENUM_FLOW_GRADIENT {
  GREEN_GAUSS = 1,      
  WEIGHTED_LEAST_SQUARES = 2    
};
static const map<string, ENUM_FLOW_GRADIENT> Gradient_Map = CCreateMap<string, ENUM_FLOW_GRADIENT>
("GREEN_GAUSS", GREEN_GAUSS)
("WEIGHTED_LEAST_SQUARES", WEIGHTED_LEAST_SQUARES);

enum GEOMETRY_ACTION {
  ALLOCATE = 0,     
  UPDATE = 1       
};

enum GEOMETRY_MODE {
  FUNCTION = 0,     
  GRADIENT = 1      
};
static const map<string, GEOMETRY_MODE> GeometryMode_Map = CCreateMap<string, GEOMETRY_MODE>
("FUNCTION", FUNCTION)
("GRADIENT", GRADIENT);

enum BC_TYPE {
  EULER_WALL = 1,       
  FAR_FIELD = 2,        
  SYMMETRY_PLANE = 3,       
  INLET_FLOW = 4,       
  OUTLET_FLOW = 5,      
  PERIODIC_BOUNDARY = 6,    
  NEARFIELD_BOUNDARY = 7,   
  ELECTRODE_BOUNDARY = 8,   
  DIELEC_BOUNDARY = 9,  
  CUSTOM_BOUNDARY = 10,         
  INTERFACE_BOUNDARY = 11,  
  DIRICHLET = 12,       
  NEUMANN = 13,     
  DISPLACEMENT_BOUNDARY = 14,       
  LOAD_BOUNDARY = 15,       
  FLOWLOAD_BOUNDARY = 16,       
  SUPERSONIC_INLET = 19,        
  SUPERSONIC_OUTLET = 20,       
  ENGINE_INFLOW = 21,       
  ENGINE_EXHAUST = 22,      
  RIEMANN_BOUNDARY= 24,   
  ISOTHERMAL = 25,      
  HEAT_FLUX  = 26,      
  PRESSURE_BOUNDARY = 27,       
  ACTDISK_INLET = 32,   
  ACTDISK_OUTLET = 33,  
  CLAMPED_BOUNDARY = 34,        
  LOAD_DIR_BOUNDARY = 35,       
  LOAD_SINE_BOUNDARY = 36,      
  NRBC_BOUNDARY= 37,   
  INTERNAL_BOUNDARY= 38,   
  FLUID_INTERFACE = 39, 
  SEND_RECEIVE = 99,        
};


enum ENUM_2DFORM {
  PLANE_STRESS = 0,         
  PLANE_STRAIN = 1          
};
static const map<string, ENUM_2DFORM> ElasForm_2D = CCreateMap<string, ENUM_2DFORM>
("PLANE_STRESS", PLANE_STRESS)
("PLANE_STRAIN", PLANE_STRAIN);


enum ENUM_AITKEN {
  NO_RELAXATION = 0,            
  FIXED_PARAMETER = 1,          
  AITKEN_DYNAMIC = 2            
};
static const map<string, ENUM_AITKEN> AitkenForm_Map = CCreateMap<string, ENUM_AITKEN>
("NONE", NO_RELAXATION)
("FIXED_PARAMETER", FIXED_PARAMETER)
("AITKEN_DYNAMIC", AITKEN_DYNAMIC);



enum RIEMANN_TYPE {
  TOTAL_CONDITIONS_PT = 1,      
  DENSITY_VELOCITY = 2,         
  STATIC_PRESSURE = 3,           
  TOTAL_SUPERSONIC_INFLOW = 4,  
  STATIC_SUPERSONIC_INFLOW_PT = 5, 
  STATIC_SUPERSONIC_INFLOW_PD = 6, 
  MIXING_IN = 7, 
  MIXING_OUT = 8 
};

static const map<string, RIEMANN_TYPE> Riemann_Map = CCreateMap<string, RIEMANN_TYPE>
("TOTAL_CONDITIONS_PT", TOTAL_CONDITIONS_PT)
("DENSITY_VELOCITY", DENSITY_VELOCITY)
("STATIC_PRESSURE", STATIC_PRESSURE)
("TOTAL_SUPERSONIC_INFLOW", TOTAL_SUPERSONIC_INFLOW)
("STATIC_SUPERSONIC_INFLOW_PT", STATIC_SUPERSONIC_INFLOW_PT)
("STATIC_SUPERSONIC_INFLOW_PD", STATIC_SUPERSONIC_INFLOW_PD)
("MIXING_IN", MIXING_IN)
("MIXING_OUT", MIXING_OUT);


static const map<string, RIEMANN_TYPE> NRBC_Map = CCreateMap<string, RIEMANN_TYPE>
("TOTAL_CONDITIONS_PT", TOTAL_CONDITIONS_PT)
("DENSITY_VELOCITY", DENSITY_VELOCITY)
("STATIC_PRESSURE", STATIC_PRESSURE)
("TOTAL_SUPERSONIC_INFLOW", TOTAL_SUPERSONIC_INFLOW)
("STATIC_SUPERSONIC_INFLOW_PT", STATIC_SUPERSONIC_INFLOW_PT)
("STATIC_SUPERSONIC_INFLOW_PD", STATIC_SUPERSONIC_INFLOW_PD)
("MIXING_IN", MIXING_IN)
("MIXING_OUT", MIXING_OUT);


enum MIXINGPROCESS_TYPE {
  ALGEBRAIC_AVERAGE = 1,        
  AREA_AVERAGE = 2,           
  MIXEDOUT_AVERAGE = 3       
};

static const map<string, MIXINGPROCESS_TYPE> MixingProcess_Map = CCreateMap<string, MIXINGPROCESS_TYPE>
("ALGEBRAIC_AVERAGE", ALGEBRAIC_AVERAGE)
("AREA_AVERAGE", AREA_AVERAGE)
("MIXEDOUT_AVERAGE",  MIXEDOUT_AVERAGE);

enum TURBO_PERFORMANCE_TYPE {
  BLADE   = 1,      
  STAGE = 2,      
  TURBINE              = 3      
};

static const map<string, TURBO_PERFORMANCE_TYPE> TurboPerformance_Map = CCreateMap<string, TURBO_PERFORMANCE_TYPE>
("BLADE", BLADE)
("STAGE", STAGE)
("TURBINE", TURBINE);

enum INLET_TYPE {
  TOTAL_CONDITIONS = 1,     
  MASS_FLOW = 2,           
  INPUT_FILE = 3           
};
static const map<string, INLET_TYPE> Inlet_Map = CCreateMap<string, INLET_TYPE>
("TOTAL_CONDITIONS", TOTAL_CONDITIONS)
("MASS_FLOW", MASS_FLOW)
("INPUT_FILE", INPUT_FILE);

enum ENGINE_INFLOW_TYPE {
  FAN_FACE_MACH = 1,             
  FAN_FACE_MDOT = 2,           
  FAN_FACE_PRESSURE = 3        
};
static const map<string, ENGINE_INFLOW_TYPE> Engine_Inflow_Map = CCreateMap<string, ENGINE_INFLOW_TYPE>
("FAN_FACE_MACH", FAN_FACE_MACH)
("FAN_FACE_MDOT", FAN_FACE_MDOT)
("FAN_FACE_PRESSURE", FAN_FACE_PRESSURE);

enum ACTDISK_TYPE {
  VARIABLES_JUMP = 1,       
  BC_THRUST = 2,     
  NET_THRUST = 3,     
  DRAG_MINUS_THRUST = 4,     
  MASSFLOW = 5,     
  POWER = 6     
};
static const map<string, ACTDISK_TYPE> ActDisk_Map = CCreateMap<string, ACTDISK_TYPE>
("VARIABLES_JUMP", VARIABLES_JUMP)
("BC_THRUST", BC_THRUST)
("NET_THRUST", NET_THRUST)
("DRAG_MINUS_THRUST", DRAG_MINUS_THRUST)
("MASSFLOW", MASSFLOW)
("POWER", POWER);

enum GEO_TYPE {
  VERTEX = 1,           
  LINE = 3,         
  TRIANGLE = 5,         
  QUADRILATERAL = 9,        
  TETRAHEDRON = 10,         
  HEXAHEDRON = 12,          
  PRISM = 13,           
  PYRAMID = 14          
};

enum ENUM_OBJECTIVE {
  DRAG_COEFFICIENT = 1,           
  LIFT_COEFFICIENT = 2,           
  SIDEFORCE_COEFFICIENT = 3,      
  EFFICIENCY = 4,                   
  INVERSE_DESIGN_PRESSURE = 5,  
  INVERSE_DESIGN_HEATFLUX = 6,  
  TOTAL_HEATFLUX = 7,           
  MAXIMUM_HEATFLUX = 8,         
  MOMENT_X_COEFFICIENT = 9,     
  MOMENT_Y_COEFFICIENT = 10,    
  MOMENT_Z_COEFFICIENT = 11,    
  EQUIVALENT_AREA = 12,           
  NEARFIELD_PRESSURE = 13,      
  FORCE_X_COEFFICIENT = 14,     
  FORCE_Y_COEFFICIENT = 15,     
  FORCE_Z_COEFFICIENT = 16,     
  THRUST_COEFFICIENT = 17,        
  TORQUE_COEFFICIENT = 18,        
  FIGURE_OF_MERIT = 19,           
  MAX_THICKNESS = 21,           
  MIN_THICKNESS = 22,           
  MAX_THICK_SEC1 = 23,          
  MAX_THICK_SEC2 = 24,          
  MAX_THICK_SEC3 = 25,          
  MAX_THICK_SEC4 = 26,          
  MAX_THICK_SEC5 = 27,           
  AVG_TOTAL_PRESSURE = 28,      
  AVG_OUTLET_PRESSURE = 29,      
  MASS_FLOW_RATE = 30,           
  OUTFLOW_GENERALIZED = 31,       
  AERO_DRAG_COEFFICIENT = 35,     
  RADIAL_DISTORTION = 36,         
  CIRCUMFERENTIAL_DISTORTION = 37  
};

static const map<string, ENUM_OBJECTIVE> Objective_Map = CCreateMap<string, ENUM_OBJECTIVE>
("DRAG", DRAG_COEFFICIENT)
("LIFT", LIFT_COEFFICIENT)
("SIDEFORCE", SIDEFORCE_COEFFICIENT)
("EFFICIENCY", EFFICIENCY)
("INVERSE_DESIGN_PRESSURE", INVERSE_DESIGN_PRESSURE)
("INVERSE_DESIGN_HEATFLUX", INVERSE_DESIGN_HEATFLUX)
("MOMENT_X", MOMENT_X_COEFFICIENT)
("MOMENT_Y", MOMENT_Y_COEFFICIENT)
("MOMENT_Z", MOMENT_Z_COEFFICIENT)
("EQUIVALENT_AREA", EQUIVALENT_AREA)
("NEARFIELD_PRESSURE", NEARFIELD_PRESSURE)
("FORCE_X", FORCE_X_COEFFICIENT)
("FORCE_Y", FORCE_Y_COEFFICIENT)
("FORCE_Z", FORCE_Z_COEFFICIENT)
("THRUST", THRUST_COEFFICIENT)
("TORQUE", TORQUE_COEFFICIENT)
("TOTAL_HEATFLUX", TOTAL_HEATFLUX)
("MAXIMUM_HEATFLUX", MAXIMUM_HEATFLUX)
("FIGURE_OF_MERIT", FIGURE_OF_MERIT)
("MAX_THICKNESS", MAX_THICKNESS)
("MIN_THICKNESS", MIN_THICKNESS)
("MAX_THICK_SEC1", MAX_THICK_SEC1)
("MAX_THICK_SEC2", MAX_THICK_SEC2)
("MAX_THICK_SEC3", MAX_THICK_SEC3)
("MAX_THICK_SEC4", MAX_THICK_SEC4)
("MAX_THICK_SEC5", MAX_THICK_SEC5)
("AVG_TOTAL_PRESSURE", AVG_TOTAL_PRESSURE)
("AVG_OUTLET_PRESSURE", AVG_OUTLET_PRESSURE)
("MASS_FLOW_RATE", MASS_FLOW_RATE)
("OUTFLOW_GENERALIZED", OUTFLOW_GENERALIZED)
("AERO_DRAG", AERO_DRAG_COEFFICIENT)
("RADIAL_DISTORTION", RADIAL_DISTORTION)
("CIRCUMFERENTIAL_DISTORTION", CIRCUMFERENTIAL_DISTORTION);

enum ENUM_RESIDUAL {
    RHO_RESIDUAL = 1,         
    RHO_ENERGY_RESIDUAL = 2           
};

static const map<string, ENUM_RESIDUAL> Residual_Map = CCreateMap<string, ENUM_RESIDUAL>
("RHO", RHO_RESIDUAL)
("RHO_ENERGY", RHO_ENERGY_RESIDUAL);

enum ENUM_SENS {
  SENS_GEOMETRY = 1,        
  SENS_MACH = 2,        
  SENS_AOA = 3,         
  SENS_AOS = 4          
};
static const map<string, ENUM_SENS> Sens_Map = CCreateMap<string, ENUM_SENS>
("SENS_GEOMETRY", SENS_GEOMETRY)
("SENS_MACH", SENS_MACH)
("SENS_AOA", SENS_AOA)
("SENS_AOS", SENS_AOS);

enum ENUM_ADAPT {
  NO_ADAPT = 0,                 
  FULL = 1,         
  FULL_FLOW = 2,        
  FULL_ADJOINT = 3,     
  GRAD_FLOW = 5,        
  GRAD_ADJOINT = 6,     
  GRAD_FLOW_ADJ = 7,        
  COMPUTABLE = 9,       
  REMAINING = 10,       
  WAKE = 12,            
  SMOOTHING = 14,       
  SUPERSONIC_SHOCK = 15,    
  PERIODIC = 17         
};
static const map<string, ENUM_ADAPT> Adapt_Map = CCreateMap<string, ENUM_ADAPT>
("NONE", NO_ADAPT)
("FULL", FULL)
("FULL_FLOW", FULL_FLOW)
("FULL_ADJOINT", FULL_ADJOINT)
("GRAD_FLOW", GRAD_FLOW)
("GRAD_ADJOINT", GRAD_ADJOINT)
("GRAD_FLOW_ADJ", GRAD_FLOW_ADJ)
("COMPUTABLE", COMPUTABLE)
("REMAINING", REMAINING)
("WAKE", WAKE)
("SMOOTHING", SMOOTHING)
("SUPERSONIC_SHOCK", SUPERSONIC_SHOCK)
("PERIODIC", PERIODIC);

enum ENUM_INPUT {
  SU2 = 1,                       
  CGNS = 2                     
};
static const map<string, ENUM_INPUT> Input_Map = CCreateMap<string, ENUM_INPUT>
("SU2", SU2)
("CGNS", CGNS);

const int CGNS_STRING_SIZE = 33;
enum ENUM_OUTPUT {
  TECPLOT = 1,               
  TECPLOT_BINARY = 2,    
  FIELDVIEW = 3,           
  FIELDVIEW_BINARY = 4,  
  CSV = 5,                   
  CGNS_SOL = 6,              
  PARAVIEW = 7               
};
static const map<string, ENUM_OUTPUT> Output_Map = CCreateMap<string, ENUM_OUTPUT>
("TECPLOT", TECPLOT)
("TECPLOT_BINARY", TECPLOT_BINARY)
("FIELDVIEW", FIELDVIEW)
("FIELDVIEW_BINARY", FIELDVIEW_BINARY)
("CSV", CSV)
("CGNS", CGNS_SOL)
("PARAVIEW", PARAVIEW);

enum JUMP_DEFINITION {
  DIFFERENCE = 1,     
  RATIO = 2           
};
static const map<string, JUMP_DEFINITION> Jump_Map = CCreateMap<string, JUMP_DEFINITION>
("DIFFERENCE", DIFFERENCE)
("RATIO", RATIO);

enum MG_CYCLE {
  V_CYCLE = 0,          
  W_CYCLE = 1,          
  FULLMG_CYCLE = 2  
};
static const map<string, MG_CYCLE> MG_Cycle_Map = CCreateMap<string, MG_CYCLE>
("V_CYCLE", V_CYCLE)
("W_CYCLE", W_CYCLE)
("FULLMG_CYCLE", FULLMG_CYCLE);

enum ENUM_OUTPUT_VARS {
  DENSITY = 1,      
  VEL_X = 2,        
  VEL_Y = 3,        
  VEL_Z = 4,        
  PRESSURE = 5,         
  MACH = 6,         
  TEMPERATURE = 7,  
  LAM_VISC = 8,     
  EDDY_VISC = 9     
};
static const map<string, ENUM_OUTPUT_VARS> Output_Vars_Map = CCreateMap<string, ENUM_OUTPUT_VARS>
("DENSITY", DENSITY)
("VEL_X", VEL_X)
("VEL_Y", VEL_Y)
("VEL_Z", VEL_Z)
("PRESSURE", PRESSURE)
("MACH", MACH)
("TEMPERATURE", TEMPERATURE)
("LAM_VISC", LAM_VISC)
("EDDY_VISC", EDDY_VISC);

enum ENUM_PARAM {
  TRANSLATION = 0,             
  ROTATION = 1,                  
  SCALE = 2,                       
  FFD_SETTING = 3,             
  FFD_CONTROL_POINT = 4,       
  FFD_NACELLE = 5,           
  FFD_GULL = 6,              
  FFD_CAMBER = 7,                
  FFD_TWIST = 8,                 
  FFD_THICKNESS = 9,             
  FFD_DIHEDRAL_ANGLE = 10,   
  FFD_ROTATION = 11,             
  FFD_CONTROL_POINT_2D = 12, 
  FFD_CAMBER_2D = 13,            
  FFD_THICKNESS_2D = 14,         
  FFD_TWIST_2D = 15,             
  FFD_CONTROL_SURFACE = 16,  
  HICKS_HENNE = 17,          
  PARABOLIC = 18,                
  NACA_4DIGITS = 19,           
  AIRFOIL = 20,                
  CST = 21,                  
  SURFACE_BUMP = 22,           
  SURFACE_FILE = 23,             
  CUSTOM = 24,               
  NO_DEFORMATION = 25,         
  ANGLE_OF_ATTACK = 101,       
  FFD_ANGLE_OF_ATTACK = 102  
};
static const map<string, ENUM_PARAM> Param_Map = CCreateMap<string, ENUM_PARAM>
("FFD_SETTING", FFD_SETTING)
("FFD_CONTROL_POINT_2D", FFD_CONTROL_POINT_2D)
("FFD_TWIST_2D", FFD_TWIST_2D)
("FFD_ANGLE_OF_ATTACK", FFD_ANGLE_OF_ATTACK)
("FFD_CAMBER_2D", FFD_CAMBER_2D)
("FFD_THICKNESS_2D", FFD_THICKNESS_2D)
("HICKS_HENNE", HICKS_HENNE)
("SURFACE_BUMP", SURFACE_BUMP)
("ANGLE_OF_ATTACK", ANGLE_OF_ATTACK)
("NACA_4DIGITS", NACA_4DIGITS)
("TRANSLATION", TRANSLATION)
("ROTATION", ROTATION)
("SCALE", SCALE)
("FFD_CONTROL_POINT", FFD_CONTROL_POINT)
("FFD_DIHEDRAL_ANGLE", FFD_DIHEDRAL_ANGLE)
("FFD_ROTATION", FFD_ROTATION)
("FFD_CONTROL_SURFACE", FFD_CONTROL_SURFACE)
("FFD_NACELLE", FFD_NACELLE)
("FFD_GULL", FFD_GULL)
("FFD_TWIST", FFD_TWIST)
("FFD_CAMBER", FFD_CAMBER)
("FFD_THICKNESS", FFD_THICKNESS)
("PARABOLIC", PARABOLIC)
("AIRFOIL", AIRFOIL)
("SURFACE_FILE", SURFACE_FILE)
("CUSTOM", CUSTOM)
("NO_DEFORMATION", NO_DEFORMATION)
("CST", CST);


enum ENUM_FFD_BLENDING{
  BSPLINE_UNIFORM = 0,
  BEZIER = 1,
};
static const map<string, ENUM_FFD_BLENDING> Blending_Map = CCreateMap<string, ENUM_FFD_BLENDING>
("BSPLINE_UNIFORM", BSPLINE_UNIFORM)
("BEZIER", BEZIER);

enum ENUM_LINEAR_SOLVER {
  STEEPEST_DESCENT = 1,     
  NEWTON = 2,           
  QUASI_NEWTON = 3,     
  CONJUGATE_GRADIENT = 4,   
  FGMRES = 5,       
  BCGSTAB = 6,  
  RESTARTED_FGMRES = 7,  
  SMOOTHER_LUSGS = 8,  
  SMOOTHER_JACOBI = 9,  
  SMOOTHER_ILU = 10,  
  SMOOTHER_LINELET = 11  
};
static const map<string, ENUM_LINEAR_SOLVER> Linear_Solver_Map = CCreateMap<string, ENUM_LINEAR_SOLVER>
("STEEPEST_DESCENT", STEEPEST_DESCENT)
("NEWTON", NEWTON)
("QUASI_NEWTON", QUASI_NEWTON)
("CONJUGATE_GRADIENT", CONJUGATE_GRADIENT)
("BCGSTAB", BCGSTAB)
("FGMRES", FGMRES)
("RESTARTED_FGMRES", RESTARTED_FGMRES)
("SMOOTHER_LUSGS", SMOOTHER_LUSGS)
("SMOOTHER_JACOBI", SMOOTHER_JACOBI)
("SMOOTHER_LINELET", SMOOTHER_LINELET)
("SMOOTHER_ILU0", SMOOTHER_ILU);

enum ENUM_FFD_CONTINUITY {
  DERIVATIVE_NONE = 0,      
  DERIVATIVE_1ST = 1,       
  DERIVATIVE_2ND = 2,   
  USER_INPUT = 3                  
};
static const map<string, ENUM_FFD_CONTINUITY> Continuity_Map = CCreateMap<string, ENUM_FFD_CONTINUITY>
("NO_DERIVATIVE", DERIVATIVE_NONE)
("1ST_DERIVATIVE", DERIVATIVE_1ST)
("2ND_DERIVATIVE", DERIVATIVE_2ND)
("USER_INPUT", USER_INPUT);

enum ENUM_FFD_COORD_SYSTEM {
  CARTESIAN = 0,
  CYLINDRICAL = 1,
  SPHERICAL = 2
};
static const map<string, ENUM_FFD_COORD_SYSTEM> CoordSystem_Map = CCreateMap<string, ENUM_FFD_COORD_SYSTEM>
("CARTESIAN", CARTESIAN)
("CYLINDRICAL", CYLINDRICAL)
("SPHERICAL", SPHERICAL);

enum ENUM_SENS_SMOOTHING {
  NO_SMOOTH = 0,        
  SOBOLEV = 1,      
  BIGRID = 2    
};
static const map<string, ENUM_SENS_SMOOTHING> Sens_Smoothing_Map = CCreateMap<string, ENUM_SENS_SMOOTHING>
("NONE", NO_SMOOTH)
("SOBOLEV", SOBOLEV)
("BIGRID", BIGRID);

enum ENUM_LINEAR_SOLVER_PREC {
  JACOBI = 1,       
  LU_SGS = 2,       
  LINELET = 3,  
  ILU = 4       
};
static const map<string, ENUM_LINEAR_SOLVER_PREC> Linear_Solver_Prec_Map = CCreateMap<string, ENUM_LINEAR_SOLVER_PREC>
("JACOBI", JACOBI)
("LU_SGS", LU_SGS)
("LINELET", LINELET)
("ILU0", ILU);

enum ENUM_GEO_ANALYTIC {
  NO_GEO_ANALYTIC = 0,          
  NACA0012_AIRFOIL = 1,     
  NACA4412_AIRFOIL = 2,     
  CYLINDER = 3,         
  BIPARABOLIC = 4           
};
static const map<string, ENUM_GEO_ANALYTIC> Geo_Analytic_Map = CCreateMap<string, ENUM_GEO_ANALYTIC>
("NONE", NO_GEO_ANALYTIC)
("NACA0012_AIRFOIL", NACA0012_AIRFOIL)
("NACA4412_AIRFOIL", NACA4412_AIRFOIL)
("CYLINDER", CYLINDER)
("BIPARABOLIC", BIPARABOLIC);

enum ENUM_AXIS_ORIENTATION {
  X_AXIS = 0,   
  Y_AXIS = 1,   
  Z_AXIS = 2    
};
static const map<string, ENUM_AXIS_ORIENTATION> Axis_Stations_Map = CCreateMap<string, ENUM_AXIS_ORIENTATION>
("X_AXIS", X_AXIS)
("Y_AXIS", Y_AXIS)
("Z_AXIS", Z_AXIS);

enum ENUM_UNSTEADY {
  STEADY = 0,            
  TIME_STEPPING = 1,         
  DT_STEPPING_1ST = 2,   
  DT_STEPPING_2ND = 3,   
  ROTATIONAL_FRAME = 4,  
  HARMONIC_BALANCE = 5    
};
static const map<string, ENUM_UNSTEADY> Unsteady_Map = CCreateMap<string, ENUM_UNSTEADY>
("NO", STEADY)
("TIME_STEPPING", TIME_STEPPING)
("DUAL_TIME_STEPPING-1ST_ORDER", DT_STEPPING_1ST)
("DUAL_TIME_STEPPING-2ND_ORDER", DT_STEPPING_2ND)
("HARMONIC_BALANCE", HARMONIC_BALANCE)
("ROTATIONAL_FRAME", ROTATIONAL_FRAME);

enum ENUM_CONVERGE_CRIT {
  CAUCHY = 1,           
  RESIDUAL = 2          
};
static const map<string, ENUM_CONVERGE_CRIT> Converge_Crit_Map = CCreateMap<string, ENUM_CONVERGE_CRIT>
("CAUCHY", CAUCHY)
("RESIDUAL", RESIDUAL);

enum ENUM_DEFORM_STIFFNESS {
  CONSTANT_STIFFNESS = 0,               
  INVERSE_VOLUME = 1,           
  WALL_DISTANCE = 2         
};
static const map<string, ENUM_DEFORM_STIFFNESS> Deform_Stiffness_Map = CCreateMap<string, ENUM_DEFORM_STIFFNESS>
("CONSTANT_STIFFNESS", CONSTANT_STIFFNESS)
("INVERSE_VOLUME", INVERSE_VOLUME)
("WALL_DISTANCE", WALL_DISTANCE);

enum ENUM_DIRECTDIFF_VAR {
  NO_DERIVATIVE = 0,
  D_MACH = 1,   
  D_AOA = 2,         
  D_PRESSURE = 3, 
  D_TEMPERATURE = 4,
  D_DENSITY = 5,
  D_TURB2LAM = 6,
  D_SIDESLIP = 7,
  D_VISCOSITY = 8,
  D_REYNOLDS = 9,
  D_DESIGN = 10
};
static const map<string, ENUM_DIRECTDIFF_VAR> DirectDiff_Var_Map = CCreateMap<string, ENUM_DIRECTDIFF_VAR>
("NONE", NO_DERIVATIVE)
("MACH", D_MACH)
("AOA", D_AOA)
("PRESSURE", D_PRESSURE)
("TEMPERATURE", D_TEMPERATURE)
("DENSITY", D_DENSITY)
("TURB2LAM", D_TURB2LAM)
("SIDESLIP", D_SIDESLIP)
("VISCOSITY", D_VISCOSITY)
("REYNOLDS", D_REYNOLDS)
("DESIGN_VARIABLES", D_DESIGN);

enum ENUM_DYNAMIC {
  STATIC = 0,             
  DYNAMIC = 1             
};
static const map<string, ENUM_DYNAMIC> Dynamic_Map = CCreateMap<string, ENUM_DYNAMIC>
("NO", STATIC)
("YES", DYNAMIC);

/* END_CONFIG_ENUMS */

class COptionBase {
private:
public:
  COptionBase() {};
  virtual  ~COptionBase() = 0;
  //  virtual string SetValue(string) {SU2MPI::PrintAndFinalize("shouldn't be here"); return "";};
  virtual string SetValue(vector<string>) = 0;
  virtual void SetDefault() = 0;

  string optionCheckMultipleValues(vector<string> & option_value, string type_id, string option_name) {
    if (option_value.size() != 1) {
      string newString;
      newString.append(option_name);
      newString.append(": multiple values for type ");
      newString.append(type_id);
      return newString;
    }
    return "";
  }

  string badValue(vector<string> & option_value, string type_id, string option_name) {
    string newString;
    newString.append(option_name);
    newString.append(": improper option value for type ");
    newString.append(type_id);
    return newString;
  }
};

inline COptionBase::~COptionBase() {}


template <class Tenum>
class COptionEnum : public COptionBase {

  map<string, Tenum> m;
  unsigned short & field; // Reference to the feildname
  Tenum def; // Default value
  string name; // identifier for the option

public:
  COptionEnum(string option_field_name, const map<string, Tenum> m, unsigned short & option_field, Tenum default_value) : field(option_field) {
    this->m = m;
    this->def = default_value;
    this->name = option_field_name;
  }

  ~COptionEnum() {};
  string SetValue(vector<string> option_value) {
    // Check if there is more than one string
    string out = optionCheckMultipleValues(option_value, "enum", this->name);
    if (out.compare("") != 0) {
      return out;
    }

    // Check to see if the enum value is in the map
    if (this->m.find(option_value[0]) == m.end()) {
      string str;
      str.append(this->name);
      str.append(": invalid option value ");
      str.append(option_value[0]);
      str.append(". Check current SU2 options in config_template.cfg.");
      return str;
    }
    // If it is there, set the option value
    Tenum val = this->m[option_value[0]];
    this->field = val;
    return "";
  }

  void SetDefault() {
    this->field = this->def;
  }
};

class COptionDouble : public COptionBase {
  su2double & field; // Reference to the fieldname
  su2double def; // Default value
  string name; // identifier for the option

public:
  COptionDouble(string option_field_name, su2double & option_field, su2double default_value) : field(option_field) {
    this->def = default_value;
    this->name = option_field_name;
  }

  ~COptionDouble() {};
  string SetValue(vector<string> option_value) {
    // check if there is more than one value
    string out = optionCheckMultipleValues(option_value, "su2double", this->name);
    if (out.compare("") != 0) {
      return out;
    }
    istringstream is(option_value[0]);
    su2double val;
    if (is >> val) {
      this->field = val;
      return "";
    }
    return badValue(option_value, "su2double", this->name);
  }
  void SetDefault() {
    this->field = this->def;
  }
};

class COptionString : public COptionBase {
  string & field; // Reference to the fieldname
  string def; // Default value
  string name; // identifier for the option

public:
  COptionString(string option_field_name, string & option_field, string default_value) : field(option_field) {
    this->def = default_value;
    this->name = option_field_name;
  }

  ~COptionString() {};
  string SetValue(vector<string> option_value) {
    // check if there is more than one value
    string out = optionCheckMultipleValues(option_value, "su2double", this->name);
    if (out.compare("") != 0) {
      return out;
    }
    this->field.assign(option_value[0]);
    return "";
  }
  void SetDefault() {
    this->field = this->def;
  }
};

class COptionInt : public COptionBase {
  int & field; // Reference to the feildname
  int def; // Default value
  string name; // identifier for the option

public:
  COptionInt(string option_field_name, int & option_field, int default_value) : field(option_field) {
    this->def = default_value;
    this->name = option_field_name;
  }

  ~COptionInt() {};
  string SetValue(vector<string> option_value) {
    string out = optionCheckMultipleValues(option_value, "int", this->name);
    if (out.compare("") != 0) {
      return out;
    }
    istringstream is(option_value[0]);
    int val;
    if (is >> val) {
      this->field = val;
      return "";
    }
    return badValue(option_value, "int", this->name);
  }
  void SetDefault() {
    this->field = this->def;
  }
};

class COptionULong : public COptionBase {
  unsigned long & field; // Reference to the feildname
  unsigned long def; // Default value
  string name; // identifier for the option

public:
  COptionULong(string option_field_name, unsigned long & option_field, unsigned long default_value) : field(option_field) {
    this->def = default_value;
    this->name = option_field_name;
  }

  ~COptionULong() {};
  string SetValue(vector<string> option_value) {
    string out = optionCheckMultipleValues(option_value, "unsigned long", this->name);
    if (out.compare("") != 0) {
      return out;
    }
    istringstream is(option_value[0]);
    unsigned long val;
    if (is >> val) {
      this->field = val;
      return "";
    }
    return badValue(option_value, "unsigned long", this->name);
  }
  void SetDefault() {
    this->field = this->def;
  }
};

class COptionUShort : public COptionBase {
  unsigned short & field; // Reference to the feildname
  unsigned short def; // Default value
  string name; // identifier for the option

public:
  COptionUShort(string option_field_name, unsigned short & option_field, unsigned short default_value) : field(option_field) {
    this->def = default_value;
    this->name = option_field_name;
  }

  ~COptionUShort() {};
  string SetValue(vector<string> option_value) {
    string out = optionCheckMultipleValues(option_value, "unsigned short", this->name);
    if (out.compare("") != 0) {
      return out;
    }
    istringstream is(option_value[0]);
    unsigned short val;
    if (is >> val) {
      this->field = val;
      return "";
    }
    return badValue(option_value, "unsigned short", this->name);
  }
  void SetDefault() {
    this->field = this->def;
  }
};

class COptionLong : public COptionBase {
  long & field; // Reference to the feildname
  long def; // Default value
  string name; // identifier for the option

public:
  COptionLong(string option_field_name, long & option_field, long default_value) : field(option_field) {
    this->def = default_value;
    this->name = option_field_name;
  }

  ~COptionLong() {};
  string SetValue(vector<string> option_value) {
    string out = optionCheckMultipleValues(option_value, "long", this->name);
    if (out.compare("") != 0) {
      return out;
    }
    istringstream is(option_value[0]);
    long val;
    if (is >> val) {
      this->field = val;
      return "";
    }
    return badValue(option_value, "long", this->name);
  }
  void SetDefault() {
    this->field = this->def;
  }
};


class COptionBool : public COptionBase {
  bool & field; // Reference to the feildname
  bool def; // Default value
  string name; // identifier for the option

public:
  COptionBool(string option_field_name, bool & option_field, bool default_value) : field(option_field) {
    this->def = default_value;
    this->name = option_field_name;
  }

  ~COptionBool() {};
  string SetValue(vector<string> option_value) {
    // check if there is more than one value
    string out = optionCheckMultipleValues(option_value, "bool", this->name);
    if (out.compare("") != 0) {
      return out;
    }
    if (option_value[0].compare("YES") == 0) {
      this->field = true;
      return "";
    }
    if (option_value[0].compare("NO") == 0) {
      this->field = false;
      return "";
    }
    return badValue(option_value, "bool", this->name);
  }
  void SetDefault() {
    this->field = this->def;
  }
};

template <class Tenum>
class COptionEnumList : public COptionBase {

  map<string, Tenum> m;
  unsigned short * & field; // Reference to the feildname
  string name; // identifier for the option
  unsigned short & size;

public:
  COptionEnumList(string option_field_name, const map<string, Tenum> m, unsigned short * & option_field, unsigned short & list_size) : field(option_field) , size(list_size) {
    this->m = m;
    this->name = option_field_name;
  }

  ~COptionEnumList() {};
  string SetValue(vector<string> option_value) {
    if (option_value.size() == 1 && option_value[0].compare("NONE") == 0) {
      this->size = 0;
      return "";
    }
    // size is the length of the option list
    this->size = option_value.size();
    unsigned short * enums = new unsigned short[size];
    for (int i  = 0; i < this->size; i++) {
      // Check to see if the enum value is in the map
      if (this->m.find(option_value[i]) == m.end()) {
        string str;
        str.append(this->name);
        str.append(": invalid option value ");
        str.append(option_value[i]);
        str.append(". Check current SU2 options in config_template.cfg.");
        return str;
      }
      // If it is there, set the option value
      enums[i] = this->m[option_value[i]];
    }
    this->field = enums;
    return "";
  }

  void SetDefault() {
    // No default to set
    size = 0;
  }
};

class COptionDoubleArray : public COptionBase {
  su2double * & field; // Reference to the feildname
  string name; // identifier for the option
  const int size;
  su2double * def;
  su2double * vals;
  su2double * default_value;

public:
  COptionDoubleArray(string option_field_name, const int list_size, su2double * & option_field, su2double * default_value) : field(option_field), size(list_size) {
    this->name = option_field_name;
    this->default_value = default_value;
    def  = NULL;
    vals = NULL;
  }

  ~COptionDoubleArray() {
     if(def  != NULL) delete [] def; 
     if(vals != NULL) delete [] vals; 
  };
  string SetValue(vector<string> option_value) {
    // Check that the size is correct
    if (option_value.size() != (unsigned long)this->size) {
      string newstring;
      newstring.append(this->name);
      newstring.append(": wrong number of arguments: ");
      stringstream ss;
      ss << this->size;
      newstring.append(ss.str());
      newstring.append(" expected, ");
      stringstream ss2;
      ss2 << option_value.size();
      newstring.append(ss2.str());
      newstring.append(" found");
      return newstring;
    }
    vals = new su2double[this->size];
    for (int i  = 0; i < this->size; i++) {
      istringstream is(option_value[i]);
      su2double val;
      if (!(is >> val)) {
        delete [] vals;
        return badValue(option_value, "su2double array", this->name);
      }
      vals[i] = val;
    }
    this->field = vals;
    return "";
  }

  void SetDefault() {
    def = new su2double [size];
    for (int i = 0; i < size; i++) {
      def[i] = default_value[i];
    }
    this->field = def;
  }
};

class COptionDoubleList : public COptionBase {
  su2double * & field; // Reference to the feildname
  string name; // identifier for the option
  unsigned short & size;

public:
  COptionDoubleList(string option_field_name, unsigned short & list_size, su2double * & option_field) : field(option_field), size(list_size) {
    this->name = option_field_name;
  }

  ~COptionDoubleList() {};
  string SetValue(vector<string> option_value) {
    // The size is the length of option_value
    unsigned short option_size = option_value.size();
    if (option_size == 1 && option_value[0].compare("NONE") == 0) {
      // No options
      this->size = 0;
      return "";
    }

    this->size = option_size;

    // Parse all of the options
    su2double * vals = new su2double[option_size];
    for (unsigned long i  = 0; i < option_size; i++) {
      istringstream is(option_value[i]);
      su2double val;
      if (!(is >> val)) {
        delete [] vals;
        return badValue(option_value, "su2double list", this->name);
      }
      vals[i] = val;
    }
    this->field = vals;
    return "";
  }

  void SetDefault() {
    this->size = 0; // There is no default value for list
  }
};

class COptionShortList : public COptionBase {
  short * & field; // Reference to the feildname
  string name; // identifier for the option
  unsigned short & size;
  
public:
  COptionShortList(string option_field_name, unsigned short & list_size,  short * & option_field) : field(option_field), size(list_size) {
    this->name = option_field_name;
  }
  
  ~COptionShortList() {};
  string SetValue(vector<string> option_value) {
    // The size is the length of option_value
    unsigned short option_size = option_value.size();
    if (option_size == 1 && option_value[0].compare("NONE") == 0) {
      // No options
      this->size = 0;
      return "";
    }
    this->size = option_size;
    
    // Parse all of the options
    short * vals = new  short[option_size];
    for (unsigned long i  = 0; i < option_size; i++) {
      istringstream is(option_value[i]);
      unsigned short val;
      if (!(is >> val)) {
        delete [] vals;
        return badValue(option_value, "short", this->name);
      }
      vals[i] = val;
    }
    this->field = vals;
    return "";
  }
  
  void SetDefault() {
    this->size = 0; // There is no default value for list
  }
};

class COptionUShortList : public COptionBase {
  unsigned short * & field; // Reference to the feildname
  string name; // identifier for the option
  unsigned short & size;

public:
  COptionUShortList(string option_field_name, unsigned short & list_size, unsigned short * & option_field) : field(option_field), size(list_size) {
    this->name = option_field_name;
  }

  ~COptionUShortList() {};
  string SetValue(vector<string> option_value) {
    // The size is the length of option_value
    unsigned short option_size = option_value.size();
    if (option_size == 1 && option_value[0].compare("NONE") == 0) {
      // No options
      this->size = 0;
      return "";
    }
    this->size = option_size;

    // Parse all of the options
    unsigned short * vals = new unsigned short[option_size];
    for (unsigned long i  = 0; i < option_size; i++) {
      istringstream is(option_value[i]);
      unsigned short val;
      if (!(is >> val)) {
        delete [] vals;
        return badValue(option_value, "unsigned short", this->name);
      }
      vals[i] = val;
    }
    this->field = vals;
    return "";
  }

  void SetDefault() {
    this->size = 0; // There is no default value for list
  }
};

class COptionStringList : public COptionBase {
  string * & field; // Reference to the feildname
  string name; // identifier for the option
  unsigned short & size;

public:
  COptionStringList(string option_field_name, unsigned short & list_size, string * & option_field) : field(option_field), size(list_size) {
    this->name = option_field_name;
  }

  ~COptionStringList() {};
  string SetValue(vector<string> option_value) {
    // The size is the length of option_value
    unsigned short option_size = option_value.size();
    if (option_size == 1 && option_value[0].compare("NONE") == 0) {
      this->size = 0;
      return "";
    }
    this->size = option_size;

    // Parse all of the options
    string * vals = new string[option_size];
    for (unsigned long i  = 0; i < option_size; i++) {
      vals[i].assign(option_value[i]);
    }
    this->field = vals;
    return "";
  }

  void SetDefault() {
    this->size = 0; // There is no default value for list
  }
};

class COptionConvect : public COptionBase {
  string name; // identifier for the option
  unsigned short & space;
  unsigned short & centered;
  unsigned short & upwind;

public:
  COptionConvect(string option_field_name, unsigned short & space_field, unsigned short & centered_field, unsigned short & upwind_field) : space(space_field), centered(centered_field), upwind(upwind_field) {
    this->name = option_field_name;
  }

  ~COptionConvect() {};
  string SetValue(vector<string> option_value) {

    string out = optionCheckMultipleValues(option_value, "unsigned short", this->name);
    if (out.compare("") != 0) {
      return out;
    }

    if (Centered_Map.count(option_value[0])) {
      this->space = Space_Map.find("SPACE_CENTERED")->second;
      this->centered = Centered_Map.find(option_value[0])->second;
      this->upwind = NO_UPWIND;
      return "";
    }
    if (Upwind_Map.count(option_value[0])) {
      this->space = Space_Map.find("SPACE_UPWIND")->second;
      this->upwind = Upwind_Map.find(option_value[0])->second;
      this->centered = NO_CENTERED;
      return "";
    }
    // Make them defined in case something weird happens
    this->centered = NO_CENTERED;
    this->upwind = NO_UPWIND;
    this->space = SPACE_CENTERED;
    return badValue(option_value, "convect", this->name);

  }

  void SetDefault() {
    this->centered = NO_CENTERED;
    this->upwind = NO_UPWIND;
    this->space = SPACE_CENTERED;
  }
};

class COptionMathProblem : public COptionBase {
  string name; // identifier for the option
  bool & cont_adjoint;
  bool cont_adjoint_def;
  bool & disc_adjoint;
  bool disc_adjoint_def;
  bool & restart;
  bool restart_def;

public:
  COptionMathProblem(string option_field_name, bool & cont_adjoint_field, bool cont_adjoint_default, bool & disc_adjoint_field, bool disc_adjoint_default, bool & restart_field, bool restart_default) : cont_adjoint(cont_adjoint_field), disc_adjoint(disc_adjoint_field), restart(restart_field) {
    this->name = option_field_name;
    this->cont_adjoint_def = cont_adjoint_default;
    this->disc_adjoint_def = disc_adjoint_default;
    this->restart_def = restart_default;
  }

  ~COptionMathProblem() {};
  string SetValue(vector<string> option_value) {
    string out = optionCheckMultipleValues(option_value, "unsigned short", this->name);
    if (out.compare("") != 0) {
      return out;
    }
    if (option_value[0] == "ADJOINT") {
      return badValue(option_value, "math problem (try CONTINUOUS_ADJOINT)", this->name);
    }
    if (Math_Problem_Map.find(option_value[0]) == Math_Problem_Map.end()) {
      return badValue(option_value, "math problem", this->name);
    }
    if (option_value[0] == "DIRECT") {
      this->cont_adjoint = false;
      this->disc_adjoint = false;
      this->restart = false;
      return "";
    }
    if (option_value[0] == "CONTINUOUS_ADJOINT") {
      this->cont_adjoint= true;
      this->disc_adjoint = false;
      this->restart= true;
      return "";
    }
    if (option_value[0] == "DISCRETE_ADJOINT") {
      this->disc_adjoint = true;
      this->cont_adjoint= false;
      this->restart = true;
      return "";
    }
    return "option in math problem map not considered in constructor";
  }

  void SetDefault() {
    this->cont_adjoint = this->cont_adjoint_def;
    this->disc_adjoint = this->disc_adjoint_def;
    this->restart = this->restart_def;
  }
  
};

class COptionDVParam : public COptionBase {
  string name; // identifier for the option
  unsigned short & nDV;
  su2double ** & paramDV;
  string * & FFDTag;
  unsigned short* & design_variable;

public:
  COptionDVParam(string option_field_name, unsigned short & nDV_field, su2double** & paramDV_field, string* & FFDTag_field, unsigned short * & design_variable_field) : nDV(nDV_field), paramDV(paramDV_field), FFDTag(FFDTag_field), design_variable(design_variable_field) {
    this->name = option_field_name;
  }

  ~COptionDVParam() {};
  
  string SetValue(vector<string> option_value) {
    if ((option_value.size() == 1) && (option_value[0].compare("NONE") == 0)) {
      this->nDV = 0;
      return "";
    }

    // Cannot have ; at the beginning or the end
    if (option_value[0].compare(";") == 0) {
      string newstring;
      newstring.append(this->name);
      newstring.append(": may not have beginning semicolon");
      return newstring;
    }
    if (option_value[option_value.size()-1].compare(";") == 0) {
      string newstring;
      newstring.append(this->name);
      newstring.append(": may not have ending semicolon");
      return newstring;
    }


    // use the ";" token to determine the number of design variables
    // This works because semicolon is not one of the delimiters in tokenize string
    this->nDV = 0;
    //unsigned int num_semi = 0;
    for (unsigned int i = 0; i < static_cast<unsigned int>(option_value.size()); i++) {
      if (option_value[i].compare(";") == 0) {
        this->nDV++;
        //        num_semi++;
      }
    }

    // One more design variable than semicolon
    this->nDV++;

    if ( (this->nDV > 0) && (this->design_variable == NULL) ) {
      string newstring;
      newstring.append(this->name);
      newstring.append(": Design_Variable array has not been allocated. Check that DV_KIND appears before DV_PARAM in configuration file.");
      return newstring;
    }

    this->paramDV = new su2double*[this->nDV];
    for (unsigned short iDV = 0; iDV < this->nDV; iDV++) {
      this->paramDV[iDV] = new su2double[MAX_PARAMETERS];
    }

    this->FFDTag = new string[this->nDV];

    unsigned short nParamDV = 0;
    stringstream ss;
    unsigned int i = 0;
    for (unsigned short iDV = 0; iDV < this->nDV; iDV++) {
      switch (this->design_variable[iDV]) {
        case NO_DEFORMATION:       nParamDV = 0; break;
        case FFD_SETTING:          nParamDV = 0; break;
        case FFD_CONTROL_POINT_2D: nParamDV = 5; break;
        case FFD_CAMBER_2D:        nParamDV = 2; break;
        case FFD_THICKNESS_2D:     nParamDV = 2; break;
        case FFD_TWIST_2D:         nParamDV = 3; break;
        case HICKS_HENNE:          nParamDV = 2; break;
        case SURFACE_BUMP:         nParamDV = 3; break;
        case CST:                  nParamDV = 3; break;
        case ANGLE_OF_ATTACK:      nParamDV = 1; break;
        case SCALE:                nParamDV = 0; break;
        case TRANSLATION:          nParamDV = 3; break;
        case ROTATION:             nParamDV = 6; break;
        case NACA_4DIGITS:         nParamDV = 3; break;
        case PARABOLIC:            nParamDV = 2; break;
        case AIRFOIL:              nParamDV = 2; break;
        case FFD_CONTROL_POINT:    nParamDV = 7; break;
        case FFD_NACELLE:          nParamDV = 6; break;
        case FFD_GULL:             nParamDV = 2; break;
        case FFD_TWIST:            nParamDV = 8; break;
        case FFD_ROTATION:         nParamDV = 7; break;
        case FFD_CONTROL_SURFACE:  nParamDV = 7; break;
        case FFD_CAMBER:           nParamDV = 3; break;
        case FFD_THICKNESS:        nParamDV = 3; break;
        case FFD_ANGLE_OF_ATTACK:  nParamDV = 2; break;
        case SURFACE_FILE:         nParamDV = 0; break;
        case CUSTOM:               nParamDV = 1; break;
        default : {
          string newstring;
          newstring.append(this->name);
          newstring.append(": undefined design variable type found in configuration file.");
          return newstring;
        }
      }

      for (unsigned short iParamDV = 0; iParamDV < nParamDV; iParamDV++) {

        ss << option_value[i] << " ";

        if ((iParamDV == 0) &&
            ((this->design_variable[iDV] == NO_DEFORMATION) ||
             (this->design_variable[iDV] == FFD_SETTING) ||
             (this->design_variable[iDV] == FFD_ANGLE_OF_ATTACK)||
             (this->design_variable[iDV] == FFD_CONTROL_POINT_2D) ||
             (this->design_variable[iDV] == FFD_CAMBER_2D) ||
             (this->design_variable[iDV] == FFD_TWIST_2D) ||
             (this->design_variable[iDV] == FFD_THICKNESS_2D) ||
             (this->design_variable[iDV] == FFD_CONTROL_POINT) ||
             (this->design_variable[iDV] == FFD_NACELLE) ||
             (this->design_variable[iDV] == FFD_GULL) ||
             (this->design_variable[iDV] == FFD_TWIST) ||
             (this->design_variable[iDV] == FFD_ROTATION) ||
             (this->design_variable[iDV] == FFD_CONTROL_SURFACE) ||
             (this->design_variable[iDV] == FFD_CAMBER) ||
             (this->design_variable[iDV] == FFD_THICKNESS))) {
              ss >> this->FFDTag[iDV];
              this->paramDV[iDV][iParamDV] = 0;
            }
        else
          ss >> this->paramDV[iDV][iParamDV];

        i++;
      }
      if (iDV < (this->nDV-1)) {
        if (option_value[i].compare(";") != 0) {
          string newstring;
          newstring.append(this->name);
          newstring.append(": a design variable in the configuration file has the wrong number of parameters");
          return newstring;
        }
        i++;
      }
    }

    // Need to return something...
    return "";
  }

  void SetDefault() {
    this->nDV = 0;
    this->paramDV = NULL;
    this->FFDTag = NULL;
    // Don't mess with the Design_Variable because it's an input, not modified
  }
};

class COptionDVValue : public COptionBase {
  string name; // identifier for the option
  unsigned short* & nDV_Value;
  su2double ** & valueDV;
  unsigned short & nDV;
  su2double ** & paramDV;
  unsigned short* & design_variable;

public:
  COptionDVValue(string option_field_name, unsigned short* & nDVValue_field, su2double** & valueDV_field, unsigned short & nDV_field,  su2double** & paramDV_field, unsigned short * & design_variable_field) : nDV_Value(nDVValue_field), valueDV(valueDV_field), nDV(nDV_field), paramDV(paramDV_field), design_variable(design_variable_field) {
    this->name = option_field_name;
  }

  ~COptionDVValue() {};

  string SetValue(vector<string> option_value) {
    if ((option_value.size() == 1) && (option_value[0].compare("NONE") == 0)) {
      this->nDV_Value = NULL;
      return "";
    }

    if ( (this->nDV > 0) && (this->design_variable == NULL) ) {
      string newstring;
      newstring.append(this->name);
      newstring.append(": Design_Variable array has not been allocated. Check that DV_KIND appears before DV_VALUE in configuration file.");
      return newstring;
    }
    if ( (this->nDV > 0) && (this->paramDV == NULL) ) {
      string newstring;
      newstring.append(this->name);
      newstring.append(": Design_Parameter array has not been allocated. Check that DV_PARAM appears before DV_VALUE in configuration file.");
      return newstring;
    }

    this->valueDV = new su2double*[this->nDV];
    this->nDV_Value = new unsigned short[this->nDV];

    for (unsigned short iDV = 0; iDV < this->nDV; iDV++) {
      this->valueDV[iDV] = new su2double[3];
    }

    unsigned short nValueDV = 0;
    unsigned short totalnValueDV = 0;
    stringstream ss;
    unsigned int i = 0;
    for (unsigned short iDV = 0; iDV < this->nDV; iDV++) {
      switch (this->design_variable[iDV]) {
        case FFD_CONTROL_POINT:
          if((this->paramDV[iDV][4] == 0) &&
             (this->paramDV[iDV][5] == 0) &&
             (this->paramDV[iDV][6] == 0)) {
            nValueDV = 3;
          } else {
            nValueDV = 1;
          }
          break;
        case FFD_CONTROL_POINT_2D:
          if((this->paramDV[iDV][3] == 0) &&
             (this->paramDV[iDV][4] == 0)) {
            nValueDV = 2;
          } else {
            nValueDV = 1;
          }
          break;
        default :
          nValueDV = 1;
      }

      this->nDV_Value[iDV] = nValueDV;

      totalnValueDV += nValueDV;

      for (unsigned short iValueDV = 0; iValueDV < nValueDV; iValueDV++) {

        ss << option_value[i] << " ";

        ss >> this->valueDV[iDV][iValueDV];

        i++;
      }
    }

    if (i != totalnValueDV) {
      string newstring;
      newstring.append(this->name);
      newstring.append(": a design variable in the configuration file has the wrong number of values");
      return newstring;
    }

    // Need to return something...
    return "";
  }

  void SetDefault() {
    this->nDV_Value = 0;
    this->valueDV = NULL;
    // Don't mess with the Design_Variable because it's an input, not modified
  }
};

class COptionFFDDef : public COptionBase {
  string name;
  unsigned short & nFFD;
  su2double ** & CoordFFD;
  string * & FFDTag;
  
public:
  COptionFFDDef(string option_field_name, unsigned short & nFFD_field, su2double** & coordFFD_field, string* & FFDTag_field) : nFFD(nFFD_field), CoordFFD(coordFFD_field), FFDTag(FFDTag_field) {
    this->name = option_field_name;
  }
  
  ~COptionFFDDef() {};
  
  string SetValue(vector<string> option_value) {
    if ((option_value.size() == 1) && (option_value[0].compare("NONE") == 0)) {
      this->nFFD = 0;
      return "";
    }
    
    // Cannot have ; at the beginning or the end
    if (option_value[0].compare(";") == 0) {
      string newstring;
      newstring.append(this->name);
      newstring.append(": may not have beginning semicolon");
      return newstring;
    }
    if (option_value[option_value.size()-1].compare(";") == 0) {
      string newstring;
      newstring.append(this->name);
      newstring.append(": may not have ending semicolon");
      return newstring;
    }
    
    
    // use the ";" token to determine the number of design variables
    // This works because semicolon is not one of the delimiters in tokenize string
    this->nFFD = 0;
    for (unsigned int i = 0; i < static_cast<unsigned int>(option_value.size()); i++) {
      if (option_value[i].compare(";") == 0) {
        this->nFFD++;
      }
    }
    
    // One more design variable than semicolon
    this->nFFD++;
    
    this->CoordFFD = new su2double*[this->nFFD];
    for (unsigned short iFFD = 0; iFFD < this->nFFD; iFFD++) {
      this->CoordFFD[iFFD] = new su2double[25];
    }
    
    this->FFDTag = new string[this->nFFD];
    
    unsigned short nCoordFFD = 0;
    stringstream ss;
    unsigned int i = 0;
    
    for (unsigned short iFFD = 0; iFFD < this->nFFD; iFFD++) {
      
      nCoordFFD = 25;
      
      for (unsigned short iCoordFFD = 0; iCoordFFD < nCoordFFD; iCoordFFD++) {
        
        ss << option_value[i] << " ";
        
        if (iCoordFFD == 0) ss >> this->FFDTag[iFFD];
        else ss >> this->CoordFFD[iFFD][iCoordFFD-1];
        
        i++;
      }
      
      if (iFFD < (this->nFFD-1)) {
        if (option_value[i].compare(";") != 0) {
          string newstring;
          newstring.append(this->name);
          newstring.append(": a FFD box in the configuration file has the wrong number of parameters");
          return newstring;
        }
        i++;
      }
      
    }
    
    // Need to return something...
    return "";
  }
  
  void SetDefault() {
    this->nFFD = 0;
    this->CoordFFD = NULL;
    this->FFDTag = NULL;
  }
  
};

class COptionFFDDegree : public COptionBase {
  string name;
  unsigned short & nFFD;
  unsigned short ** & DegreeFFD;
  
public:
  COptionFFDDegree(string option_field_name, unsigned short & nFFD_field, unsigned short** & degreeFFD_field) : nFFD(nFFD_field), DegreeFFD(degreeFFD_field) {
    this->name = option_field_name;
  }
  
  ~COptionFFDDegree() {};
  
  string SetValue(vector<string> option_value) {
    if ((option_value.size() == 1) && (option_value[0].compare("NONE") == 0)) {
      this->nFFD = 0;
      return "";
    }
    
    // Cannot have ; at the beginning or the end
    if (option_value[0].compare(";") == 0) {
      string newstring;
      newstring.append(this->name);
      newstring.append(": may not have beginning semicolon");
      return newstring;
    }
    if (option_value[option_value.size()-1].compare(";") == 0) {
      string newstring;
      newstring.append(this->name);
      newstring.append(": may not have ending semicolon");
      return newstring;
    }
    
    
    // use the ";" token to determine the number of design variables
    // This works because semicolon is not one of the delimiters in tokenize string
    this->nFFD = 0;
    for (unsigned int i = 0; i < static_cast<unsigned int>(option_value.size()); i++) {
      if (option_value[i].compare(";") == 0) {
        this->nFFD++;
      }
    }
    
    // One more design variable than semicolon
    this->nFFD++;
    
    this->DegreeFFD = new unsigned short*[this->nFFD];
    for (unsigned short iFFD = 0; iFFD < this->nFFD; iFFD++) {
      this->DegreeFFD[iFFD] = new unsigned short[3];
    }
    
    unsigned short nDegreeFFD = 0;
    stringstream ss;
    unsigned int i = 0;
    
    for (unsigned short iFFD = 0; iFFD < this->nFFD; iFFD++) {
      
      nDegreeFFD = 3;
      
      for (unsigned short iDegreeFFD = 0; iDegreeFFD < nDegreeFFD; iDegreeFFD++) {
        ss << option_value[i] << " ";
        ss >> this->DegreeFFD[iFFD][iDegreeFFD];
        i++;
      }
      
      if (iFFD < (this->nFFD-1)) {
        if (option_value[i].compare(";") != 0) {
          string newstring;
          newstring.append(this->name);
          newstring.append(": a FFD degree in the configuration file has the wrong number of parameters");
          return newstring;
        }
        i++;
      }
      
    }
    
    // Need to return something...
    return "";
  }
  
  void SetDefault() {
    this->nFFD = 0;
    this->DegreeFFD = NULL;
  }
  
};

// Class where the option is represented by (String, su2double, string, su2double, ...)
class COptionStringDoubleList : public COptionBase {
  string name; // identifier for the option
  unsigned short & size; // how many strings are there (same as number of su2doubles)

  string * & s_f; // Reference to the string fields
  su2double* & d_f; // reference to the su2double fields

public:
  COptionStringDoubleList(string option_field_name, unsigned short & list_size, string * & string_field, su2double* & double_field) : size(list_size), s_f(string_field), d_f(double_field) {
    this->name = option_field_name;
  }

  ~COptionStringDoubleList() {};
  string SetValue(vector<string> option_value) {
    // There must be an even number of entries (same number of strings and doubles
    unsigned short totalVals = option_value.size();
    if ((totalVals % 2) != 0) {
      if ((totalVals == 1) && (option_value[0].compare("NONE") == 0)) {
        // It's okay to say its NONE
        this->size = 0;
        return "";
      }
      string newstring;
      newstring.append(this->name);
      newstring.append(": must have an even number of entries");
      return newstring;
    }
    unsigned short nVals = totalVals / 2;
    this->size = nVals;
    this->s_f = new string[nVals];
    this->d_f = new su2double[nVals];

    for (unsigned long i = 0; i < nVals; i++) {
      this->s_f[i].assign(option_value[2*i]); // 2 because have su2double and string
      istringstream is(option_value[2*i + 1]);
      su2double val;
      if (!(is >> val)) {
        return badValue(option_value, "string su2double", this->name);
      }
      this->d_f[i] = val;
    }
    // Need to return something...
    return "";
  }

  void SetDefault() {
    this->size = 0; // There is no default value for list
  }
};

class COptionInlet : public COptionBase {
  string name; // identifier for the option
  unsigned short & size;
  string * & marker;
  su2double * & ttotal;
  su2double * & ptotal;
  su2double ** & flowdir;

public:
  COptionInlet(string option_field_name, unsigned short & nMarker_Inlet, string* & Marker_Inlet, su2double* & Ttotal, su2double* & Ptotal, su2double** & FlowDir) : size(nMarker_Inlet), marker(Marker_Inlet), ttotal(Ttotal), ptotal(Ptotal), flowdir(FlowDir) {
    this->name = option_field_name;
  }

  ~COptionInlet() {};
  string SetValue(vector<string> option_value) {

    unsigned short totalVals = option_value.size();
    if ((totalVals == 1) && (option_value[0].compare("NONE") == 0)) {
      this->size = 0;
      this->marker = NULL;
      this->ttotal = NULL;
      this->ptotal = NULL;
      this->flowdir = NULL;
      return "";
    }

    if (totalVals % 6 != 0) {
      string newstring;
      newstring.append(this->name);
      newstring.append(": must have a number of entries divisible by 6");
      this->size = 0;
      this->marker = NULL;
      this->ttotal = NULL;
      this->ptotal = NULL;
      this->flowdir = NULL;
      return newstring;
    }

    unsigned short nVals = totalVals / 6;
    this->size = nVals;
    this->marker = new string[nVals];
    this->ttotal = new su2double[nVals];
    this->ptotal = new su2double[nVals];
    this->flowdir = new su2double*[nVals];
    for (unsigned long i = 0; i < nVals; i++) {
      this->flowdir[i] = new su2double[3];
    }

    for (unsigned long i = 0; i < nVals; i++) {
      this->marker[i].assign(option_value[6*i]);
      istringstream ss_1st(option_value[6*i + 1]);
      if (!(ss_1st >> this->ttotal[i])) {
        return badValue(option_value, "inlet", this->name);
      }
      istringstream ss_2nd(option_value[6*i + 2]);
      if (!(ss_2nd >> this->ptotal[i])) {
        return badValue(option_value, "inlet", this->name);
      }
      istringstream ss_3rd(option_value[6*i + 3]);
      if (!(ss_3rd >> this->flowdir[i][0])) {
        return badValue(option_value, "inlet", this->name);
      }
      istringstream ss_4th(option_value[6*i + 4]);
      if (!(ss_4th >> this->flowdir[i][1])) {
        return badValue(option_value, "inlet", this->name);
      }
      istringstream ss_5th(option_value[6*i + 5]);
      if (!(ss_5th >> this->flowdir[i][2])) {
        return badValue(option_value, "inlet", this->name);
      }
    }

    return "";
  }

  void SetDefault() {
    this->marker = NULL;
    this->ttotal = NULL;
    this->ptotal = NULL;
    this->flowdir = NULL;
    this->size = 0; // There is no default value for list
  }
};

template <class Tenum>
class COptionRiemann : public COptionBase {

protected:
  map<string, Tenum> m;
  string name; // identifier for the option
  unsigned short & size;
  string * & marker;
  unsigned short* & field; // Reference to the field name
  su2double * & var1;
  su2double * & var2;
  su2double ** & flowdir;

public:
  COptionRiemann(string option_field_name, unsigned short & nMarker_Riemann, string* & Marker_Riemann, unsigned short* & option_field, const map<string, Tenum> m, su2double* & var1, su2double* & var2, su2double** & FlowDir) : size(nMarker_Riemann),
                  marker(Marker_Riemann), field(option_field), var1(var1), var2(var2), flowdir(FlowDir) {
    this->name = option_field_name;
    this->m = m;
  }
  ~COptionRiemann() {};

  string SetValue(vector<string> option_value) {

    unsigned short totalVals = option_value.size();
    if ((totalVals == 1) && (option_value[0].compare("NONE") == 0)) {
      this->size = 0;
      this->marker = NULL;
      this->field = 0;
      this->var1 = NULL;
      this->var2 = NULL;
      this->flowdir = NULL;
      return "";
    }

    if (totalVals % 7 != 0) {
      string newstring;
      newstring.append(this->name);
      newstring.append(": must have a number of entries divisible by 7");
      this->size = 0;
      this->marker = NULL;
      this->var1 = NULL;
      this->var2 = NULL;
      this->flowdir = NULL;
      this->field = NULL;
      return newstring;
    }

    unsigned short nVals = totalVals / 7;
    this->size = nVals;
    this->marker = new string[nVals];
    this->var1 = new su2double[nVals];
    this->var2 = new su2double[nVals];
    this->flowdir = new su2double*[nVals];
    this->field = new unsigned short[nVals];

    for (unsigned long i = 0; i < nVals; i++) {
      this->flowdir[i] = new su2double[3];
    }

    for (unsigned long i = 0; i < nVals; i++) {
      this->marker[i].assign(option_value[7*i]);
        // Check to see if the enum value is in the map
    if (this->m.find(option_value[7*i + 1]) == m.end()) {
      string str;
      str.append(this->name);
      str.append(": invalid option value ");
      str.append(option_value[0]);
      str.append(". Check current SU2 options in config_template.cfg.");
      return str;
    }
      Tenum val = this->m[option_value[7*i + 1]];
      this->field[i] = val;

      istringstream ss_1st(option_value[7*i + 2]);
      if (!(ss_1st >> this->var1[i])) {
        return badValue(option_value, "Riemann", this->name);
      }
      istringstream ss_2nd(option_value[7*i + 3]);
      if (!(ss_2nd >> this->var2[i])) {
        return badValue(option_value, "Riemann", this->name);
      }
      istringstream ss_3rd(option_value[7*i + 4]);
      if (!(ss_3rd >> this->flowdir[i][0])) {
        return badValue(option_value, "Riemann", this->name);
      }
      istringstream ss_4th(option_value[7*i + 5]);
      if (!(ss_4th >> this->flowdir[i][1])) {
        return badValue(option_value, "Riemann", this->name);
      }
      istringstream ss_5th(option_value[7*i + 6]);
      if (!(ss_5th >> this->flowdir[i][2])) {
        return badValue(option_value, "Riemann", this->name);
      }
    }

    return "";
  }

  void SetDefault() {
    this->marker = NULL;
    this->var1 = NULL;
    this->var2 = NULL;
    this->flowdir = NULL;
    this->size = 0; // There is no default value for list
  }
};

template <class Tenum>
class COptionNRBC : public COptionRiemann<Tenum> {

public:
      COptionNRBC(string option_field_name, unsigned short & nMarker_NRBC, string* & Marker_NRBC, unsigned short* & option_field,
                  const map<string, Tenum> m, su2double* & var1, su2double* & var2, su2double** & FlowDir): COptionRiemann<Tenum>(option_field_name, nMarker_NRBC,  Marker_NRBC, option_field,
                   m, var1, var2,FlowDir) {}
      ~COptionNRBC() {};

};
//template <class Tenum>
//class COptionNRBC : public COptionBase {
//
//  map<string, Tenum> m;
//  unsigned short* & field; // Reference to the fieldname
//  string name; // identifier for the option
//  unsigned short & size;
//  string * & marker;
//  su2double * & var1;
//  su2double * & var2;
//  su2double ** & flowdir;
//
//public:
//  COptionNRBC(string option_field_name, unsigned short & nMarker_NRBC, string* & Marker_NRBC, unsigned short* & option_field, const map<string, Tenum> m, su2double* & var1, su2double* & var2, su2double** & FlowDir) : size(nMarker_NRBC),
//                    marker(Marker_NRBC), field(option_field), var1(var1), var2(var2), flowdir(FlowDir) {
//    this->name = option_field_name;
//    this->m = m;
//  }
//  ~COptionNRBC() {};
//
//  string SetValue(vector<string> option_value) {
//
//    unsigned long totalVals = option_value.size();
//    if ((totalVals == 1) && (option_value[0].compare("NONE") == 0)) {
//      this->size = 0;
//      this->marker = NULL;
//      this->field = 0;
//      this->var1 = NULL;
//      this->var2 = NULL;
//      this->flowdir = NULL;
//      return "";
//    }
//
//    if (totalVals % 7 != 0) {
//      string newstring;
//      newstring.append(this->name);
//      newstring.append(": must have a number of entries divisible by 7");
//      this->size = 0;
//      this->marker = NULL;
//      this->var1 = NULL;
//      this->var2 = NULL;
//      this->flowdir = NULL;
//      this->field = NULL;
//      return newstring;
//    }
//
//    unsigned long nVals = totalVals / 7;
//    this->size = nVals;
//    this->marker = new string[nVals];
//    this->var1 = new su2double[nVals];
//    this->var2 = new su2double[nVals];
//    this->flowdir = new su2double*[nVals];
//    this->field = new unsigned short[nVals];
//
//    for (int i = 0; i < nVals; i++) {
//      this->flowdir[i] = new su2double[3];
//    }
//
//    for (int i = 0; i < nVals; i++) {
//      this->marker[i].assign(option_value[7*i]);
//        // Check to see if the enum value is in the map
//    if (this->m.find(option_value[7*i + 1]) == m.end()) {
//      string str;
//      str.append(this->name);
//      str.append(": invalid option value ");
//      str.append(option_value[0]);
//      str.append(". Check current SU2 options in config_template.cfg.");
//      return str;
//    }
//      Tenum val = this->m[option_value[7*i + 1]];
//      this->field[i] = val;
//
//      istringstream ss_1st(option_value[7*i + 2]);
//      if (!(ss_1st >> this->var1[i])) {
//        return badValue(option_value, "NRBC", this->name);
//      }
//      istringstream ss_2nd(option_value[7*i + 3]);
//      if (!(ss_2nd >> this->var2[i])) {
//        return badValue(option_value, "NRBC", this->name);
//      }
//      istringstream ss_3rd(option_value[7*i + 4]);
//      if (!(ss_3rd >> this->flowdir[i][0])) {
//        return badValue(option_value, "NRBC", this->name);
//      }
//      istringstream ss_4th(option_value[7*i + 5]);
//      if (!(ss_4th >> this->flowdir[i][1])) {
//        return badValue(option_value, "NRBC", this->name);
//      }
//      istringstream ss_5th(option_value[7*i + 6]);
//      if (!(ss_5th >> this->flowdir[i][2])) {
//        return badValue(option_value, "NRBC", this->name);
//      }
//    }
//
//    return "";
//  }
//
//  void SetDefault() {
//    this->marker = NULL;
//    this->var1 = NULL;
//    this->var2 = NULL;
//    this->flowdir = NULL;
//    this->size = 0; // There is no default value for list
//  }
//};






//Inlet condition where the input direction is assumed
class COptionExhaust : public COptionBase {
  string name; // identifier for the option
  unsigned short & size;
  string * & marker;
  su2double * & ttotal;
  su2double * & ptotal;

public:
  COptionExhaust(string option_field_name, unsigned short & nMarker_Exhaust, string* & Marker_Exhaust, su2double* & Ttotal, su2double* & Ptotal) : size(nMarker_Exhaust), marker(Marker_Exhaust), ttotal(Ttotal), ptotal(Ptotal) {
    this->name = option_field_name;
  }

  ~COptionExhaust() {};
  
  string SetValue(vector<string> option_value) {

    unsigned short totalVals = option_value.size();
    if ((totalVals == 1) && (option_value[0].compare("NONE") == 0)) {
      this->size = 0;
      this->marker = NULL;
      this->ttotal = NULL;
      this->ptotal = NULL;
      return "";
    }

    if (totalVals % 3 != 0) {
      string newstring;
      newstring.append(this->name);
      newstring.append(": must have a number of entries divisible by 3");
      this->size = 0;
      this->marker = NULL;
      this->ttotal = NULL;
      this->ptotal = NULL;
      return newstring;
    }

    unsigned short nVals = totalVals / 3;
    this->size = nVals;
    this->marker = new string[nVals];
    this->ttotal = new su2double[nVals];
    this->ptotal = new su2double[nVals];

    for (unsigned long i = 0; i < nVals; i++) {
      this->marker[i].assign(option_value[3*i]);
      istringstream ss_1st(option_value[3*i + 1]);
      if (!(ss_1st >> this->ttotal[i]))
        return badValue(option_value, "exhaust fixed", this->name);
      istringstream ss_2nd(option_value[3*i + 2]);
      if (!(ss_2nd >> this->ptotal[i]))
        return badValue(option_value, "exhaust fixed", this->name);
    }
    
    return "";
  }

  void SetDefault() {
    this->marker = NULL;
    this->ttotal = NULL;
    this->ptotal = NULL;
    this->size = 0; // There is no default value for list
  }
  
};

class COptionPeriodic : public COptionBase {
  string name; // identifier for the option
  unsigned short & size;
  string * & marker_bound;
  string * & marker_donor;
  su2double ** & rot_center;
  su2double ** & rot_angles;
  su2double ** & translation;

public:
  COptionPeriodic(const string option_field_name, unsigned short & nMarker_PerBound,
                  string* & Marker_PerBound, string* & Marker_PerDonor,
                  su2double** & RotCenter, su2double** & RotAngles, su2double** & Translation) : size(nMarker_PerBound), marker_bound(Marker_PerBound), marker_donor(Marker_PerDonor), rot_center(RotCenter), rot_angles(RotAngles), translation(Translation) {
    this->name = option_field_name;
  }

  ~COptionPeriodic() {};
  string SetValue(vector<string> option_value) {

    const int mod_num = 11;

    unsigned short totalVals = option_value.size();
    if ((totalVals == 1) && (option_value[0].compare("NONE") == 0)) {
      this->size = 0;
      this->marker_bound = NULL;
      this->marker_donor = NULL;
      this->rot_center = NULL;
      this->rot_angles = NULL;
      this->translation = NULL;
      return "";
    }

    if (totalVals % mod_num != 0) {
      string newstring;
      newstring.append(this->name);
      newstring.append(": must have a number of entries divisible by 11");
      this->size = 0;
      this->marker_bound = NULL;
      this->marker_donor = NULL;
      this->rot_center = NULL;
      this->rot_angles = NULL;
      this->translation = NULL;
      return newstring;
    }

    unsigned short nVals = 2 * (totalVals / mod_num); // To account for periodic and donor
    this->size = nVals;
    this->marker_bound = new string[nVals];
    this->marker_donor = new string[nVals];
    this->rot_center = new su2double*[nVals];
    this->rot_angles = new su2double*[nVals];
    this->translation = new su2double*[nVals];
    for (unsigned long i = 0; i < nVals; i++) {
      this->rot_center[i] = new su2double[3];
      this->rot_angles[i] = new su2double[3];
      this->translation[i] = new su2double[3];
    }

    su2double deg2rad = PI_NUMBER/180.0;

    for (unsigned long i = 0; i < (nVals/2); i++) {
      this->marker_bound[i].assign(option_value[mod_num*i]);
      this->marker_donor[i].assign(option_value[mod_num*i+1]);
      istringstream ss_1st(option_value[mod_num*i + 2]);
      if (!(ss_1st >> this->rot_center[i][0])) {
        return badValue(option_value, "periodic", this->name);
      }
      istringstream ss_2nd(option_value[mod_num*i + 3]);
      if (!(ss_2nd >> this->rot_center[i][1])) {
        return badValue(option_value, "periodic", this->name);
      }
      istringstream ss_3rd(option_value[mod_num*i + 4]);
      if (!(ss_3rd >> this->rot_center[i][2])) {
        return badValue(option_value, "periodic", this->name);
      }
      istringstream ss_4th(option_value[mod_num*i + 5]);
      if (!(ss_4th >> this->rot_angles[i][0])) {
        return badValue(option_value, "periodic", this->name);
      }
      istringstream ss_5th(option_value[mod_num*i + 6]);
      if (!(ss_5th >> this->rot_angles[i][1])) {
        return badValue(option_value, "periodic", this->name);
      }
      istringstream ss_6th(option_value[mod_num*i + 7]);
      if (!(ss_6th >> this->rot_angles[i][2])) {
        return badValue(option_value, "periodic", this->name);
      }
      istringstream ss_7th(option_value[mod_num*i + 8]);
      if (!(ss_7th >> this->translation[i][0])) {
        return badValue(option_value, "periodic", this->name);
      }
      istringstream ss_8th(option_value[mod_num*i + 9]);
      if (!(ss_8th >> this->translation[i][1])) {
        return badValue(option_value, "periodic", this->name);
      }
      istringstream ss_9th(option_value[mod_num*i + 10]);
      if (!(ss_9th >> this->translation[i][2])) {
        return badValue(option_value, "periodic", this->name);
      }
      this->rot_angles[i][0] *= deg2rad;
      this->rot_angles[i][1] *= deg2rad;
      this->rot_angles[i][2] *= deg2rad;
    }

    for (unsigned long i = (nVals/2); i < nVals; i++) {
      this->marker_bound[i].assign(option_value[mod_num*(i-nVals/2)+1]);
      this->marker_donor[i].assign(option_value[mod_num*(i-nVals/2)]);
      istringstream ss_1st(option_value[mod_num*(i-nVals/2) + 2]);
      if (!(ss_1st >> this->rot_center[i][0])) {
        return badValue(option_value, "periodic", this->name);
      }
      istringstream ss_2nd(option_value[mod_num*(i-nVals/2) + 3]);
      if (!(ss_2nd >> this->rot_center[i][1])) {
        return badValue(option_value, "periodic", this->name);
      }
      istringstream ss_3rd(option_value[mod_num*(i-nVals/2) + 4]);
      if (!(ss_3rd >> this->rot_center[i][2])) {
        return badValue(option_value, "periodic", this->name);
      }
      istringstream ss_4th(option_value[mod_num*(i-nVals/2) + 5]);
      if (!(ss_4th >> this->rot_angles[i][0])) {
        return badValue(option_value, "periodic", this->name);
      }
      istringstream ss_5th(option_value[mod_num*(i-nVals/2) + 6]);
      if (!(ss_5th >> this->rot_angles[i][1])) {
        return badValue(option_value, "periodic", this->name);
      }
      istringstream ss_6th(option_value[mod_num*(i-nVals/2) + 7]);
      if (!(ss_6th >> this->rot_angles[i][2])) {
        return badValue(option_value, "periodic", this->name);
      }
      istringstream ss_7th(option_value[mod_num*(i-nVals/2) + 8]);
      if (!(ss_7th >> this->translation[i][0])) {
        return badValue(option_value, "periodic", this->name);
      }
      istringstream ss_8th(option_value[mod_num*(i-nVals/2) + 9]);
      if (!(ss_8th >> this->translation[i][1])) {
        return badValue(option_value, "periodic", this->name);
      }
      istringstream ss_9th(option_value[mod_num*(i-nVals/2) + 10]);
      if (!(ss_9th >> this->translation[i][2])) {
        return badValue(option_value, "periodic", this->name);
      }
      /*--- Mirror the rotational angles and translation vector (rotational
       center does not need to move) ---*/
      this->rot_center[i][0] *= 1.0;
      this->rot_center[i][1] *= 1.0;
      this->rot_center[i][2] *= 1.0;
      this->rot_angles[i][0] *= -deg2rad;
      this->rot_angles[i][1] *= -deg2rad;
      this->rot_angles[i][2] *= -deg2rad;
      this->translation[i][0] *= -1.0;
      this->translation[i][1] *= -1.0;
      this->translation[i][2] *= -1.0;
    }

    return "";
  }

  void SetDefault() {
    this->size = 0;
    this->marker_bound = NULL;
    this->marker_donor = NULL;
    this->rot_center = NULL;
    this->rot_angles = NULL;
    this->translation = NULL;
  }
};


class COptionMixingPlane : public COptionBase {
  string name; // identifier for the option
  unsigned short & size;
  string * & marker_bound;
  string * & marker_donor;

public:
  COptionMixingPlane(const string option_field_name, unsigned short & nMarker_MixBound,
                  string* & Marker_MixBound, string* & Marker_MixDonor) : size(nMarker_MixBound), marker_bound(Marker_MixBound), marker_donor(Marker_MixDonor) {
    this->name = option_field_name;
  }

  ~COptionMixingPlane() {};
  string SetValue(vector<string> option_value) {

    const int mod_num = 2;

    unsigned long totalVals = option_value.size();
    if ((totalVals == 1) && (option_value[0].compare("NONE") == 0)) {
      this->size = 0;
      this->marker_bound = NULL;
      this->marker_donor = NULL;
      return "";
    }

    if (totalVals % mod_num != 0) {
      string newstring;
      newstring.append(this->name);
      newstring.append(": must have a number of entries divisible by 11");
      this->size = 0;
      this->marker_bound = NULL;
      this->marker_donor = NULL;
      return newstring;
    }

    unsigned long nVals = 2 * (totalVals / mod_num); // To account for periodic and donor
    this->size = nVals;
    this->marker_bound = new string[nVals];
    this->marker_donor = new string[nVals];


    for (unsigned short i = 0; i < (nVals/2); i++) {
      this->marker_bound[i].assign(option_value[mod_num*i]);
      this->marker_donor[i].assign(option_value[mod_num*i+1]);
     }

    for (unsigned long i = (nVals/2); i < nVals; i++) {
      this->marker_bound[i].assign(option_value[mod_num*(i-nVals/2)+1]);
      this->marker_donor[i].assign(option_value[mod_num*(i-nVals/2)]);
      }



    return "";
  }

  void SetDefault() {
    this->size = 0;
    this->marker_bound = NULL;
    this->marker_donor = NULL;
  }
};

template <class Tenum>
class COptionTurboPerformance : public COptionBase {
  string name; // identifier for the option
  unsigned short & size;
  string * & marker_turboIn;
  string * & marker_turboOut;
  map<string, Tenum> m;
  unsigned short* & field; // Reference to the fieldname

public:
  COptionTurboPerformance(const string option_field_name, unsigned short & nMarker_TurboPerf,
                  string* & Marker_TurboBoundIn, string* & Marker_TurboBoundOut, unsigned short* & option_field, const map<string, Tenum> m) : size(nMarker_TurboPerf), marker_turboIn(Marker_TurboBoundIn), marker_turboOut(Marker_TurboBoundOut), field(option_field) {
    this->name = option_field_name;
    this->m = m;
  }

  ~COptionTurboPerformance() {};
  string SetValue(vector<string> option_value) {

    const int mod_num = 3;

    unsigned long totalVals = option_value.size();
    if ((totalVals == 1) && (option_value[0].compare("NONE") == 0)) {
      this->size = 0;
      this->marker_turboIn= NULL;
      this->marker_turboOut = NULL;
      this->field = NULL;
      return "";
    }

    if (totalVals % mod_num != 0) {
      string newstring;
      newstring.append(this->name);
      newstring.append(": must have a number of entries divisible by 11");
      this->size = 0;
      this->marker_turboIn= NULL;
      this->marker_turboOut = NULL;;
      this->field = NULL;
      return newstring;
    }

    unsigned long nVals = totalVals / mod_num;
    this->size = nVals;
    this->marker_turboIn = new string[nVals];
    this->marker_turboOut = new string[nVals];
    this->field = new unsigned short[nVals];
    for (unsigned long i = 0; i < nVals; i++)
        if (this->m.find(option_value[mod_num*i + 2]) == m.end()) {
            string str;
            str.append(this->name);
            str.append(": invalid option value ");
            str.append(option_value[0]);
            str.append(". Check current SU2 options in config_template.cfg.");
            return str;
        }
    for (unsigned long i = 0; i < nVals; i++) {
      this->marker_turboIn[i].assign(option_value[mod_num*i]);
      this->marker_turboOut[i].assign(option_value[mod_num*i+1]);
      Tenum val = this->m[option_value[mod_num*i + 2]];
      this->field[i] = val;
     }


    return "";
  }

  void SetDefault() {
    this->size = 0;
    this->marker_turboIn= NULL;
    this->marker_turboOut = NULL;
    this->field = NULL;
  }
};


class COptionPython : public COptionBase {
  string name;
public:
  COptionPython(const string name) {
    this->name = name;
  }
  ~COptionPython() {};
  // No checking happens with python options
  string SetValue(vector<string>) {
    return "";
  }
  // No defaults with python options
  void SetDefault() {
    return;
  };
};



class COptionActDisk : public COptionBase {
  string name; // identifier for the option
  unsigned short & inlet_size;
  unsigned short & outlet_size;
  string * & marker_inlet;
  string * & marker_outlet;
  su2double ** & press_jump;
  su2double ** & temp_jump;
  su2double ** & omega;
  
public:
  COptionActDisk(const string name,
                 unsigned short & nMarker_ActDiskInlet, unsigned short & nMarker_ActDiskOutlet, string * & Marker_ActDiskInlet, string * & Marker_ActDiskOutlet,
                 su2double ** & ActDisk_PressJump, su2double ** & ActDisk_TempJump, su2double ** & ActDisk_Omega) :
  inlet_size(nMarker_ActDiskInlet), outlet_size(nMarker_ActDiskOutlet), marker_inlet(Marker_ActDiskInlet), marker_outlet(Marker_ActDiskOutlet),
  press_jump(ActDisk_PressJump), temp_jump(ActDisk_TempJump), omega(ActDisk_Omega) {
    this->name = name;
  }
  
  ~COptionActDisk() {};
  string SetValue(vector<string> option_value) {
    const int mod_num = 8;
    unsigned short totalVals = option_value.size();
    if ((totalVals == 1) && (option_value[0].compare("NONE") == 0)) {
      this->SetDefault();
      return "";
    }
    
    if (totalVals % mod_num != 0) {
      string newstring;
      newstring.append(this->name);
      newstring.append(": must have a number of entries divisible by 8");
      this->SetDefault();
      return newstring;
    }
    
    unsigned short nVals = totalVals / mod_num;
    this->inlet_size = nVals;
    this->outlet_size = nVals;
    this->marker_inlet = new string[this->inlet_size];
    this->marker_outlet = new string[this->outlet_size];
    
    this->press_jump = new su2double*[this->inlet_size];
    this->temp_jump = new su2double*[this->inlet_size];
    this->omega = new su2double*[this->inlet_size];
    for (int i = 0; i < this->inlet_size; i++) {
      this->press_jump[i] = new su2double[2];
      this->temp_jump[i] = new su2double[2];
      this->omega[i] = new su2double[2];
    }
    
    string tname = "actuator disk";
    
    for (int i = 0; i < this->inlet_size; i++) {
      this->marker_inlet[i].assign(option_value[mod_num*i]);
      this->marker_outlet[i].assign(option_value[mod_num*i+1]);
      istringstream ss_1st(option_value[mod_num*i + 2]);
      if (!(ss_1st >> this->press_jump[i][0])) {
        return badValue(option_value, tname, this->name);
      }
      istringstream ss_2nd(option_value[mod_num*i + 3]);
      if (!(ss_2nd >> this->temp_jump[i][0])) {
        return badValue(option_value, tname, this->name);
      }
      istringstream ss_3rd(option_value[mod_num*i + 4]);
      if (!(ss_3rd >> this->omega[i][0])) {
        return badValue(option_value, tname, this->name);
      }
      istringstream ss_4th(option_value[mod_num*i + 5]);
      if (!(ss_4th >> this->press_jump[i][1])) {
        return badValue(option_value, tname, this->name);
      }
      istringstream ss_5th(option_value[mod_num*i + 6]);
      if (!(ss_5th >> this->temp_jump[i][1])) {
        return badValue(option_value, tname, this->name);
      }
      istringstream ss_6th(option_value[mod_num*i + 7]);
      if (!(ss_6th >> this->omega[i][1])) {
        return badValue(option_value, tname, this->name);
      }
    }
    return "";
  }
  void SetDefault() {
    this->inlet_size = 0;
    this->outlet_size = 0;
    this->marker_inlet = NULL;
    this->marker_outlet = NULL;
    this->press_jump = NULL;
    this->temp_jump = NULL;
    this->omega = NULL;
  }
};