ms2data.cpp

/*********************************************************************/ 
/*                                                                   */ 
/*             Config files library - (C) TGG 2015                   */ 
/*                                                                   */ 
/*********************************************************************/ 
/*                          Warszawa, 2015                           */ 
/*********************************************************************/ 
/*                                                                   */
/* File: ms2data.cpp                                                 */
/*                                                                   */
/* Author: D.Mieszalski, modif: T.Grabowski                          */
/*                                                                   */
/* Contents - ms2 data I/O class                                     */
/*                                                                   */ 
/*                                                                   */
/*********************************************************************/
/*                                                                   */
/*                                                                   */
 
#include <sstream>
#include <cstdlib>
#include <cmath>
 
#include "ms2data.h"
 
using namespace std;
 
map<int,const char*> CreateFusTypeStr( void )
{
    map<int,const char*>  mFusTypeStr;
    mFusTypeStr[(int)FT_FILE] = "FromFile";
    mFusTypeStr[(int)FT_PARAMS] = "FromParams";
    return mFusTypeStr;
}
 
map<int,const char*> CreateFusCvrStr( void )
{
    map<int,const char*> mFusCvrStr;
    mFusCvrStr[(int)CRV_SPINE] = "Spine";
    mFusCvrStr[(int)CRV_UP_CONT] = "UpCont";
    mFusCvrStr[(int)CRV_SIDE_CONT] = "SideContour";
    mFusCvrStr[(int)CRV_DOWN_CONT] = "DownContour";
    mFusCvrStr[(int)CRV_CV_FACT_UP] = "UpConvFact";
    mFusCvrStr[(int)CRV_CV_FACT_DOWN] = "DownConvFact";
    return mFusCvrStr;
}
 
map<int,const char*> CreateFusCvrTypeStr( void )
{
    map<int,const char*> mFusCvrTypeStr;
    mFusCvrTypeStr[(int)ELLIPSE] = "SupEllipse";
    mFusCvrTypeStr[(int)AIRFOIL] = "Airfoil";
    mFusCvrTypeStr[(int)CONSTANT] = "Constant";
    return mFusCvrTypeStr;
}
 
map<int,const char*> CreateFusAirfoilSide( void )
{
    map<int,const char*>  mFusAirfoilSide;
    mFusAirfoilSide[(int)AS_UP] = "Top";
    mFusAirfoilSide[(int)AS_DOWN] = "Bottom";
    return mFusAirfoilSide;
}
 
map<int,const char*> CreateWingTypeStr( void )
{
    map<int,const char*> mWingTypeStr;
    mWingTypeStr[(int)WING_TYPE_SECTIONS] = "FromSections";
    mWingTypeStr[(int)WING_TYPE_MODULES] = "FromModules";
    mWingTypeStr[(int)WING_TYPE_NACELLE] = "Nacelle";
    return mWingTypeStr;
}
 
map<int,const char*> CreateAirfoilTypeStr( void )
{
    map<int,const char*>  mAirfoilTypeStr;
    mAirfoilTypeStr[(int)AIRFOIL_FILE] = "File";
    mAirfoilTypeStr[(int)AIRFOIL_NACA] = "NACA";
    mAirfoilTypeStr[(int)AIRFOIL_DATA] = "Data";
    return mAirfoilTypeStr;
}
 
map<int,const char*> CreateWingModTypeStr( void )
{
    map<int,const char*> mWingModTypeStr;
    mWingModTypeStr[(int)WING_MOD_TYPE_ROOT] = "Root";
    mWingModTypeStr[(int)WING_MOD_TYPE_EQUI_LINE] = "EquiLine";
    mWingModTypeStr[(int)WING_MOD_TYPE_ARC] = "Arc";
    mWingModTypeStr[(int)WING_MOD_TYPE_LINE] ="Line";
    return mWingModTypeStr;
}
 
map<int,const char*> CreateWingModConcStr( void )
{
    map<int,const char*>  mWingModPanConcStr;
    mWingModPanConcStr[(int)WING_MOD_PAN_CONC_LEFT] = "Left";
    mWingModPanConcStr[(int)WING_MOD_PAN_CONC_CENTER] = "Center";
    mWingModPanConcStr[(int)WING_MOD_PAN_CONC_RIGHT] = "Right";
    return mWingModPanConcStr;
}
 
map<int,const char*> CreateWingDivSourceStr( void )
{
    map<int,const char*> mWingDivSourceStr;
    mWingDivSourceStr[(int)WING_DIV_MASTER] = "Master";
    mWingDivSourceStr[(int)WING_DIV_SLAVE] = "Slave";
    mWingDivSourceStr[(int)WING_DIV_INDEPENDENT] = "Independent";
    return mWingDivSourceStr;
}
 
map<int,const char*> CreateWingSurfSideStr( void )
{
    map<int,const char*>  mWingSurfSideStr;
    mWingSurfSideStr[(int)WS_ALL] = "All";
    mWingSurfSideStr[(int)WS_TOP] = "Top";
    mWingSurfSideStr[(int)WS_BOTTOM] = "Bottom";
    return mWingSurfSideStr;
}
 
map<int,const char*> CreateWingRibTypeStr( void )
{
    map<int,const char*> mWingRibTypeStr;
    mWingRibTypeStr[(int)WING_RIB_OPEN] = "Open";
    mWingRibTypeStr[(int)WING_RIB_EXTERNAL] = "External";
    mWingRibTypeStr[(int)WING_RIB_BOTH] = "Both";
    mWingRibTypeStr[(int)WING_RIB_INTERNAL] = "Internal";
    return mWingRibTypeStr;
}
 
map<int,const char*> CreateWingSectionDivStr( void )
{
    map<int,const char*> mWingSectionDivStr;
    mWingSectionDivStr[(int)DT_LINEAR] = "Linear";
    mWingSectionDivStr[(int)DT_COSINE] = "Cosine";
    mWingSectionDivStr[(int)DT_USER] = "UserDef";
    mWingSectionDivStr[(int)DT_PROFILE] = "Profile";
    mWingSectionDivStr[(int)DT_AUTO] = "Unknown";     // "unknown" in ms2Edit
    return mWingSectionDivStr;
}
 
map<int,const char*> CreateNacelleSwirlStr( void )
{
    map<int,const char*> mNacelleSwirlStr;
    mNacelleSwirlStr[(int)SWIRL_UP] = "SwirlUp";
    mNacelleSwirlStr[(int)SWIRL_DOWN] = "SwirlDown";
    return mNacelleSwirlStr;
}
 
map<int,const char*> CreateNacelleRangeStr( void )
{
    map<int,const char*> mNacelleRangeStr;
    mNacelleRangeStr[(int)FULL_NACELLE] = "Full";
    mNacelleRangeStr[(int)HALF_NACELLE] = "Half";
    return mNacelleRangeStr;
}
 
//define strings used for types definition in ms2 file
map<int,const char*> MS2_Data::AirfoilTypeStr = CreateAirfoilTypeStr();
map<int,const char*> MS2_Data::FusTypeStr  = CreateFusTypeStr();
map<int,const char*> MS2_Data::FusCvrStr = CreateFusCvrStr();
map<int,const char*> MS2_Data::FusCvrTypeStr = CreateFusCvrTypeStr();
map<int,const char*> MS2_Data::FusAirfoilSide = CreateFusAirfoilSide();
map<int,const char*> MS2_Data::WingTypeStr = CreateWingTypeStr();
map<int,const char*> MS2_Data::WingModTypeStr = CreateWingModTypeStr();
map<int,const char*> MS2_Data::WingModPanConcStr = CreateWingModConcStr();
map<int,const char*> MS2_Data::WingDivSourceStr = CreateWingDivSourceStr();
map<int,const char*> MS2_Data::WingSurfSideStr = CreateWingSurfSideStr();
map<int,const char*> MS2_Data::WingRibTypeStr = CreateWingRibTypeStr();
map<int,const char*> MS2_Data::WingSectionDivStr = CreateWingSectionDivStr();
map<int,const char*> MS2_Data::NacelleSwirlStr = CreateNacelleSwirlStr();
map<int,const char*> MS2_Data::NacelleRangeStr = CreateNacelleRangeStr();
 
MS2_Data::MS2_Data( void )
{
   Clear();
}
 
MS2_Data::~MS2_Data( void )
{
 
}
 
void MS2_Data::Clear( void )
{
    //Version
    iVersion = 0;
    ClearGeneral( General );
    ClearFuselage( Fuselage );
    Wings.clear();
    Conns.clear();
    Wakes.clear();
}
 
void MS2_Data::SetDefaults( void )
{
    //Version
    iVersion = CURRENT_VERSION;
    //General
    General.RefVal.AutoComp = true;
    General.RefVal.S = 20.0;
    General.RefVal.B = 10.0;
    General.RefVal.MAC = 2.0;
    General.RefVal.MX = 0.25;
    General.RefVal.MZ = 0.0;
    General.RefVal.Scale = 1;
    General.SymmOpt = SYM_OPT_SYM;
    General.OutOpt = OUT_OPT_NODES;
    General.InpFileName = "";
    General.AutoInpFileName = 1;
 
    //Fuselage
    SetFuselageDefs( Fuselage );
 
    //Wings
    Wings.clear();
    Conns.clear();
    Wakes.clear();
}
 
void MS2_Data::ClearGeneral( MS2_General &gen )
{
    gen.InpFileName.clear();
    gen.SymmOpt = 0;
    gen.OutOpt = 0;
    gen.RefVal.AutoComp = 0;
    gen.RefVal.B = gen.RefVal.MAC = gen.RefVal.S = 0;
    gen.RefVal.Scale = 1;
    gen.RefVal.MX = gen.RefVal.MZ = 0;
}
 
void MS2_Data::ClearFuselage( MS2_Fuselage &fus )
{
    fus.Type = 0;
    fus.Exists = false;
    fus.Active = 0;
    fus.UserDiv.clear();
    fus.File.Name.clear();
    fus.Params.Name.clear();
    fus.Params.Nup = fus.Params.Ndown = 0;
    fus.Params.Scale = fus.Params.ScaleX = fus.Params.ScaleY = fus.Params.ScaleZup = fus.Params.ScaleZdown = 0;
    fus.Params.X0 = fus .Params.Y0 = fus.Params.Z0 = 0.0;
    fus.Params.BendLength = 0;
    fus.Params.BendAngle = 0;
    fus.Params.Length = 0;
 
    ClearFusCurve( fus.Params.SpineCvr, ELLIPSE_SPINE );
    ClearFusCurve( fus.Params.UpCvr, ELLIPSE_NORMAL );
    ClearFusCurve( fus.Params.SideCvr, ELLIPSE_NORMAL );
    ClearFusCurve( fus.Params.DownCvr, ELLIPSE_NORMAL );
    ClearFusCurve( fus.Params.CvFactUp, ELLIPSE_NORMAL);
    ClearFusCurve( fus.Params.CvFactDown, ELLIPSE_NORMAL );
}
 
void MS2_Data::SetFuselageDefs( MS2_Fuselage &fus )
{
    fus.Type = FT_PARAMS;
    fus.Exists = false;
    fus.Active = 1;
    fus.UserDiv.clear();
 
    fus.File.Name = "";
 
    fus.Params.Name = "Fuselage";
    fus.Params.Nup = fus.Params.Ndown = 10;
    fus.Params.Scale = fus.Params.ScaleX = fus.Params.ScaleY = fus.Params.ScaleZup = fus.Params.ScaleZdown =1;
    fus.Params.X0 = fus .Params.Y0 = fus.Params.Z0 = 0.0;
    fus.Params.BendLength = 0.5;
    fus.Params.BendAngle = 0;
    fus.Params.Length = 1;
 
    SetFusCurveDefs( fus.Params.SpineCvr, ELLIPSE_SPINE );
    SetFusCurveDefs( fus.Params.UpCvr, ELLIPSE_NORMAL );
    SetFusCurveDefs( fus.Params.SideCvr, ELLIPSE_NORMAL );
    SetFusCurveDefs( fus.Params.DownCvr, ELLIPSE_NORMAL );
    SetFusCurveDefs( fus.Params.CvFactUp, ELLIPSE_NORMAL);
    SetFusCurveDefs( fus.Params.CvFactDown, ELLIPSE_NORMAL );
}
 
void MS2_Data::ClearFusCurve( MS2_FusCurve &cvr, int elltype )
{
    cvr.Type = ELLIPSE;
    cvr.Factor = 0;
    cvr.Ellipse.EllType = elltype;
    cvr.Ellipse.NF = cvr.Ellipse.NR = 0;
    cvr.Ellipse.L = 0;
    cvr.Ellipse.H = 0;
    cvr.Ellipse.CvFactF = cvr.Ellipse.CvFactR = 0;
    cvr.Airfoil.iType = AIRFOIL_FILE;
    cvr.Airfoil.Name.clear();
    cvr.Airfoil.NACAnumber = 12;
    cvr.Airfoil.Side = 0;
}
 
void MS2_Data::SetFusCurveDefs( MS2_FusCurve &cvr, int elltype )
{
    cvr.Type = ELLIPSE;
    cvr.Factor = 0.5;
    cvr.Ellipse.EllType = elltype;
    cvr.Ellipse.NF = cvr.Ellipse.NR = 10;
    cvr.Ellipse.L = 0.5;
    cvr.Ellipse.H = 0.25;
    cvr.Ellipse.CvFactF = cvr.Ellipse.CvFactR = 0.5;
    cvr.Airfoil.iType = AIRFOIL_FILE;
    cvr.Airfoil.Name = "";
    cvr.Airfoil.NACAnumber = 12;
    cvr.Airfoil.Side = AS_UP;
}
 
 
void MS2_Data::ClearWing( MS2_Wing &wing )
{
    wing.ID = 0;
    wing.Active = 0;
    wing.Type = 0;
    wing.DivSource = 0;
    wing.ComputeInt = 0;
    wing.LongeronNo = 0;
    wing.RibType = 0;
    wing.Name.clear();
    wing.SurfType = 0;
    wing.DivNo = 10;
    wing.DivType = 0;
    wing.TwistRef = 0;
    wing.UserDiv.clear();
    wing.SmartBypass = 0;
    wing.BypassDepth = 0;
    //From sections
    wing.Sec.Sections.clear();
    wing.Sec.DivType = SDT_LINEAR;
    //From modules
    wing.Mod.Modules.clear();
    wing.UseMunk = 0;
    wing.SRef = 1.0;
    wing.CzDes = 1;
    //nacelle
    ClearNacelleWing( wing.Nac );
}
 
void MS2_Data::SetWingDefs( MS2_Wing &wing )
{
    ClearWing( wing );
    wing.Active = 1;
    wing.Type = WING_TYPE_SECTIONS;
    wing.DivSource = WING_DIV_MASTER;
    wing.ComputeInt = 0;
    wing.LongeronNo = 0;
    wing.RibType = WING_RIB_OPEN;
    wing.Name = "Wing";
    wing.SurfType = WS_ALL;
    wing.DivNo = 15;
    wing.DivType = DT_LINEAR;
    wing.TwistRef = 0;
    wing.UseMunk = 0;
    wing.SRef = 0;
    wing.CzDes = 1.0;
    wing.SmartBypass = 0;
    wing.BypassDepth = 2;
 
    wing.UserDiv.clear();
    //From sections
    wing.Sec.Sections.clear();
    wing.Sec.DivType = SDT_LINEAR;
    //From modules
    wing.Mod.Modules.clear();
    //nacelle
    SetNacelleWingDefs( wing.Nac );
}
 
 
void MS2_Data::ClearSection( MS2_Section &sect )
{
    sect.Profil.Name.clear();
    sect.Profil.ShortName.clear();
    sect.X = sect.Z = 0.0;
    sect.Y = 0.0;
    sect.RotX = sect.RotY = sect.RotZ = 0.0;
    sect.No = 0;
    sect.Chord = 0;
    sect.Profil.iType = AIRFOIL_FILE;
    sect.Profil.NACAnumber = 4415;
    sect.CtrlFlag = 0;
    sect.CoefPosFlag  = 1;
    sect.Deflection = 0.0;
    sect.Hinge_X = 0.75;
    sect.Hinge_Z = 0.0;
}
 
void MS2_Data::SetSectionDefs( MS2_Section &sect )
{
    sect.Profil.Name = "";
    sect.Profil.ShortName = "";
    sect.X = sect.Z = 0.0;
    sect.Y = 0.0;
    sect.RotX = sect.RotY = sect.RotZ = 0.0;
    sect.No = 0;
    sect.Chord = 10;
    sect.Profil.iType = AIRFOIL_FILE;
    sect.Profil.NACAnumber = 4415;
    sect.CtrlFlag = 0;
    sect.CoefPosFlag  = 1;
    sect.Deflection = 0.0;
    sect.Hinge_X = 0.75;
    sect.Hinge_Z = 0.0;
}
 
void MS2_Data::ClearPrf( MS2_Profile &prf )
{
    prf.Name.clear();
    prf.ShortName.clear();
    prf.Xd.clear();
    prf.Xg.clear();
    prf.Zd.clear();
    prf.Zg.clear();
    prf.iType = AIRFOIL_FILE;
    prf.NACAnumber = 4415;
}
 
void MS2_Data::SetPrfDefs( MS2_Profile &prf )
{
    prf.Name.clear();
    prf.ShortName.clear();
    prf.Xd.clear();
    prf.Xg.clear();
    prf.Zd.clear();
    prf.Zg.clear();
    prf.iType = AIRFOIL_NACA;
    prf.NACAnumber = 4415;
}
 
void MS2_Data::ClearModule( MS2_ModWingModule &mod )
{
    mod.Type = 0;
    mod.Profil.Name.clear();
    mod.Profil.NACAnumber = 4415;
    mod.X0 = mod.Y0 = mod.Z0 = 0.0;
    mod.XRef = 0.0;
    mod.C = 0;
    mod.Alfa = 0.0;
    mod.Fi = mod.Gamma = 0.0;
    mod.L = 0;
    mod.R = 0;
    mod.N = 0;
    mod.NDist = 0;
    mod.SpanPanConc = 0;
}
 
void MS2_Data::SetModuleDefs( MS2_ModWingModule &mod )
{
    mod.Type = WING_MOD_TYPE_ROOT;
    mod.Profil.Name = "";
    mod.Profil.NACAnumber = 4415;
    mod.X0 = 0.0;
    mod.Y0 = mod.Z0 = 0.0;
    mod.XRef = 0.25;
    mod.C = 1;
    mod.Alfa = 0.0;
    mod.Fi = mod.Gamma = 0.0;
    mod.L = 1.0;
    mod.R = 0.0;
    mod.N = 20;
    mod.NDist = 1;
    mod.SpanPanConc = WING_MOD_PAN_CONC_CENTER;
}
 
void MS2_Data::ClearConnection( MS2_Conn &conn )
{
    conn.Name .clear();
    conn.Type = 0; //vert to horiz
    conn.Active = 0;
    conn.Wing1No = 0;
    conn.Wing2No = 0;
    conn.Wing1Rib = 0;
    conn.Wing2Rib = 0;
    conn.Wing2LongLE = 0;
    conn.Wing2LongTE = 0;
    conn.Wing2Surf = 0;
}
 
void MS2_Data::SetConnectionDefs( MS2_Conn &conn )
{
    conn.Name = "Connection";
    conn.Active = 1;
    conn.Type = CON_H; //vert to horiz
    conn.Wing1No = 0;
    conn.Wing2No = 1;
    conn.Wing1Rib = 0;
    conn.Wing2Rib = 5;
    conn.Wing2LongLE = 0;
    conn.Wing2LongTE = 2;
    conn.Wing2Surf = 0;
}
 
void MS2_Data::ClearWake( MS2_Wake &wake )
{
    wake.Name .clear();
    wake.Type = 0;
    wake.Active = 0;
    wake.Wing1No = 0;
    wake.Wing2No = 0;
    wake.Wing1Rib = 0;
    wake.Wing2Rib = 0;
    wake.Wing2Surf = 0;
}
 
void MS2_Data::SetWakeDefs( MS2_Wake &wake )
{
    wake.Name = "main_wing";
    wake.Active = 1;
    wake.Type = WAKE_H; //horizontal wake
    wake.Wing1No = 0;
    wake.Wing2No = 0;
    wake.Wing1Rib = 0;
    wake.Wing2Rib = 3;
    wake.Wing2Surf = 0;
}
 
void MS2_Data::ClearNacelleWing( MS2_NacelleWing &nac )
{
    nac.Profil.Name.clear();
    nac.Profil.NACAnumber = 12;
    nac.NUp = nac.NDown = 0;
    nac.SwirlType = 0;
    nac.SwirlRange = 0;
    nac.X0 = nac.Y0 = nac.Z0 = 0.0;
    nac.L = 0;
    nac.CvFactUp = nac.CvFactDown = 0.0;
    nac.Y = nac.ZUp = nac.ZDown = 0.0;
    nac.fi = nac.theta = nac.psi = 0.0;
}
 
void MS2_Data::SetNacelleWingDefs( MS2_NacelleWing &nac )
{
    nac.Profil.Name = "";
    nac.Profil.NACAnumber = 12;
    nac.NUp = nac.NDown = 10;
    nac.SwirlType = SWIRL_UP;
    nac.SwirlRange = FULL_NACELLE;
    nac.X0 = nac.Y0 = nac.Z0 = 0.0;
    nac.L = 1;
    nac.CvFactUp = nac.CvFactDown = 0.5;
    nac.Y = nac.ZUp = nac.ZDown = 1.0;
    nac.fi = nac.theta = nac.psi = 0.0;
}
 
 
string MS2_Data::WingSurfName( int n )
{
    string retStr = "";
    switch( n )
    {
        case WS_ALL :
            //retStr = "all";
            //break;
        case WS_TOP :
            //retStr = "top";
            //break;
        case WS_BOTTOM :
            //retStr = "bottom";
            //break;
            retStr = string( WingSurfSideStr[n]);
            break;
        default :
            retStr = "";
            break;
    }
    return retStr;
}
 
string MS2_Data::DivTypeName( int div )
{
    string retStr = "";
    switch( div )
    {
        case DT_LINEAR :
            //retStr = "linear";
            //break;
        case DT_COSINE :
           // retStr = "cosine";
           // break;
        case DT_PROFILE :
           // retStr = "profile";
           // break;
        case DT_AUTO :
           // retStr = "unknown";
           // break;
           retStr = string( WingSectionDivStr[div]);
           break;
        default :
            retStr = "";
            break;
    }
    return retStr;
}
 
string MS2_Data::ConnTypeName( int n )
{
    string retStr = "";
    switch( n )
    {
        case CON_H :
            retStr = "Vertical (#1) to horizontal (#2)";
            break;
        case CON_V :
            retStr = "Horizontal (#1) to vertical (#2)";
            break;
        case CON_P :
            retStr = "Parallel connection";
            break;
        default :
            retStr = "Unknown";
            break;
    }
    return retStr;
}
 
string MS2_Data::WakeTypeName( int n )
{
    string retStr = "";
    switch( n )
    {
        case WAKE_H :
            retStr = "Horizontal";
            break;
        case WAKE_V :
            retStr = "Vertical";
            break;
        default :
            retStr = "Horizontal";
            break;
    }
    return retStr;
}
 
string MS2_Data::TruncateQuotMarks( string str )
{
    string retStr = RemoveWhiteSpaces(str);
 
    if( retStr[0] == '\"')
    {
        retStr = retStr.substr(1,retStr.size()-1);
    }
    if( retStr[retStr.size()-1] == '\"' )
    {
        retStr.resize( retStr.size()-1);
    }
    return retStr;
}
 
string MS2_Data::RemoveWhiteSpaces( string str )
{
    string retStr = str;
    int i=0;
    for( i=0; i<(int)str.length();i++ )
    {
        if( !isspace(retStr[i]) ) break;
    }
 
    if( i != 0 )
        retStr = retStr.erase(0,i);
 
    return retStr;
}
 
string MS2_Data::GetNACANoAsString( int no )
{
    char tmp[11];
    if( no > 9999 )
        sprintf(tmp,"%05u",no);
    else
        sprintf(tmp,"%04u",no);
    return string( tmp );
}
 
void MS2_Data::Comment( void )
{   
    fprintf( stderr, "%s\n", cComment );
}
 
 
bool MS2_Data::Read( const char * file, bool bRestrictive, bool auto_mod )
{
    // Zmodyfikowana wersja metody czytajacej dane z pliku *.ms2
    // Oryginaln : metoda "int MESH::czytaj_ms2 ( char* nazwainf )" (plik: mesh2.cpp)  Author: P.Blaszczyk (modif. T.Grabowski)
    FILE *t;
    t=fopen(file,"rt");
    int i,np;
    char ss[200],sss[20],ssss[11];
    int Pil, PVil, PPil;
 
    if( t == NULL )
        {
        sprintf( cComment, "Can't find file %s.", file );
        Comment();
        return false;
        }
 
    //read version
    rewind(t);
    int iVer = 0;
    iVer = find_section( t, "begin_version" );
 
    if( iVer == 0 ) //section not found
        iVersion = 2;
    else
    {
        if( iVer!=2 && iVer != 3 && iVer != 31 && iVer != 32 && iVer != 40 && iVer != 50 && iVer != 51 && iVer != 52 && iVer != 53 && iVer != 54 && iVer != 55)
        {
            sprintf( cComment, "Version  - wrong ms2 data file version (%d)", iVer );
            Comment();
            return false;
        }
        iVersion = iVer;
    }
 
    rewind(t);
 
    bool has_main = has_section( t, "begin" );
    if( !has_main )
        {
        sprintf( cComment, "Error: No global section in configuration file.");
        Comment();
        return false;
        }
 
    fscanf( t, "%s", ss );
    ReadComm( t );
    ClearGeneral( General );
    if (strcmp(ss,"*****")!=0)
        {
        General.RefVal.S = atof(ss);                 //SSS=atof(ss);
        ReadPar (t, "%lf", &General.RefVal.MAC);     //readln (t,&SCA);
        ReadPar (t, "%lf", &General.RefVal.B);       //readln (t,&B);
        ReadPar (t, "%lf", &General.RefVal.MX);      //readln (t,&X025);
        ReadPar (t, "%lf", &General.RefVal.MZ);      //readln (t,&Z025);
        ReadPar (t, "%lf", &General.RefVal.Scale);   //readln (t,&SKALA);
        ReadComm (t);
        General.RefVal.AutoComp = false;
        }
    else
        {
        if( iVersion > 52 )
            {
            ReadPar (t, "%lf", &General.RefVal.Scale);   //readln (t,&SKALA);
            ReadComm (t);
            }
        General.RefVal.AutoComp = true;
        }
 
    char nazwaout[200];
    //readln (t,nazwaout);
    ReadStr( t, nazwaout );
    General.InpFileName = string( nazwaout );
    if( iVersion >= 54 ) 
        ReadPar( t, "%d", &General.AutoInpFileName );
    else
        General.AutoInpFileName = 0;
 
    //liczba platow ze zdefiniowanym podzialem , liczba platow bez zdef. podzialu
    ReadPar (t, "%d", &Pil);
    ReadPar (t, "%d", &PVil);
    PPil = Pil+PVil;
    //Flaga symmetrii i typ pliku wyjsciowego
    General.SymmOpt = 0;
    General.OutOpt = 0;
    if( iVersion >= 52)
        {
        ReadPar( t, "%d", &General.SymmOpt );
        ReadPar( t, "%d", &General.OutOpt );
        }
    else
        {
        fscanf( t, "%s", ss );
        ReadComm( t );
        if (strcmp(ss,"end")!=0) General.SymmOpt = atoi(ss);    //iSym=atoi(ss);
        }
    
    //airfoils data
    Profiles.clear();
    if( iVersion >= 50 )
    {
    rewind(t);
    
        int NN = 0;
    while( true )
        {
        sprintf( ssss, "%d", NN );
        string cname = string( "begin_airfoil" ) + string( ssss );
        //cout << cname << endl; fflush( stdout );
        if( has_section( t, cname.c_str() ) == false )break;
        MS2_Profile PP;
        if( ReadProfile( t, PP ) == false )
            {
            if( bRestrictive ) return false;
            break;
            }
        Profiles.push_back( PP );
        NN++;
        }
    }
    
    //WINGS
    Wings.clear();
    for (np=0;np<PPil;np++)
        {
        //itoa(np,ssss,10);
        sprintf(ssss,"%d",np);
        strcpy(sss,"begin_wing");
        strcat(sss,ssss);
        do 
            {
            //readln (t,ss);
            fscanf( t, "%s", ss );
            ReadComm( t );
            }   
        while (strcmp(ss,sss));
        MS2_Wing newWing;
        ClearWing( newWing );
        if( !ReadWing( t, newWing, np, bRestrictive, auto_mod ) ) return false;
        Wings.push_back( newWing );
        }
 
    //FUSELAGE
    rewind(t);
    ClearFuselage( Fuselage );
    SetFuselageDefs( Fuselage );
    Fuselage.Exists = (bool)find_section( t, "begin_fuselage" );
    if ( Fuselage.Exists )
        {
        if( iVersion == 2 )
            {
            Fuselage.Type = FT_FILE; //default fuselage type for version
            Fuselage.Active = 1;
            }
        else
            {
            char tmpStr[20];
            int iRead = ReadPar( t, "%d", &Fuselage.Active );
            if( Fuselage.Active != 0 )Fuselage.Active = 1;
            iRead = ReadStr( t, tmpStr );
           // ReadDummy(t);
            if(/*iRead == 0 || */ iRead == EOF )
                {
                sprintf( cComment, "Fuselage  - wrong fuselage type (type=%s)", tmpStr );
                Comment();
                return false;
                }
            if( CompareStrings( tmpStr, (char*)FusTypeStr[(int)FT_FILE] ) )
                {
                Fuselage.Type = FT_FILE;
                }
            else if( CompareStrings( tmpStr, (char*)FusTypeStr[(int)FT_PARAMS] ) )
                {
                Fuselage.Type = FT_PARAMS;
                }
            else
                {
                sprintf( cComment, "Fuselage  - wrong fuselage type (type=%s)", tmpStr );
                Comment();
                return false;
                }
            }
 
        if( Fuselage.Type == FT_FILE  )
            {
            char Knazwa[200];
            ReadStr( t, Knazwa );
            Fuselage.File.Name = string( Knazwa );
            Fuselage.File.Name = MS2_Data::TruncateQuotMarks( Fuselage.File.Name );
            if( Fuselage.File.Name.empty() )
                {
                sprintf( cComment, "Fuselage  - empty fuselage name" );
                Comment();
                return false;
                }
            ReadDummy( t );
            }
        else if( Fuselage.Type == FT_PARAMS )
            {
            if( ReadFusFromParams( t , bRestrictive ) == false )return false;
            }
        else
            {
            sprintf( cComment, "Fuselage  - wrong fuselage type (type=%d)", Fuselage.Type );
            Comment();
            return false;
            }
        int Kidod = 0;
        ReadPar (t,"%d",&Kidod);
        double wspKdod = 0;
        Fuselage.UserDiv.clear();
        for (i=0;i<Kidod;i++)
            {
            fscanf (t,"%lf",&wspKdod);
            Fuselage.UserDiv.push_back( wspKdod );
            }
        //ReadComm( t );
 
        if( iVersion >= 51 )
            ReadPar(t,"%d %d",&Fuselage.iDivSectionType,&Fuselage.iSecN);
        else
            {
            Fuselage.iDivSectionType = FDT_DATA; 
            Fuselage.iSecN = 10;
            }
        ReadDummy( t );
        }
 
    //CONNECTIONS
    Conns.clear();
    rewind(t);
    int ICon = find_section( t, "begin_connections" );
    if( ICon > 0 )
        {
        for( int i=0; i<ICon; i++ )
            {
            MS2_Conn newConn;
            ClearConnection( newConn );
            CONNECT_DATA Con;
            Con.Read(t, (int)CON_H, iVersion);
            CONNECT2MS2_Conn( Con, newConn );
            //if( MS2_Data::CheckConnData( newConn, Wings, HasGUI() ) == false )
            //{
            //   if( bRestrictive ) return false;
            //}
            Conns.push_back( newConn );
            }
        }
    if( iVersion == 2 )
        {
        // V - CONNECTIONS
        rewind(t);
        int IConV = find_section( t, "begin_connections_V" );
        if( IConV > 0 )
            {
            for( int i=0; i<IConV; i++ )
                {
                MS2_Conn newConn;
                ClearConnection( newConn );
                CONNECT_DATA ConV;
                ConV.Read(t, (int)CON_V, iVersion);
                CONNECT2MS2_Conn( ConV, newConn );
                //if( CheckConnData( newConn, Wings, HasGUI() ) == false )
                //{
                //    if( bRestrictive ) return false;
                //}
                Conns.push_back( newConn );
                }
            }
        }
    //WAKE info
    Wakes.clear();
    rewind(t);
    int IWake = find_section( t, "begin_wake_info" );
    if( IWake > 0 )
        {
        char name[200];
        for( int i=0; i<IWake; i++ )
            {
            MS2_Wake newWake;
            ClearWake( newWake );
 
            ReadStr( t, name );
            int iTyp = WAKE_H;
            if( CompareStrings( name, (char*)(WakeTypeName((int)WAKE_H)).c_str() ) == true )
                iTyp = WAKE_H;
            else if( CompareStrings( name, (char*)(WakeTypeName((int)WAKE_V)).c_str() ) == true )
                iTyp = WAKE_V;
            newWake.Type = iTyp;
            ReadStr( t, name );
            newWake.Name = string( name );
            fscanf ( t, "%d", &newWake.Active );
            fscanf ( t, "%d", &newWake.Wing1No );
            fscanf ( t, "%d", &newWake.Wing2No );
            fscanf ( t, "%d", &newWake.Wing1Rib );
            fscanf ( t, "%d", &newWake.Wing2Rib );
            fscanf ( t, "%d", &newWake.Wing2Surf );
            //if( MS2_Data::CheckWakeData( newWake, Wings, HasGUI() ) == false )
            //{
            //   if( bRestrictive ) return false;
            //}
            Wakes.push_back( newWake );
            }
        }
 
    iVersion = CURRENT_VERSION;
    fclose (t);
 
    return true;
}
 
 
bool MS2_Data::ReadFusFromParams( FILE *t, bool bRestrictive )
{
    //global
    char name[200];
    ReadStr( t, name );
    Fuselage.Params.Name = string( name );
    Fuselage.Params.Name = MS2_Data::TruncateQuotMarks( Fuselage.Params.Name );
    int iN[2]={0};
    ReadVect( t,iN,2,1);
    Fuselage.Params.Nup = iN[0];
    Fuselage.Params.Ndown = iN[1];
 
    double dVect[5] = {0};
    ReadVect(t,dVect,3,1);
    Fuselage.Params.X0 = dVect[0];
    Fuselage.Params.Y0 = dVect[1];
    Fuselage.Params.Z0 = dVect[2];
    memset( dVect, 0, sizeof(double)*5 );
 
    ReadVect(t,dVect,5,1);
    Fuselage.Params.Scale = dVect[0];
    Fuselage.Params.ScaleX = dVect[1];
    Fuselage.Params.ScaleY = dVect[2];
    Fuselage.Params.ScaleZup = dVect[3];
    Fuselage.Params.ScaleZdown = dVect[4];
    memset( dVect, 0, sizeof(double)*5 );
 
    ReadVect(t,dVect,3,1);
    Fuselage.Params.Length = dVect[0];
    Fuselage.Params.BendLength = dVect[1];
    Fuselage.Params.BendAngle = dVect[2];
 
    bool bReadStat = true;
/*--------------------------------------------------------------------*/
    //spine
    char tempStr[40];
    int iRead = fscanf( t, "%s", tempStr );//fuselage curve name string
    if( iRead == 0 || iRead == EOF ) bReadStat = false; //UWAGA
 
    if( CompareStrings(tempStr,(char*)FusCvrStr[(int)CRV_SPINE]) == false || bReadStat == false )
    {
        sprintf( cComment, "Fuselage spine definition error. Spine definition was not found or was defined incorrectly. (%s)",tempStr);
        Comment();
        return false;
    }
 
    iRead = fscanf( t, "%s", tempStr );
    Fuselage.Params.SpineCvr.Type = -99;
    if( CompareStrings(tempStr, (char*)FusCvrTypeStr[(int)ELLIPSE]))
    {
        Fuselage.Params.SpineCvr.Type = ELLIPSE;
    }
    else if( CompareStrings(tempStr, (char*)FusCvrTypeStr[(int)AIRFOIL]))
    {
        Fuselage.Params.SpineCvr.Type = AIRFOIL;
    }
 
    bReadStat = true;
    if( iRead == 0 ||  iRead == EOF ) bReadStat = false;
    if( Fuselage.Params.SpineCvr.Type == ELLIPSE )
    {
        bReadStat *= ReadFusEllipse( t, Fuselage.Params.SpineCvr.Ellipse, "Spine" );
    }
    else if( Fuselage.Params.SpineCvr.Type == AIRFOIL )
    {
        bReadStat *= ReadFusAirfoil( t, Fuselage.Params.SpineCvr.Airfoil, "Spine", bRestrictive );
    }
    else
    {
        sprintf( cComment, "Fuselage spine definition error. Wrong spine type (%s)", tempStr );
        Comment();
        return false;
    }
    if( bReadStat == false )
    {
        sprintf( cComment, "Fuselage spine definition error." );
        Comment();
        return false;
    }
 
/*--------------------------------------------------------------------*/
    //Up contour
    iRead = fscanf( t, "%s", tempStr );
    bReadStat = true;
    if( iRead == 0 ||  iRead == EOF ) bReadStat = false;
 
    if( CompareStrings(tempStr,(char*)FusCvrStr[(int)CRV_UP_CONT]) == false || bReadStat == false )
    {
       sprintf( cComment, "Fuselage up contour  definition error. Up contour definition was not foud or was defined incorrectly. (%s)",tempStr);
       Comment();
       return false;
    }
    bReadStat = true;
    iRead = fscanf( t, "%s", tempStr );
    if( iRead == 0 ||  iRead == EOF ) bReadStat = false;
    Fuselage.Params.UpCvr.Type = -99;
    if( CompareStrings(tempStr, (char*)FusCvrTypeStr[(int)ELLIPSE]))
    {
        Fuselage.Params.UpCvr.Type = ELLIPSE;
    }
    else if( CompareStrings(tempStr, (char*)FusCvrTypeStr[(int)AIRFOIL]))
    {
        Fuselage.Params.UpCvr.Type = AIRFOIL;
    }
 
    if( Fuselage.Params.UpCvr.Type == ELLIPSE )
    {
        bReadStat *= ReadFusEllipse( t, Fuselage.Params.UpCvr.Ellipse, "Up contour" );
    }
    else if( Fuselage.Params.UpCvr.Type == AIRFOIL )
    {
        bReadStat *= ReadFusAirfoil( t, Fuselage.Params.UpCvr.Airfoil, "Up contour", bRestrictive );
    }
    else
    {
        sprintf( cComment, "Fuselage up contour definition error. Wrong contour type (%s)", tempStr );
        Comment();
        return false;
    }
    if( bReadStat == false )
    {
        sprintf( cComment, "Fuselage up contour definition error.\n" );
        Comment();
        return false;
    }
 
/*--------------------------------------------------------------------*/
    //Side contour
    iRead = fscanf( t, "%s", tempStr );
    bReadStat = true;
    if( iRead == 0 ||  iRead == EOF ) bReadStat = false; //UWAGA
 
    if( CompareStrings(tempStr,(char*)FusCvrStr[(int)CRV_SIDE_CONT]) == false || bReadStat == false )
    {
        sprintf( cComment, "Fuselage side contour  definition error. Side contour definition was not foud or was defined incorrectly. (%s)",tempStr);
        Comment();
        return false;
    }
    bReadStat = true;
    iRead = fscanf( t, "%s", tempStr );
    if( iRead == 0 || iRead == EOF ) bReadStat = false;
    Fuselage.Params.SideCvr.Type = -99;
    if( CompareStrings(tempStr, (char*)FusCvrTypeStr[(int)ELLIPSE]))
    {
        Fuselage.Params.SideCvr.Type = ELLIPSE;
    }
    else if( CompareStrings(tempStr, (char*)FusCvrTypeStr[(int)AIRFOIL]))
    {
        Fuselage.Params.SideCvr.Type = AIRFOIL;
    }
 
    if( Fuselage.Params.SideCvr.Type == ELLIPSE )
    {
        bReadStat *= ReadFusEllipse( t, Fuselage.Params.SideCvr.Ellipse, "Side contour" );
    }
    else if( Fuselage.Params.SideCvr.Type == AIRFOIL )
    {
        bReadStat *= ReadFusAirfoil( t, Fuselage.Params.SideCvr.Airfoil, "Side contour", bRestrictive );
    }
    else
    {
        sprintf( cComment, "Fuselage side contour definition error. Wrong contour type (%s)", tempStr );
        Comment();
        return false;
    }
    if( bReadStat == false )
    {
        sprintf( cComment, "Fuselage side contour definition error." );
        Comment();
        return false;
    }
 
/*--------------------------------------------------------------------*/
    //down contour
    bReadStat = true;
    iRead = fscanf( t, "%s", tempStr );
    if( iRead == 0 ||  iRead == EOF ) bReadStat = false;
 
    if( CompareStrings(tempStr,(char*)FusCvrStr[(int)CRV_DOWN_CONT]) == false || bReadStat == false )
    {
        sprintf( cComment, "Fuselage down contour  definition error. Down contour definition was not foud or was defined incorrectly. (%s)",tempStr);
        Comment();
        return false;
    }
    bReadStat = true;
    iRead = fscanf( t, "%s", tempStr );
    if( iRead == 0 ||  iRead == EOF ) bReadStat = false;
    Fuselage.Params.DownCvr.Type = -99;
    if( CompareStrings(tempStr, (char*)FusCvrTypeStr[(int)ELLIPSE]))
    {
        Fuselage.Params.DownCvr.Type = ELLIPSE;
    }
    else if( CompareStrings(tempStr, (char*)FusCvrTypeStr[(int)AIRFOIL]))
    {
        Fuselage.Params.DownCvr.Type = AIRFOIL;
    }
 
    if( Fuselage.Params.DownCvr.Type == ELLIPSE )
    {
        bReadStat *= ReadFusEllipse( t, Fuselage.Params.DownCvr.Ellipse,  "Down contour" );
    }
    else if( Fuselage.Params.DownCvr.Type == AIRFOIL )
    {
        bReadStat *= ReadFusAirfoil( t, Fuselage.Params.DownCvr.Airfoil, "Down contour", bRestrictive );
    }
    else
    {
        sprintf( cComment, "Fuselage down contour definition error. Wrong contour type (%s)", tempStr );
        Comment();
        return false;
    }
    if( bReadStat == false )
    {
        sprintf( cComment, "Fuselage  down contour definition error." );
        Comment();
        return false;
    }
 
/*--------------------------------------------------------------------*/
    //up convexity factor curve
    bReadStat = true;
    iRead = fscanf( t, "%s", tempStr );
    if( iRead == 0 || iRead == EOF ) bReadStat = false;
 
    if( CompareStrings(tempStr,(char*)FusCvrStr[(int)CRV_CV_FACT_UP]) == false || bReadStat == false )
    {
        sprintf( cComment, "Fuselage up convexity factors definition error. Up convexity factors definition was not foud or was defined incorrectly. (%s)",tempStr);
        Comment();
        return false;
    }
    bReadStat = true;
    iRead = fscanf( t, "%s", tempStr );
    if( iRead == 0 || iRead == EOF ) bReadStat = false;
    Fuselage.Params.CvFactUp.Type = -99;
    if( CompareStrings(tempStr, (char*)FusCvrTypeStr[(int)ELLIPSE]))
    {
        Fuselage.Params.CvFactUp.Type = ELLIPSE;
    }
    else if( CompareStrings(tempStr, (char*)FusCvrTypeStr[(int)AIRFOIL]))
    {
        Fuselage.Params.CvFactUp.Type = AIRFOIL;
    }
    else if( CompareStrings( tempStr, (char*)FusCvrTypeStr[(int)CONSTANT] ))
    {
        Fuselage.Params.CvFactUp.Type = CONSTANT;
    }
 
    if( Fuselage.Params.CvFactUp.Type == ELLIPSE )
    {
        bReadStat *= ReadFusEllipse( t, Fuselage.Params.CvFactUp.Ellipse, "Up  convexity factors" );
    }
    else if( Fuselage.Params.CvFactUp.Type == AIRFOIL )
    {
        bReadStat *= ReadFusAirfoil( t, Fuselage.Params.CvFactUp.Airfoil, "Up  convexity factors", bRestrictive );
    }
    else if( Fuselage.Params.CvFactUp.Type == CONSTANT )
    {
        ReadPar( t, "%lf", &Fuselage.Params.CvFactUp.Factor);
    }
    else
    {
        sprintf( cComment, "Fuselage up convexity factors definition error. Wrong type (%s)", tempStr );
        Comment();
        return false;
    }
    if( bReadStat == false )
    {
        sprintf( cComment, "Fuselage up convexity factors definition error." );
        Comment();
        return false;
    }
 
    //down convexity factor curve
    bReadStat = true;
    iRead = fscanf( t, "%s", tempStr );
    if( iRead == 0 ||  iRead == EOF ) bReadStat = false;
 
    if( CompareStrings(tempStr,(char*)FusCvrStr[(int)CRV_CV_FACT_DOWN]) == false || bReadStat == false )
    {
        sprintf( cComment, "Fuselage down convexity factors definition error. Down convexity factors definition was not foud or was defined incorrectly. (%s)",tempStr);
        Comment();
        return false;
    }
    bReadStat = true;
    iRead = fscanf( t, "%s", tempStr );
    if( iRead == 0 ||  iRead == EOF ) bReadStat = false;
    Fuselage.Params.CvFactDown.Type = -99;
    if( CompareStrings(tempStr, (char*)FusCvrTypeStr[(int)ELLIPSE]))
    {
        Fuselage.Params.CvFactDown.Type = ELLIPSE;
    }
    else if( CompareStrings(tempStr, (char*)FusCvrTypeStr[(int)AIRFOIL]))
    {
        Fuselage.Params.CvFactDown.Type = AIRFOIL;
    }
    else if( CompareStrings( tempStr, (char*)FusCvrTypeStr[(int)CONSTANT] ))
    {
        Fuselage.Params.CvFactDown.Type = CONSTANT;
    }
 
    if( Fuselage.Params.CvFactDown.Type == ELLIPSE )
    {
        bReadStat *= ReadFusEllipse( t, Fuselage.Params.CvFactDown.Ellipse, "Down  convexity factors" );
    }
    else if( Fuselage.Params.CvFactDown.Type == AIRFOIL )
    {
        bReadStat *= ReadFusAirfoil( t, Fuselage.Params.CvFactDown.Airfoil, "Down  convexity factors", bRestrictive  );
    }
    else if( Fuselage.Params.CvFactDown.Type == CONSTANT )
    {
        ReadPar( t, "%lf", &Fuselage.Params.CvFactDown.Factor);
    }
    else
    {
        sprintf( cComment, "Fuselage down convexity factors definition error. Wrong type (%s)", tempStr );
        Comment();
        return false;
    }
    if( bReadStat == false )
    {
        sprintf( cComment, "Fuselage down convexity factors definition error." );
        Comment();
        return false;
    }
 
    return true;
}
 
bool MS2_Data::ReadFusEllipse( FILE *t, MS2_SuperEllipse &SupEll, const char * desc )
{
    double vect[4]={0};
    ReadVect(t,vect,4);
    if( SupEll.EllType == ELLIPSE_SPINE )
    {
        SupEll.NF = (int)vect[0];
        SupEll.NR = (int)vect[1];
    }
    else if( SupEll.EllType == ELLIPSE_NORMAL )
    {
        SupEll.L = vect[0];
        SupEll.H = vect[1];
    }
 
    else
    {
        fprintf( stderr, "Wrong super ellipse type (%d) in %s\n", SupEll.EllType, desc );
        return false;
    }
    SupEll.CvFactF = vect[2];
    SupEll.CvFactR = vect[3];
    return true;
}
 
bool MS2_Data::ReadFusAirfoil( FILE *t, MS2_FusAirfoil &airfoil, const char * desc, bool bRestrictive)
{
    char name[256];
    char tempStr[20];
 
    int iRead = fscanf( t, "%s", tempStr ); //side
    if( iRead == 0 ||  iRead == EOF )
        {
        fprintf( stderr, "Empty/wrong airfoil side in %s.\n", desc );
        return false;
        }
 
    if( CompareStrings(tempStr, (char*)FusAirfoilSide[(int)AS_UP]) )
        {
        airfoil.Side = AS_UP;
        }
    else if( CompareStrings(tempStr, (char*)FusAirfoilSide[(int)AS_DOWN]) )
        {
        airfoil.Side = AS_DOWN;
        }
    else
        {
        fprintf( stderr, "Empty/wrong airfoil side in %s.\n", desc );
        if( bRestrictive)
            return false;
        else
           airfoil.Side = AS_UP;
        }
 
    if( iVersion >= 50 )
        {
        ReadProfile( t, airfoil, desc, false );
        }
    else
        {
 
        iRead = fscanf( t, "%s", tempStr );//source
 
        if( iRead == 0 || iRead == EOF )
            {
            fprintf( stderr, "Empty/wrong airfoil source in %s.\n", desc );
            return false;
            }
 
        if( CompareStrings(tempStr, (char*)AirfoilTypeStr[(int)AIRFOIL_FILE]) )
            {
            airfoil.iType = AIRFOIL_FILE;
            }
        else if( CompareStrings(tempStr, (char*)AirfoilTypeStr[(int)AIRFOIL_NACA]) )
            {
            airfoil.iType = AIRFOIL_NACA;
            }
        else
            {
            fprintf( stderr, "Empty/wrong airfoil source in %s.\n", desc );
            return false;
            }
 
        if( airfoil.iType == AIRFOIL_FILE )
            {
            iRead = ReadStr( t, name ); //UWAGA
 
            if( strlen(name)==0 || iRead == EOF /*||iRead == 0 */)
                {
                sprintf( cComment, "Empty/wrong airfoil name in %s", desc );
                Comment();
                if( bRestrictive)
                    return false;
                else
                    airfoil.Name = "NACA4415.prf";
                }
            else
                {
                airfoil.Name = string( name );
                airfoil.Name =  MS2_Data::TruncateQuotMarks( airfoil.Name );
                airfoil.ShortName = string( filename_name( airfoil.Name.c_str() ) );
                }
    
            }
        else if( airfoil.iType == AIRFOIL_NACA )
            {
            char nacastr[20];
            iRead = ReadStr( t, nacastr );
            //check if NACA airfoil i 4 or 5 digit
            if( (strlen(nacastr) ==  4 || strlen(nacastr) == 5 ) && iRead != EOF /*&& iRead != 0 */ ) //UWAGA
                {
                airfoil.NACAnumber = atoi( nacastr );
                }
            else
                {
                sprintf( cComment, "Empty/wrong NACA airfoil number in %s. NACA number %s was read.", desc, nacastr );
                Comment();
                if( bRestrictive )
                    return false;
                else
                    airfoil.NACAnumber = 4415;
                }
            }
 
        }
    
    //ReadDummy( t );
    return true;
}
 
bool MS2_Data::ReadWing( FILE *t, MS2_Wing &wing, int iW, bool bRestrictive , bool auto_mod )
{
    char ss[200];
    char name[200];
    char tmpStr[20];
    ostringstream oss;
    
    wing.ID = iW;
    
    if( iVersion == 2 )
    {
        oss<<iW;
        wing.Type = WING_TYPE_SECTIONS;
        wing.DivSource = WING_DIV_MASTER;
        wing.Name = "Wing " + oss.str();
        wing.Active = 1;
    }
    else
    {
        ReadPar( t,"%d", &wing.Active );
        //wing type
        int iRead = 0;// = fscanf(t, "%s", tmpStr );
        ReadStr( t, tmpStr );
 
        if( CompareStrings(tmpStr,(char*)WingTypeStr[(int)WING_TYPE_SECTIONS]))
            wing.Type = WING_TYPE_SECTIONS;
        else if( CompareStrings(tmpStr,(char*)WingTypeStr[(int)WING_TYPE_MODULES]))
            wing.Type = WING_TYPE_MODULES;
        else if( CompareStrings(tmpStr,(char*)WingTypeStr[(int)WING_TYPE_NACELLE]))
            wing.Type = WING_TYPE_NACELLE;
        else
        {
            sprintf( cComment, "Wing %d  - wrong wing type", iW );
            Comment();
            return false;
        }
 
    if( iVersion >= 40 )fscanf( t, "%d", &wing.ID );
 
        //name
        ReadStr( t, name );
        wing.Name = string( name );
        if( wing.Name.empty() )
            {
            sprintf( cComment, "Wing %d  - empty wing's name", iW );
            Comment();
            return false;
            }
 
        //fuselage-wing intersection source
        iRead = ReadStr( t, tmpStr ); //div source
        if( /*Read == 0 || */iRead == EOF ) //UWAGA
            {
            sprintf( cComment, "Wing \"%s\"  - wrong wing division source (%s)", wing.Name.c_str(), tmpStr );
            Comment();
            return false;
            }
        if( CompareStrings( tmpStr, (char*)WingDivSourceStr[(int)WING_DIV_MASTER ]))
            wing.DivSource = WING_DIV_MASTER;
        else if( CompareStrings( tmpStr, (char*)WingDivSourceStr[(int)WING_DIV_SLAVE ]))
            wing.DivSource = WING_DIV_SLAVE;
        else if( CompareStrings( tmpStr, (char*)WingDivSourceStr[(int)WING_DIV_INDEPENDENT ]))
            wing.DivSource = WING_DIV_INDEPENDENT;
        else
            {
            sprintf( cComment, "Wing \"%s\"  - wrong wing division source (%s)", wing.Name.c_str(), tmpStr );
            Comment();
            if( bRestrictive )
                return false;
            else
                {
                wing.DivSource = WING_DIV_MASTER;
                }
            }
 
        ReadPar (t,"%d",&wing.ComputeInt);
        ReadPar (t,"%d",&wing.LongeronNo);
        if( iVersion >= 51 )
            {
            ReadPar (t,"%d",&wing.SmartBypass);
            ReadPar (t,"%d",&wing.BypassDepth);
            }
        else
            {
            wing.SmartBypass = 0;
            wing.BypassDepth = 0;
            }
        
        if( wing.DivSource == WING_DIV_INDEPENDENT )
            {
            wing.ComputeInt = 0;
            wing.LongeronNo = 0;
            wing.SmartBypass = 0;
            wing.BypassDepth = 0;
            }
 
        //surface to create
        iRead = ReadStr( t, ss ); //UWAGA
        if ( CompareStrings( ss, (char*)WingSurfSideStr[(int)WS_BOTTOM] ) )
            wing.SurfType = WS_BOTTOM;
        else if ( CompareStrings( ss, (char*)WingSurfSideStr[(int)WS_TOP] ) )
            wing.SurfType = WS_TOP;
        else if ( CompareStrings( ss, (char*)WingSurfSideStr[(int)WS_ALL] ) )
            wing.SurfType = WS_ALL;
        else
            {
            sprintf( cComment, "Wing \"%s\"  - wrong wing surface name (%s)", wing.Name.c_str(), ss );
            Comment();
            if( bRestrictive )
                return false;
            else
                wing.SurfType = WS_ALL;
            }
        //rib type
        iRead = ReadStr( t, tmpStr );//UWAGA
        if( /*iRead == 0 ||*/ iRead == EOF )
            {
            sprintf( cComment, "Wing \"%s\"  - wrong wing rib's type", tmpStr );
            Comment();
            return false;
            }
        if( CompareStrings(tmpStr,(char*)WingRibTypeStr[(int)WING_RIB_OPEN]))
            wing.RibType = WING_RIB_OPEN;
        else if( CompareStrings(tmpStr,(char*)WingRibTypeStr[(int)WING_RIB_EXTERNAL]))
            wing.RibType = WING_RIB_EXTERNAL;
        else if( CompareStrings(tmpStr,(char*)WingRibTypeStr[(int)WING_RIB_BOTH]))
            wing.RibType = WING_RIB_BOTH;
        else if( CompareStrings(tmpStr,(char*)WingRibTypeStr[(int)WING_RIB_INTERNAL]))
            wing.RibType = WING_RIB_INTERNAL;
        else
            wing.RibType = -99;
 
        if( wing.RibType != WING_RIB_OPEN && wing.RibType != WING_RIB_EXTERNAL && wing.RibType != WING_RIB_BOTH && wing.RibType != WING_RIB_INTERNAL )
            {
            sprintf( cComment, "Wing \"%s\"  - wrong wing rib type", wing.Name.c_str() );
            Comment();
            if( bRestrictive )
                return false;
            else
                wing.RibType = WING_RIB_BOTH;
            }
 
        if( iVersion >= 31 )
            {
            //twist point location (0..1)
            ReadPar(t, "%lf", &wing.TwistRef);
            if( wing.TwistRef < 0 || wing.TwistRef>1)
                {
                sprintf( cComment, "Wing \"%s\"  - wrong twist reference point (%f). Value should be between 0 and 1", wing.Name.c_str(),wing.TwistRef );
                Comment();
                return false;
                }
 
            ReadPar( t, "%d", &wing.UseMunk );
            if( wing.UseMunk == 1)
                {
                iRead = fscanf( t,"%lf %lf", &wing.SRef, &wing.CzDes );
                if( iRead == 0 || iRead == EOF || ferror(t) != 0 )
                    {
                    sprintf( cComment, "Wing \"%s\" - wrong referece area (%f) or Clift design (%f) for minimum drag calculation. Minimum induced drag calculation will be disabled.", wing.Name.c_str(),wing.SRef, wing.CzDes );
                    Comment();
                    wing.UseMunk = 0;
                    wing.CzDes = 1.0;
                    wing.SRef = 0;
                    }
                }
            else if( wing.UseMunk != 0 )  //jesli useMunk nie jest 1 lub 0 znaczy ze plik nie jest poprawny
                {
                //error
                sprintf( cComment, "Wing \"%s\" - wrong minimum drag calculation flag (%d). Value 0 or 1 was expected.", wing.Name.c_str(),wing.UseMunk );
                Comment();
                wing.UseMunk = 0;
                wing.CzDes = 1.0;
                wing.SRef = 0;
                return false;
                }
            }
        else
            {
            wing.TwistRef = 0.;
            wing.UseMunk = 0;
            wing.CzDes = 1.0;
            wing.SRef = 0;
            }
    }
 
    if( wing.Type == WING_TYPE_SECTIONS )
    {
        if( iVersion == 2 ) //in version 3 moved to the global wing properties
        {
            ReadPar (t,"%d",&wing.RibType);
            if( wing.RibType != WING_RIB_OPEN && wing.RibType != WING_RIB_EXTERNAL && wing.RibType != WING_RIB_BOTH && wing.RibType != WING_RIB_INTERNAL )
            {
                sprintf( cComment, "Wing \"%s\"  - wrong wing rib type", wing.Name.c_str() );
                Comment();
                if( bRestrictive )
                    return false;
                else
                    wing.RibType = WING_RIB_BOTH;
            }
        ReadPar (t,"%d",&wing.ComputeInt);
        ReadPar (t,"%d",&wing.LongeronNo);
            if( wing.LongeronNo < 0 || wing.ComputeInt < 0 )wing.DivSource = WING_DIV_INDEPENDENT;
        }
 
        int iSect = 0;
        ReadPar (t,"%d",&iSect);
/*  
        if( iSect > SEC )
        {
            fprintf( stderr, "Wing \"%s\"  - too many wing sections (max=%d)\n", wing.Name.c_str(), SEC );
            if( HasGUI() )fl_alert( "Wing \"%s\"  - too many wing sections (max=%d)", wing.Name.c_str(), SEC );
            return false;
        }
*/  
        if( iVersion >= 32 )
        {
            wing.Sec.DivType = SDT_LINEAR;
            int iDivType;
            ReadPar (t,"%d",&iDivType);
            if( iDivType <= SDT_COSINE_INT )wing.Sec.DivType = iDivType;
        }
    
        for( int i=0;i<iSect;i++)
        {
            MS2_Section newSect;
            ClearSection( newSect );
            if( ReadSection( t, newSect ) )
                wing.Sec.Sections.push_back( newSect );
            else
                return false;
        }
        if( iVersion == 2 )
        {
            if( ReadChordDivision( t, wing, bRestrictive ) == false ) return false;
            fscanf( t, "%s", ss );
            ReadComm( t );
            if (strcmp(ss,"end_wing")!=0)
            {
                if (strcmp(ss,"bottom")==0) wing.SurfType = WS_BOTTOM;
                else wing.SurfType = WS_TOP;
            }
            else
                wing.SurfType = WS_ALL;
        }
    }
    else if( wing.Type == WING_TYPE_MODULES )
    {
        int count = 0;
        ReadPar( t, "%d", &count );
        wing.Mod.Modules.clear();
        for( int i=0; i< count; i++ )
        {
            MS2_ModWingModule mod;
            ClearModule( mod );
            if( ReadWingModule( t, mod, bRestrictive ) )
            {
                wing.Mod.Modules.push_back(mod);
            }
            else
            {
                sprintf( cComment, "Wing \"%s\" - wrong wing module #%d definition!", wing.Name.c_str(),i );
                Comment();
                return false;
            }
        }
    }
    else if( wing.Type == WING_TYPE_NACELLE )
    {
    char airfoil[256];
        MS2_NacelleWing nac;
        ClearNacelleWing( nac );
        
        if( iVersion >= 50 )
            ReadProfile( t, nac.Profil, "nacelle airfoil", false );
        else
            {
            int iRead = ReadStr( t, airfoil );
            nac.Profil.Name = string( airfoil );
            nac.Profil.Name =  MS2_Data::TruncateQuotMarks( nac.Profil.Name );
            nac.Profil.ShortName = string( filename_name( nac.Profil.Name.c_str() ) );
            nac.Profil.iType = AIRFOIL_FILE;
            if( iRead == 0 || iRead == EOF || nac.Profil.Name.empty() )
                {
                sprintf( cComment, "Wing \"%s\"  - empty airfoil's name for nacelle", wing.Name.c_str() );
                Comment();
                if( bRestrictive )
                    return false;
                else
                    nac.Profil.Name = "NACA4415.prf";
                }
            }
    
        ReadPar( t, "%lf %lf %lf", &nac.X0, &nac.Y0, &nac.Z0 );
        ReadPar( t, "%lf %lf %lf", &nac.fi, &nac.theta, &nac.psi );
        ReadPar( t, "%lf %lf %lf", &nac.L, &nac.CvFactUp, &nac.CvFactDown );
        ReadPar( t, "%lf %lf %lf", &nac.Y, &nac.ZUp, &nac.ZDown );
 
        ReadPar( t, "%d %d", &nac.NUp, &nac.NDown );
 
        char nacRange[20];
        int iRead = ReadPar( t, "%s %s", tmpStr, nacRange );//UWAGA
 
        if( /*iRead == 0 ||*/ iRead == EOF )
        {
            nac.SwirlType  = -99;
            nac.SwirlRange = -99;
        }
 
        if( CompareStrings(tmpStr, (char*)NacelleSwirlStr[(int)SWIRL_UP]))
            nac.SwirlType  = SWIRL_UP;
        else if( CompareStrings(tmpStr, (char*)NacelleSwirlStr[(int)SWIRL_DOWN]))
            nac.SwirlType  = SWIRL_DOWN;
        else
            nac.SwirlType  = -99;
 
        if( ( nac.SwirlType != SWIRL_UP ) && (nac.SwirlType != SWIRL_DOWN ) )
        {
            sprintf( cComment, "Wing \"%s\" - wrong nacelle swirl type!", wing.Name.c_str() );
            Comment();
            if( bRestrictive )
                return false;
            else
                nac.SwirlType = SWIRL_UP;
        }
 
        if( CompareStrings(nacRange, (char*)NacelleRangeStr[(int)FULL_NACELLE]))
            nac.SwirlRange = FULL_NACELLE;
        else if( CompareStrings(nacRange, (char*)NacelleRangeStr[(int)HALF_NACELLE]))
            nac.SwirlRange = HALF_NACELLE;
        else
            nac.SwirlRange = -99;
 
        if( ( nac.SwirlRange!= FULL_NACELLE ) && (nac.SwirlRange != HALF_NACELLE ) )
        {
            sprintf( cComment, "Wing \"%s\" - wrong nacelle swirl range!", wing.Name.c_str() );
            Comment();
            if( bRestrictive )
                return false;
            else
                nac.SwirlRange = FULL_NACELLE;
        }
 
        wing.Nac = nac;
    }
    else
    {
        sprintf( cComment, "Wing \"%s\" - wrong wing type!", wing.Name.c_str() );
        Comment();
        return false;
    }
 
    //section division
    if( iVersion != 2 )
    {
        if( ReadChordDivision( t, wing, bRestrictive ) == false ) return false;
    }
 
    //Create section wing data for non-section wings 
/*
    if( wing.Type == WING_TYPE_MODULES)
    {
        Wing_Module2Sec( wing );
    }
    else if( wing.Type == WING_TYPE_NACELLE )
    {
        Wing_Nacelle2Sec( wing );
    }
*/
    return true;    //VerifyWing( wing, true/*HasGUI()*/, auto_mod, bRestrictive );
}
 
bool MS2_Data::ReadChordDivision( FILE* t, MS2_Wing &wing, bool bRestrictive )
{
    char tmpStr[255];
    int iRead = fscanf( t, "%s", tmpStr );
    if( /*iRead == 0 ||*/ iRead == EOF )
    {
        sprintf( cComment, "Wing \"%s\"  - wrong wing section division", wing.Name.c_str() );
        Comment();
        return false;
    }
 
    //if (strcmp(ss,"unknown")==0)
    if( CompareStrings( tmpStr , (char*)WingSectionDivStr[(int)DT_AUTO]))
    {
        wing.DivType = DT_AUTO;
        if( iVersion == 2 )
        {
            wing.DivSource = WING_DIV_SLAVE;
        }
 
        if( wing.DivSource != WING_DIV_SLAVE )
        {
            sprintf( cComment, "Wing \"%s\"  - The \"%s\" chord division type is not valid for \"%s\" wings", wing.Name.c_str(), tmpStr, WingDivSourceStr[wing.DivSource]);
            Comment();
            if( bRestrictive )
                return false;
            else
                wing.DivSource = WING_DIV_SLAVE;
        }
    }
    //else if (strcmp(ss,"profile")==0)
    else if( CompareStrings( tmpStr , (char*)WingSectionDivStr[(int)DT_PROFILE]))
    {
        wing.DivType = DT_PROFILE;
    }
    //else if (strcmp(ss,"cosine")==0)
    else if( CompareStrings( tmpStr , (char*)WingSectionDivStr[(int)DT_COSINE]))
    {
        ReadPar (t, "%d", &wing.DivNo );
        wing.DivType = DT_COSINE;
    }
    //else if (strcmp(ss,"linear")==0)
    else if( CompareStrings( tmpStr , (char*)WingSectionDivStr[(int)DT_LINEAR]))
    {
        ReadPar (t, "%d", &wing.DivNo );
        wing.DivType = DT_LINEAR;
    }
    else
    { //user defined
        int i = 0;
        while( tmpStr[i] != '\0' )
        {
            if( isdigit( tmpStr[0]) == 0 )
            {
                sprintf( cComment,  "Wing \"%s\"  - Wrong chord division \"%s\"", wing.Name.c_str(), tmpStr );
                Comment();
                if( bRestrictive ) return false;
            }
            i++;
        }
 
        wing.DivType = DT_USER;
        vector<double> tmp;
        tmp.push_back( (double)atof(tmpStr) );
 
        double tmpDiv = 0;
        int iRead = 0;
        do
        {
            iRead = fscanf( t, "%s", tmpStr );
            //    fprintf( stderr, "tmpStr %s %d\n", tmpStr, i );
            while( tmpStr[i] != '\0' )
            {
                if( isdigit( tmpStr[0]) == 0 )
                {
                    sprintf( cComment,  "Wing \"%s\"  - Wrong chord division \"%s\"", wing.Name.c_str(), tmpStr );
                    Comment();
                    return false;
                }
                i++;
            }
            // iRead = fscanf(t, "%lf", &tmpDiv );
            if( /*iRead == 0 || */ iRead == EOF )
            {
                sprintf( cComment,  "Wing \"%s\"  - Wrong chord division.", wing.Name.c_str() );
                Comment();
                return false;
            }
            tmpDiv = (double)atof(tmpStr) ;
            //fprintf( stderr, "tmpDiv = %f\n", tmpDiv );
            if( tmp[tmp.size()-1 ] > tmpDiv )
            {
               // fprintf( stderr, "tmpStr %s\n", tmpStr );
                sprintf( cComment,  "Wing \"%s\"  - Chord division is not in ascending order.", wing.Name.c_str() );
                Comment();
                if( bRestrictive )
                    return false;
            }
 
            if( tmp[tmp.size()-1 ] == tmpDiv )
            {
                sprintf( cComment,  "Wing \"%s\"  - Repeated chord division (%4.2f) will be ignored.", wing.Name.c_str(), tmpDiv );
                Comment();
                ReadDummy( t );
                continue;
            }
 
            tmp.push_back( tmpDiv );
            ReadDummy( t );
        }
        while (fabs(tmpDiv-100.0)>1e-19 );
/*
        if( (int)tmp.size() > Mmax )
        {
            fprintf( stderr,  "Wing \"%s\"  - too many wing longerons (max=%d)", wing.Name.c_str(), Mmax );
            if( HasGUI() )fl_alert(  "Wing \"%s\"  - too many wing longerons (max=%d)", wing.Name.c_str(), Mmax );
            if( bRestrictive )
                return false;
        }
*/
        if( tmp[0] != 0 || tmp[tmp.size()-1] != 100 )
        {
            sprintf( cComment, "Wing \"%s\"  - wrong user defined chord division.\nChord division should start with 0 and end at 100.", wing.Name.c_str() );
            Comment();
            if( bRestrictive )
                return false;
        }
        wing.UserDiv = tmp;
    }
    return true;
}
 
bool MS2_Data::ReadWingModule( FILE* t, MS2_ModWingModule &mod, bool bRestrictive )
{
    ReadDummy(t);
    char airfoil[255];
    char tmpStr[40];
    int iRead = 0;
    bool bRead = true;
    bool readSpanConc = false;
 
    iRead = fscanf( t, "%s", tmpStr );
    if( /*iRead == 0 ||*/ iRead == EOF ) //UWAGA
        bRead *= false;
    if( CompareStrings( tmpStr, (char*)WingModTypeStr[(int)WING_MOD_TYPE_ROOT ]))
        mod.Type = WING_MOD_TYPE_ROOT;
    else if( CompareStrings( tmpStr, (char*)WingModTypeStr[(int)WING_MOD_TYPE_EQUI_LINE ]))
        mod.Type = WING_MOD_TYPE_EQUI_LINE;
    else if( CompareStrings( tmpStr, (char*)WingModTypeStr[(int)WING_MOD_TYPE_ARC]))
        mod.Type = WING_MOD_TYPE_ARC;
    else if( CompareStrings( tmpStr, (char*)WingModTypeStr[(int)WING_MOD_TYPE_LINE ]))
        mod.Type = WING_MOD_TYPE_LINE;
    else
    {
        sprintf( cComment, "Wing module reading error - wrong module type (%s)!", tmpStr);
        Comment();
        return false;
    }
 
    iRead = fscanf( t,"%lf %lf", &mod.C, &mod.Alfa );
    if( iRead == 0 || iRead == EOF || ferror(t) != 0 )
            bRead *= false;
 
    if( mod.Type == WING_MOD_TYPE_ROOT)
    {
        iRead = fscanf( t, "%lf %lf %lf %lf", &mod.XRef, &mod.X0, &mod.Y0, &mod.Z0 );
        if( iRead == 0 || iRead == EOF || ferror(t) != 0 )
            bRead *= false;
    }
    else if( mod.Type == WING_MOD_TYPE_EQUI_LINE )
    {
        iRead = fscanf( t, "%lf %lf %d %lf %lf %lf %d", &mod.Fi, &mod.Gamma, &mod.N, &mod.NDist, &mod.L, &mod.R, &mod.UseMunk);
        if( iRead == 0 || iRead == EOF || ferror(t) != 0 )
            bRead *= false;
        readSpanConc = true;
    }
    else if( mod.Type == WING_MOD_TYPE_LINE )
    {
        iRead = fscanf( t, "%lf %lf %d %lf %lf %lf %d", &mod.Fi, &mod.Gamma, &mod.N, &mod.NDist, &mod.L, &mod.R, &mod.UseMunk);
        if( iRead == 0 || iRead == EOF || ferror(t) != 0 )
            bRead *= false;
        readSpanConc = true;
    }
    else if( mod.Type == WING_MOD_TYPE_ARC )
    {
        iRead = fscanf( t, "%lf %lf %d %lf %lf %d", &mod.Fi, &mod.Gamma, &mod.N, &mod.NDist, &mod.R, &mod.UseMunk);
        if( iRead == 0 || iRead == EOF || ferror(t) != 0 )
            bRead *= false;
        readSpanConc = true;
    }
    else
    {
        sprintf( cComment, "Wing module reading error - wrong module type (%d)!", mod.Type );
        Comment();
        return false;
    }
 
    if( bRead == false )
    {
        sprintf( cComment, "Wing module reading error!" );
        Comment();
        clearerr(t);
        return false;
    }
 
 
    if( readSpanConc == true )
    {
        iRead = fscanf( t, "%s", tmpStr );
        if( /*iRead == 0 ||*/ iRead == EOF ) //UWAGA
            bRead *= false;
        if( CompareStrings( tmpStr, (char*)WingModPanConcStr[(int)WING_MOD_PAN_CONC_LEFT]))
            mod.SpanPanConc = WING_MOD_PAN_CONC_LEFT;
        else if( CompareStrings( tmpStr, (char*)WingModPanConcStr[(int)WING_MOD_PAN_CONC_CENTER ]))
            mod.SpanPanConc = WING_MOD_PAN_CONC_CENTER;
        else if( CompareStrings( tmpStr, (char*)WingModPanConcStr[(int)WING_MOD_PAN_CONC_RIGHT]))
            mod.SpanPanConc = WING_MOD_PAN_CONC_RIGHT;
        else
        {
            sprintf( cComment, "Wing module reading error - wrong span paneling type (%s)!", tmpStr);
            Comment();
            return false;
        }
    }
 
 
    if( iVersion >= 50 )
        ReadProfile( t, mod.Profil, "modular wing airfoil", false );
    else
        {
        iRead = ReadStr( t, airfoil );
        mod.Profil.Name = string( airfoil );
        mod.Profil.Name =  MS2_Data::TruncateQuotMarks( mod.Profil.Name );
        mod.Profil.ShortName = string( filename_name( mod.Profil.Name.c_str() ) );
        mod.Profil.iType = AIRFOIL_FILE;
        if( iRead == 0 || iRead == EOF )
           {
           sprintf( cComment, "Wing module reading error - wrong airfoil's name (%s)!", mod.Profil.Name.c_str() );
           Comment();
           if( bRestrictive )
               return false;
           else
               mod.Profil.Name = "NACA4415.prf";
           }
        }
 
    if( bRead == false )
    {
        sprintf( cComment, "Wing module reading error!" );
        Comment();
        return false;
    }
    return true;
}
 
bool MS2_Data::ReadSection( FILE *t, MS2_Section &sect )
{
    if( iVersion >= 50 )
        ReadProfile( t, sect.Profil, "wing section", false );
    else
        {
        //sprawdzic ilosc podzialow wzdluz cieciwy oraz  if nrsect-1>Max sect number
        char nazwa[256];
        ReadStr( t, nazwa);
        sect.Profil.Name = string( nazwa );
        sect.Profil.Name =  MS2_Data::TruncateQuotMarks( sect.Profil.Name );
        sect.Profil.ShortName = string( filename_name( sect.Profil.Name.c_str() ) );
        sect.Profil.iType = AIRFOIL_FILE;
    }
 
    ReadPar ( t, "%lf", &sect.Chord);
    ReadPar ( t, "%lf %lf %lf", &sect.X, &sect.Y, &sect.Z );
    ReadPar ( t, "%lf %lf %lf", &sect.RotX, &sect.RotY, &sect.RotZ );
    if( iVersion >= 55 )
    {
    ReadPar ( t, "%d %d", &sect.CtrlFlag, &sect.CoefPosFlag );
    ReadPar ( t, "%lf %lf %lf", &sect.Deflection, &sect.Hinge_X, &sect.Hinge_Z );
    }
    ReadPar ( t, "%d", &sect.No );
 
    return true;
}
 
bool MS2_Data::ReadProfile( FILE *t, MS2_Profile &airfoil, const char* desc, bool bRestrictive )
{
    char tempStr[20];
    ClearPrf( airfoil );
 
    int iRead = ReadStr( t, tempStr );        // iType
 
    if( iRead == 0 || iRead == EOF )
        {
        fprintf( stderr, "Empty/wrong airfoil source in %s.\n", desc );
        return false;
        }
 
    if( CompareStrings(tempStr, (char*)AirfoilTypeStr[(int)AIRFOIL_FILE]) )
        {
        airfoil.iType = AIRFOIL_FILE;
        }
    else if( CompareStrings(tempStr, (char*)AirfoilTypeStr[(int)AIRFOIL_NACA]) )
        {
        airfoil.iType = AIRFOIL_NACA;
        }
    else if( CompareStrings(tempStr, (char*)AirfoilTypeStr[(int)AIRFOIL_DATA]) )
        {
        airfoil.iType = AIRFOIL_DATA;
        }
    else
        {
        fprintf( stderr, "Empty/wrong airfoil source in %s.\n", desc );
        return false;
        }
 
//    fprintf( stderr, "airfoil source in %s %s\n", desc, tempStr );
//    fflush( stderr );
 
    char name[256];
 
    if( airfoil.iType == AIRFOIL_FILE )
        {
        iRead = ReadStr( t, name );
 
        if( strlen(name)==0 || iRead == EOF )
            {
            if( bRestrictive )
                {
                sprintf( cComment, "Empty/wrong airfoil name in %s", desc ); Comment();
                return false;
                }
            else
                {
                sprintf( cComment, "Empty/wrong airfoil filename %s in %s\nNACA 4415 is established", filename_name(name), desc ); Comment();
                airfoil.Name = "NACA4415.prf";
                }
            }
        else
            {
            airfoil.Name = string( name );
            airfoil.Name = MS2_Data::TruncateQuotMarks( airfoil.Name );
            }
        
        airfoil.ShortName = string( filename_name( airfoil.Name.c_str() ) );
        }
    else if( airfoil.iType == AIRFOIL_NACA )
        {
        char nacastr[20];
        iRead = ReadStr( t, nacastr );
        //check if NACA airfoil i 4 or 5 digit
        if( ( strlen(nacastr) ==  4 || strlen(nacastr) == 5 ) && iRead != EOF )
            {
            airfoil.NACAnumber = atoi( nacastr );
            }
        else
            {
            sprintf( cComment, "Empty/wrong NACA airfoil number in %s. NACA number %s was read.", desc, nacastr ); Comment();
            if( bRestrictive )
               return false;
            else
               airfoil.NACAnumber = 4415;
            }
        airfoil.ShortName = string( "naca" ) + GetNACANoAsString( airfoil.NACAnumber );
        airfoil.Name = airfoil.ShortName;
       }
    else if( airfoil.iType == AIRFOIL_DATA )
        {
        iRead = ReadStr( t, name );
        airfoil.Name = airfoil.ShortName = string( name );
 
        int iFound = 0;
        int N = Profiles.size();
        for( int i=0; i<N; i++ )
            {
            if( Profiles[i].ShortName.compare( airfoil.ShortName ) == 0 )
                {
                int NN = Profiles[i].Xd.size();
                for( int ii=0; ii<NN; ii++ )
                    {
                    airfoil.Xd.push_back(Profiles[i].Xd[ii]);
                    airfoil.Zd.push_back(Profiles[i].Zd[ii]);
                    airfoil.Xg.push_back(Profiles[i].Xg[ii]);
                    airfoil.Zg.push_back(Profiles[i].Zg[ii]);
                    }
                iFound = 1;
                break;
                }
            }
 
        if( iFound == 0 )
            {
            if( bRestrictive )
                {
                sprintf( cComment, "Empty/wrong airfoil name %s in %s", name, desc ); Comment();
                return false;
                }
            else
                {
                sprintf( cComment, "Empty/wrong airfoil name %s in %s\nNACA 4415 is established", name, desc ); Comment();
                airfoil.iType = AIRFOIL_NACA;
                airfoil.NACAnumber = 4415;
                airfoil.ShortName = string( "naca" ) + GetNACANoAsString( airfoil.NACAnumber );
                airfoil.Name = airfoil.ShortName;
                }
            }
        }
 
    return true;
}
 
bool MS2_Data::ReadProfile( FILE *t, MS2_Profile &airfoil )
{
    char name[256];
    int NN = 0;
    double xd, xg, zd, zg;
    
    ClearPrf( airfoil );
    
    ReadStr( t, name );
    airfoil.Name = airfoil.ShortName = string( name );
    ReadPar( t, "%d", &NN );
    for( int i=0; i<NN; i++ )
       {
       ReadPar( t, "%lf %lf %lf %lf", &xd, &zd, &xg, &zg );
       airfoil.Xd.push_back( xd );
       airfoil.Zd.push_back( zd );
       airfoil.Xg.push_back( xg );
       airfoil.Zg.push_back( zg );
       }
    airfoil.iType = AIRFOIL_DATA;
 
    return true;
}
 
 
void MS2_Data::CONNECT2MS2_Conn( CONNECT_DATA &Con, MS2_Conn &newConn )
{
    newConn.Type = Con.iTyp;
    newConn.Active = Con.iActive;
    newConn.Wing1No = Con.CP1;
    newConn.Wing2No = Con.CP2;
    newConn.Wing1Rib = Con.Czeb1;
    newConn.Wing2Rib = Con.Czeb2;
    newConn.Wing2LongLE = Con.Cstart;
    newConn.Wing2LongTE = Con.Cend;
    newConn.Wing2Surf = Con.Csurf;
    newConn.Name = Con.ConName;//ConnectionDesc( newConn );
    //fprintf( stderr,"Conn desc: %s\n",newConn.Name.c_str() );
}
 
void MS2_Data::MS2_Conn2CONNECT(  MS2_Conn &Conn, CONNECT_DATA &newCon )
{
    newCon.iTyp = Conn.Type;
    newCon.iActive = Conn.Active;
    newCon.ConName = Conn.Name;
    newCon.CP1 = Conn.Wing1No;
    newCon.CP2 = Conn.Wing2No;
    newCon.Czeb1 = Conn.Wing1Rib;
    newCon.Czeb2 = Conn.Wing2Rib;
    newCon.Cstart = Conn.Wing2LongLE;
    newCon.Cend = Conn.Wing2LongTE;
    newCon.Csurf = Conn.Wing2Surf;
}
 
int MS2_Data::find_section( FILE *t, const char* sec)
{
//Metoda find section przeniesiona z "mesh2h/cpp" Author: T.Grabowski
    char ss[200];
    int N;
    do
        {
        fscanf( t, "%s", ss );
        if( ReadComm(t) == EOF )
            {
            rewind(t);
            fprintf(stderr,"brak sekcji: %s\n", sec);
            return 0;
            }
        }
    while( strcmp(ss,sec) );
 
    ReadPar( t, "%d", &N );
    return N;
}
 
bool MS2_Data::has_section( FILE *t, const char * sec )
{
    char ss[200];
    do
        {
    fscanf( t, "%s", ss );
    if( ReadComm(t) == EOF )
            {
            rewind(t);
            fprintf(stderr,"missing section: %s\n", sec); fflush( stderr );
            return false;
            }
        }
    while( strcmp(ss,sec) );
    return true;
}
 
 
bool MS2_Data::Write( const char *file )
{
    bool res = true;
    ofstream outFile( file, ios_base::out );
    if( outFile.fail() )
    {
        sprintf( cComment, "Output file can not be opened" );
        Comment();
        return false;
    }
    //General
    res *= WriteGeneral( outFile );
 
    //Wings
    outFile<<endl<<"#######################"<<endl;
    outFile<<"/*"<<endl;
    outFile<<"WING Section (\"begin_wing*\")"<<endl;
    outFile<<"   is wing active ( 1- active, 2 - not active)"<<endl;
    outFile<<"   wing type ("<<WingTypeStr[(int)WING_TYPE_SECTIONS]<<" - build from sections,  "<<WingTypeStr[(int)WING_TYPE_MODULES]<<" - build from modules, "<<WingTypeStr[(int)WING_TYPE_NACELLE]<<" - nacelle)"<<endl;
    outFile<<"   name"<<endl;
    outFile<<"   create wing as: ("<<WingDivSourceStr[(int)WING_DIV_MASTER]<<", "<< WingDivSourceStr[(int)WING_DIV_SLAVE]<<", "<<WingDivSourceStr[(int)WING_DIV_INDEPENDENT] <<")"<<endl;
    outFile<<"   compute fuselage-wing intersection: 0 - no, 1 - yes"<<endl;
    outFile<<"   the fuselage longeron number (according to definition of sections in the fuselage geometry file) which begins the wing"<<endl;
    outFile<<"   wing surface to create ("<< WingSurfSideStr[(int)WS_ALL]<<", "<< WingSurfSideStr[(int)WS_TOP]<<", "<< WingSurfSideStr[(int)WS_BOTTOM]<<")"<<endl;
    outFile<<"   rib type ("<< WingRibTypeStr[(int)WING_RIB_OPEN]<<", "<< WingRibTypeStr[(int)WING_RIB_EXTERNAL]<<", "<< WingRibTypeStr[(int)WING_RIB_BOTH]<<", "<< WingRibTypeStr[(int)WING_RIB_INTERNAL]<<")"<<endl;
    outFile<<"   twist reference point (0...1) (0 - leading edge, 1 - trailing edge)"<<endl;
    outFile<<"   <rest of wing definition ( see documentation )>"<<endl;
    /*
    outFile<<"   should the closing rib be created (Pclosed: 0 - no, 1 - exterior, 2 - exterior and interior)"<<endl;
    outFile<<"   intersection of wing and fuselage (Pcut: 0 - no; the wing is joined, 1 -yes) - important if there's a fuselage"<<endl;
    outFile<<"   the fuselage longeron number (according to definition of sections in the fuselage geometry file) which begins the wing"<<endl;
    outFile<<"   number of cross-sections - ribs defined for a wing (Pizeb)"<<endl;
    outFile<<"   definitions of successive cross-sections (Pizeb times)"<<endl;
    outFile<<"   name of the profile data file (Pprof[Pizeb] - e.g. naca0012.prf)"<<endl;
    outFile<<"      chord Pc[Pizeb]"<<endl;
    outFile<<"      coordinates of the leading point (x,y,z), starting point (pps[Pizeb])"<<endl;
    outFile<<"      angles of rib turns with X Y Z axis"<<endl;
    outFile<<"      rib number Pnr[Pizeb] - starting from \"0\"; if the rib numbers in successive cross-section definitions aren't "<<endl;
    outFile<<"      successive natural numbers, additional ribs will be automatically put between defined ones on the assumption"<<endl;
    outFile<<"      that the wing cross-section change is linear."<<endl;
    outFile<<"   divides chord wise - this row should look like this:"<<endl;
    outFile<<"   string of numbers defining the longeron in chord percentages (must begin with 0 and end with 100)"<<endl;
    outFile<<"   \"cosine n\" - co sinusoidal divide, where n is the number of all longerons"<<endl;
    outFile<<"   \"linear n\" - linear divide, where n is the number of all longerons"<<endl;
    outFile<<"   \"unknown\" - no divide defined - it will be taken according to the divide of e.g. fuselage"<<endl;
    outFile<<"      (useful for fin, when it is adjacent to tail plane)"<<endl;
    outFile<<"   option - only bottom \"bottom\" or top \"top\" wing surface"<<endl;
    */
    outFile<<"   End of wing section (\"end\")"<<endl;
    outFile<<" */"<<endl;
    outFile<<"#######################"<<endl<<endl;
 
    for( int i=0;i < (int)Wings.size();i++ )
    {
        res *= WriteWing( outFile, Wings[i], i );
    }
    //Fuselage
    res *= WriteFuselage( outFile );
    //Connections
    res *= WriteConns( outFile );
    //Wakes
    res *= WriteWakes( outFile );
    //Profiles
    res = WriteEmbededProfiles( outFile, &Profiles );
 
    outFile.close();
    return res;
}
 
std::string MS2_Data::RemoveExt( string filename )
{
    string myFile = filename;
    string ext( filename_ext( myFile.c_str() ) );
    size_t found;
    found = myFile.rfind(ext);
    if (found!=string::npos)
        myFile.erase( found,ext.length() );
    return myFile;
}
 
bool MS2_Data::WriteGeneral( ostream &fout )
{
    if( iVersion != CURRENT_VERSION ) iVersion = CURRENT_VERSION;       //Always save as current version
    fout<<"# *****************************************"<<endl;
    fout<<"# *                                       *"<<endl;
    fout<<"# *  Automatically generated config file  *"<<endl;
    fout<<"# *                                       *"<<endl;
    fout<<"# *****************************************"<<endl;
    fout<<"#"<<endl;
    fout<<"/*"<<endl;
    fout<<"Each section in this file begins by keyword \"begin\" and ends by keyword \"end\"."<<endl;
    fout<<"Keyword \"begin\" could be extended (e.g. \"begin_wing0\") by name of section:"<<endl;
    fout<<"wing*, fuselage, connections, connections_V."<<endl;
    fout<<"In the main section reference values (up to row \"*****\")"<<endl;
    fout<<"can be omitted - then they will be computed using main wing section (section \"wing0\")."<<endl;
    fout<<"The geometry is defined in the axis system defined as follows:"<<endl;
    fout<<"\torigin in fuselage nose, leading edge point of main wing (in the symmetry plane),"<<endl;
    fout<<"\tit should be the most forward point of the aircraft body,"<<endl;
    fout<<"\taxis x - backward, usually longwise the Mean Aerodynamic Chord (MAC)"<<endl;
    fout<<"\taxis y - on the right wing,"<<endl;
    fout<<"\taxis z - up."<<endl;
//    fout<<"The geometry should be defined to satisfy positive X coordinates for all aircraft body."<<endl;
    fout<<"*/"<<endl;
    fout<<endl;
    //version
    fout<<endl<<"#######################"<<endl;
    fout<<"/*"<<endl;
    fout<<"Version section (\"begin_version\")"<<endl;
    fout<<"   version number"<<endl;
    fout<<"   End of version section (\"end\")"<<endl;
    fout<<" */"<<endl;
    fout<<"#######################"<<endl<<endl;
    fout<<endl<<"begin_version"<<endl;
    fout<<iVersion<<endl;
    fout<<"end"<<endl;
    fout<<endl;
    fout<<endl<<"#######################"<<endl;
    fout<<"/*"<<endl;
    fout<<"Main section (\"begin\")"<<endl;
    fout<<"\treference area"<<endl;
    fout<<"\tMAC"<<endl;
    fout<<"\twing span"<<endl;
    fout<<"\tX coordinate of quarter of MAC     (it is the point, which is the pole"<<endl;
    fout<<"\tZ coordinate of quarter of MAC      for moments calculation)"<<endl;
    fout<<"\tscale coefficient"<<endl;
    fout<<"*****"<<endl;
    fout<<"\tname of the output grid file (without extension - default extension [.inp] will be added)"<<endl;
    fout<<"\tautomatic output file name flag"<<endl;
    fout<<"\t\t1 (default) output file name [.inp] based on ms2 file name"<<endl;
    fout<<"\t\t0 full pathname defined by user"<<endl;
    fout<<"\tnumber of wings with defined chord wise partition"<<endl;
    fout<<"\tnumber of wings without defined chord wise partition"<<endl;
    fout<<"\tsymmetry flag:"<<endl;
    fout<<"\t\t0 (default if flag doesn't exist) - symmetrical object"<<endl;
    fout<<"\t\t1 - right part"<<endl;
    fout<<"\t\t-1 - left part"<<endl;
    fout<<"\toutput type flag:"<<endl;
    fout<<"\t\t0 (default if flag doesn't exist) - mesh written as nodes"<<endl;
    fout<<"\t\t1 - mesh written as panels"<<endl;
    fout<<"The end of main section (\"end\")"<<endl;
    fout<<"*/"<<endl;
    fout<<"#######################"<<endl<<endl;;
    //begin main section
    fout<<endl<<"begin"<<endl;
    
    fout.setf(ios::fixed,ios::floatfield);
    fout.precision(5);
    
    if( !General.RefVal.AutoComp )
    {
        fout<<General.RefVal.S<<endl;
        fout<<General.RefVal.MAC<<endl;
        fout<<General.RefVal.B<<endl;
        fout<<General.RefVal.MX<<endl;
        fout<<General.RefVal.MZ<<endl;
        fout<<General.RefVal.Scale<<endl;
        fout<<"*****"<<endl;
    }
    else
    {
        fout<<"*****"<<endl;
        fout<<General.RefVal.Scale<<endl;
        fout<<"*****"<<endl;
    }
    fout<<General.InpFileName<<endl;
    fout<<General.AutoInpFileName<<endl;
//    string inpFile( filename_name( General.InpFileName.c_str() ) );
//    fout<<RemoveExt(inpFile)<<endl;
    fout<<GetIndpWingNo()<<endl;
    fout<<GetDpWingNo()<<endl;
    fout<<General.SymmOpt<<endl;
    fout<<General.OutOpt<<endl;
    fout<<"end"<<endl;
    return true;
}
 
bool MS2_Data::WriteFuselage( ostream &fout )
{
    fout<<endl<<"#######################"<<endl;
    fout<<"/*"<<endl;
    fout<<"FUSELAGE Section (\"begin_fuselage\")"<<endl;
    fout<<"   does the fuselage exist: 1 - fuselage exists, 0 - doesn't exist"<<endl;
    fout<<"   is the fuselage active:  1 - active, 0 - not active"<<endl;
    fout<<"   type of fuselage: "<< FusTypeStr[(int)FT_FILE]<<" - from file, "<<FusTypeStr[(int)FT_PARAMS] <<" - automatically generated"<<endl;
    fout<<"   <type = "<<  FusTypeStr[(int)FT_FILE]<<">"<<endl;
    fout<<"   name of the fuselage sections data file (default extension [.f])"<<endl;
    fout<<"   <type = "<< FusTypeStr[(int)FT_PARAMS]  <<"> (see documentation)"<<endl;
    fout<<"   number of additional sections computed automatically"<<endl;
    fout<<"   \"x\" coordinates of additional sections"<<endl;
    fout<<"End of fuselage section (\"end\")"<<endl;
    fout<<"*/"<<endl;
    fout<<"#######################"<<endl<<endl;
 
    fout<<endl<<"begin_fuselage"<<endl;
    fout<<(int)Fuselage.Exists<<endl;
    fout<<Fuselage.Active<<endl;
    if( Fuselage.Exists )
    {
        //fout<<Fuselage.Type<<endl; //type
        fout<<FusTypeStr[Fuselage.Type]<<endl;
        if( Fuselage.Type == FT_FILE )  //fuselage from file
        {
            //fout<<filename_name( Fuselage.File.Name.c_str() )<<endl;
            fout<<Fuselage.File.Name<<endl;      
        }
        else //fuselage from parameters
        {
            //global
            fout<<Fuselage.Params.Name<<endl;
            fout<<Fuselage.Params.Nup<<" "<<Fuselage.Params.Ndown<<endl;
            fout<<Fuselage.Params.X0<<" "<<Fuselage.Params.Y0<<" "<<Fuselage.Params.Z0<<endl;
            fout<<Fuselage.Params.Scale<<" "<<Fuselage.Params.ScaleX<<" "<<Fuselage.Params.ScaleY<<" "<<Fuselage.Params.ScaleZup<<" "<<Fuselage.Params.ScaleZdown<<endl;
            fout<<Fuselage.Params.Length<<" "<<Fuselage.Params.BendLength<<" "<<Fuselage.Params.BendAngle<<endl;
            //spine
            fout<<FusCvrStr[CRV_SPINE]<<"\t\t\t"<<FusCvrTypeStr[Fuselage.Params.SpineCvr.Type]<<" ";
            if( Fuselage.Params.SpineCvr.Type == ELLIPSE )
            {
                fout<<Fuselage.Params.SpineCvr.Ellipse.NF<<" ";
                fout<<Fuselage.Params.SpineCvr.Ellipse.NR<<" ";
                fout<<Fuselage.Params.SpineCvr.Ellipse.CvFactF<<" ";
                fout<<Fuselage.Params.SpineCvr.Ellipse.CvFactR<<endl;
            }
            else
            {
                fout<<FusAirfoilSide[(int)Fuselage.Params.SpineCvr.Airfoil.Side]<<" ";
                WriteProfile( fout, Fuselage.Params.SpineCvr.Airfoil );
                //fout<<" "<<AirfoilTypeStr[Fuselage.Params.SpineCvr.Airfoil.iType];
                //if( Fuselage.Params.SpineCvr.Airfoil.iType == AIRFOIL_FILE )
                //    fout<<" "<<Fuselage.Params.SpineCvr.Airfoil.Name<<endl;
                //else
                //    fout<<" "<<GetNACANoAsString( Fuselage.Params.SpineCvr.Airfoil.NACAnumber)<<endl;
            }
 
            //Up contour
            fout<<FusCvrStr[CRV_UP_CONT]<<"\t\t\t"<<FusCvrTypeStr[Fuselage.Params.UpCvr.Type]<<" ";
            if( Fuselage.Params.UpCvr.Type == ELLIPSE )
            {
                fout<<Fuselage.Params.UpCvr.Ellipse.L<<" ";
                fout<<Fuselage.Params.UpCvr.Ellipse.H<<" ";
                fout<<Fuselage.Params.UpCvr.Ellipse.CvFactF<<" ";
                fout<<Fuselage.Params.UpCvr.Ellipse.CvFactR<<endl;
            }
            else
            {
                fout<<FusAirfoilSide[(int)Fuselage.Params.UpCvr.Airfoil.Side]<<" ";
                WriteProfile( fout, Fuselage.Params.UpCvr.Airfoil );
                //fout<<" "<<AirfoilTypeStr[Fuselage.Params.UpCvr.Airfoil.iType];
                //if( Fuselage.Params.UpCvr.Airfoil.iType == AIRFOIL_FILE )
                //    fout<<" "<<Fuselage.Params.UpCvr.Airfoil.Name<<endl;
                //else
                //    fout<<" "<<GetNACANoAsString( Fuselage.Params.UpCvr.Airfoil.NACAnumber)<<endl;
            }
 
            //Side contour
            fout<<FusCvrStr[CRV_SIDE_CONT]<<"\t\t"<<FusCvrTypeStr[Fuselage.Params.SideCvr.Type]<<" ";
            if( Fuselage.Params.SideCvr.Type == ELLIPSE )
            {
                fout<<Fuselage.Params.SideCvr.Ellipse.L<<" ";
                fout<<Fuselage.Params.SideCvr.Ellipse.H<<" ";
                fout<<Fuselage.Params.SideCvr.Ellipse.CvFactF<<" ";
                fout<<Fuselage.Params.SideCvr.Ellipse.CvFactR<<endl;
            }
            else
            {
                fout<<FusAirfoilSide[(int)Fuselage.Params.SideCvr.Airfoil.Side]<<" ";
                WriteProfile( fout, Fuselage.Params.SideCvr.Airfoil );
                //fout<<" "<<AirfoilTypeStr[Fuselage.Params.SideCvr.Airfoil.iType];
                //if( Fuselage.Params.SideCvr.Airfoil.iType == AIRFOIL_FILE )
                //    fout<<" "<<Fuselage.Params.SideCvr.Airfoil.Name<<endl;
                //else
                //    fout<<" "<<GetNACANoAsString( Fuselage.Params.SideCvr.Airfoil.NACAnumber)<<endl;
            }
            //down contour
            fout<<FusCvrStr[CRV_DOWN_CONT]<<"\t\t"<<FusCvrTypeStr[Fuselage.Params.DownCvr.Type]<<" ";
            if( Fuselage.Params.DownCvr.Type == ELLIPSE )
            {
                fout<<Fuselage.Params.DownCvr.Ellipse.L<<" ";
                fout<<Fuselage.Params.DownCvr.Ellipse.H<<" ";
                fout<<Fuselage.Params.DownCvr.Ellipse.CvFactF<<" ";
                fout<<Fuselage.Params.DownCvr.Ellipse.CvFactR<<endl;
            }
            else
            {
                fout<<FusAirfoilSide[(int)Fuselage.Params.DownCvr.Airfoil.Side]<<" ";
                WriteProfile( fout, Fuselage.Params.DownCvr.Airfoil );
                //fout<<" "<<AirfoilTypeStr[Fuselage.Params.DownCvr.Airfoil.iType];
                //if( Fuselage.Params.DownCvr.Airfoil.iType == AIRFOIL_FILE )
                //    fout<<" "<<Fuselage.Params.DownCvr.Airfoil.Name<<endl;
                //else
                //    fout<<" "<<GetNACANoAsString( Fuselage.Params.DownCvr.Airfoil.NACAnumber)<<endl;
            }
 
            //convexity factor up
            fout<<FusCvrStr[CRV_CV_FACT_UP]<<"\t\t"<<FusCvrTypeStr[Fuselage.Params.CvFactUp.Type]<<" ";
            if( Fuselage.Params.CvFactUp.Type == ELLIPSE )
            {
                fout<<Fuselage.Params.CvFactUp.Ellipse.L<<" ";
                fout<<Fuselage.Params.CvFactUp.Ellipse.H<<" ";
                fout<<Fuselage.Params.CvFactUp.Ellipse.CvFactF<<" ";
                fout<<Fuselage.Params.CvFactUp.Ellipse.CvFactR<<endl;
            }
            else if( Fuselage.Params.CvFactUp.Type == AIRFOIL  )
            {
                fout<<FusAirfoilSide[(int)Fuselage.Params.CvFactUp.Airfoil.Side]<<" ";
                WriteProfile( fout, Fuselage.Params.CvFactUp.Airfoil );
                //fout<<" "<<AirfoilTypeStr[Fuselage.Params.CvFactUp.Airfoil.iType];
                //if( Fuselage.Params.CvFactUp.Airfoil.iType == AIRFOIL_FILE )
                //    fout<<" "<<Fuselage.Params.CvFactUp.Airfoil.Name<<endl;
                //else
                //    fout<<" "<<GetNACANoAsString( Fuselage.Params.CvFactUp.Airfoil.NACAnumber)<<endl;
            }
            else
            {
                fout<<Fuselage.Params.CvFactUp.Factor<<endl;
            }
            //convexity factor down
            fout<<FusCvrStr[CRV_CV_FACT_DOWN]<<"\t"<<FusCvrTypeStr[Fuselage.Params.CvFactDown.Type]<<" ";
            if( Fuselage.Params.CvFactDown.Type == ELLIPSE )
            {
                fout<<Fuselage.Params.CvFactDown.Ellipse.L<<" ";
                fout<<Fuselage.Params.CvFactDown.Ellipse.H<<" ";
                fout<<Fuselage.Params.CvFactDown.Ellipse.CvFactF<<" ";
                fout<<Fuselage.Params.CvFactDown.Ellipse.CvFactR<<endl;
            }
            else if( Fuselage.Params.CvFactDown.Type == AIRFOIL  )
            {
                fout<<FusAirfoilSide[(int)Fuselage.Params.CvFactDown.Airfoil.Side]<<" ";
                WriteProfile( fout, Fuselage.Params.CvFactDown.Airfoil );
                //fout<<" "<<AirfoilTypeStr[Fuselage.Params.CvFactDown.Airfoil.iType];
                //if( Fuselage.Params.CvFactDown.Airfoil.iType == AIRFOIL_FILE )
                //    fout<<" "<<Fuselage.Params.CvFactDown.Airfoil.Name<<endl;
                //else
                //    fout<<" "<<GetNACANoAsString( Fuselage.Params.CvFactDown.Airfoil.NACAnumber)<<endl;
            }
            else
            {
                fout<<Fuselage.Params.CvFactDown.Factor<<endl;
            }
        }
 
        //Additional user division
        if( !Fuselage.UserDiv.empty() )
        {
            fout<<Fuselage.UserDiv.size()<<endl;
            for( int i=0;i<(int)Fuselage.UserDiv.size();i++) fout<<Fuselage.UserDiv[i]<<" ";
                fout<<endl;
        }
        else
            fout<<0<<endl;
 
        fout<<Fuselage.iDivSectionType<<"\t"<<Fuselage.iSecN<<endl;
 
    }
    fout<<"end_fuselage"<<endl;
 
    return true;
}
 
bool MS2_Data::WriteConns( ostream &fout, bool bCom )
{
    if( bCom )
        {
        fout<<endl<<"#######################"<<endl;
        fout<<"/*"<<endl;
        fout<<"CONNECTIONS section (\"begin_connections\")"<<endl;
        fout<<" number of connections - ICon"<<endl;
        fout<<" definitions of successive connections (ICon times)"<<endl;
        fout<<"     type ( Horizontal, Vertical)"<<endl;
        fout<<"     annotation"<<endl;
        fout<<"     is section active ( 1- active, 2 - not active)"<<endl;
        fout<<"     number of the 1st wing (vertical)"<<endl;
        fout<<"     number of the 2nd wing (horizontal)"<<endl;
        fout<<"     number of wing 1 rib connected to wing 2    (0-0, 1-last)"<<endl;
        fout<<"     number of wing 2 rib connected to wing 1"<<endl;
        fout<<"     number of wing 2 longeron connected to leading point of wing 1"<<endl;
        fout<<"     number of wing 2 longeron connected to trailing point of wing 1"<<endl;
        fout<<"     wing 2 surface for modification (0-bottom or exterior, 1-top or interior)"<<endl;
        fout<<"End (\"end\")"<<endl;
        fout<<"*/"<<endl;
        fout<<"#######################"<<endl<<endl;
        }
 
    fout<<endl<<"begin_connections"<<endl;
    fout<<Conns.size()<<endl;
    for( int i=0;i < (int)Conns.size();i++)
        {
        CONNECT_DATA conn;
        MS2_Conn2CONNECT(Conns[i],conn );
        conn.Write( fout );
        }
    fout<<"end"<<endl;
    return true;
}
 
bool MS2_Data::WriteWakes( ostream &fout, bool bCom )
{
    if( bCom )
        {
        fout<<endl<<"#######################"<<endl;
        fout<<"/*"<<endl;
        fout<<"WAKE INFO section (\"begin_wake_info\")"<<endl;
        fout<<" number of defined wakes - IWake"<<endl;
        fout<<" definitions of successive wakes (IWake times)"<<endl;
        fout<<"     type ( Horizontal, Vertical)"<<endl;
        fout<<"     annotation"<<endl;
        fout<<"     is section active ( 1- active, 2 - not active)"<<endl;
        fout<<"     number of the 1st wing (from)"<<endl;
        fout<<"     number of the 2nd wing (through)"<<endl;
        fout<<"     number of wing 1 rib connected to wake"<<endl;
        fout<<"     number of wing 2 rib connected to wake"<<endl;
        fout<<"     wing 2 surface for wake modification (0-bottom or exterior, 1-top or interior)"<<endl;
        fout<<"End (\"end\")"<<endl;
        fout<<"*/"<<endl;
        fout<<"#######################"<<endl<<endl;
        }
 
    fout<<endl<<"begin_wake_info"<<endl;
    fout<<Wakes.size()<<endl;
    for( int i=0;i < (int)Wakes.size();i++)
        {
        fout<<WakeTypeName(Wakes[i].Type)<<endl;
        fout<<Wakes[i].Name<<endl;
        fout<<Wakes[i].Active<<" ";
        fout<<Wakes[i].Wing1No<<" ";
        fout<<Wakes[i].Wing2No<<" ";
        fout<<Wakes[i].Wing1Rib<<" ";
        fout<<Wakes[i].Wing2Rib<<" ";
        fout<<Wakes[i].Wing2Surf<<" ";
        fout<<endl;
        }
    fout<<"end"<<endl;
    return true;
}
 
bool MS2_Data::WriteWing( ostream &fout , MS2_Wing  wing, int No )
{
    bool res = true;
    fout<<endl<<"begin_wing"<<No<<endl;
    fout<<wing.Active<<endl;
    fout<<WingTypeStr[wing.Type]<<endl;
    fout<<wing.ID<<" "<<wing.Name<<endl;
    fout<<WingDivSourceStr[wing.DivSource]<<endl;
    fout<<wing.ComputeInt<<endl;
    fout<<wing.LongeronNo<<endl;
    fout<<wing.SmartBypass<<endl;
    fout<<wing.BypassDepth<<endl;
    fout<<WingSurfSideStr[wing.SurfType]<<endl;
    fout<<WingRibTypeStr[wing.RibType]<<endl;
    fout<<wing.TwistRef<<endl;
    fout<<wing.UseMunk<<endl;
    if( wing.UseMunk == 1 )
        {
        fout<<wing.SRef<<" "<<wing.CzDes<<endl;
        }
 
 
    if( wing.Type == WING_TYPE_SECTIONS )
        {
        fout<<wing.Sec.Sections.size()<<endl;
        fout<<wing.Sec.DivType<<endl;
 
        for( int i=0;i < (int)wing.Sec.Sections.size(); i++ )
            res *= WriteSection( fout, wing.Sec.Sections[i] );
        }
    else if( wing.Type == WING_TYPE_MODULES)
        {
        fout<<wing.Mod.Modules.size()<<endl;
        for( int i=0; i<(int)wing.Mod.Modules.size();i++ )
            {
            res *= WriteWingModule( fout, wing.Mod.Modules[i] );
            }
        }
    else if( wing.Type == WING_TYPE_NACELLE )
        {
        MS2_NacelleWing nac = wing.Nac;
        //fout<<nac.Profil.Name.c_str()<<endl;
        WriteProfile( fout, nac.Profil );
        fout<<nac.X0<<" "<<nac.Y0<<" "<<nac.Z0<<endl;
        fout<<nac.fi<<" "<<nac.theta<<" "<<nac.psi<<endl;
        fout<<nac.L<<" "<<nac.CvFactUp<<" "<<nac.CvFactDown<<endl;
        fout<<nac.Y<<" "<<nac.ZUp<<" "<<nac.ZDown<<endl;
        fout<<nac.NUp<<" "<<nac.NDown<<endl;
        fout<<NacelleSwirlStr[nac.SwirlType]<<" "<<NacelleRangeStr[nac.SwirlRange]<<endl;
        }
 
    //chord division
    if( wing.DivType != DT_USER )
        {
        fout<<WingSectionDivStr[wing.DivType]<<" ";
        if( wing.DivType == DT_LINEAR || wing.DivType == DT_COSINE )
            fout<<wing.DivNo;
        fout<<endl;
        }
    else
        {
        for( int i=0;i<(int)wing.UserDiv.size();i++ ) fout<<wing.UserDiv[i]<<" ";
        fout<<endl;
        }
 
    fout<<"end_wing"<<endl;
 
    return res;
}
 
bool MS2_Data::WriteWingModule( ostream &fout, MS2_ModWingModule mod )
{
    fout<<WingModTypeStr[mod.Type]<<"\t";
    fout<<mod.C<<"\t"<<mod.Alfa<<"\t";
    if( mod.Type == WING_MOD_TYPE_ROOT )
    {
        fout<<mod.XRef<<"\t"<<mod.X0<<"\t"<<mod.Y0<<"\t"<<mod.Z0<<"\t";
    }
    else if( mod.Type == WING_MOD_TYPE_EQUI_LINE )
    {
        fout<<mod.Fi<<"\t"<<mod.Gamma<<"\t"<<mod.N<<"\t"<<mod.NDist<<"\t"<<mod.L<<"\t"<<mod.R<<"\t"<<mod.UseMunk<<"\t";
        fout<<WingModPanConcStr[(int)mod.SpanPanConc]<<"\t";
    }
    else if( mod.Type == WING_MOD_TYPE_LINE )
    {
        fout<<mod.Fi<<"\t"<<mod.Gamma<<"\t"<<mod.N<<"\t"<<mod.NDist<<"\t"<<mod.L<<"\t"<<mod.R<<"\t"<<mod.UseMunk<<"\t";
        fout<<WingModPanConcStr[(int)mod.SpanPanConc]<<"\t";
    }
    else if( mod.Type == WING_MOD_TYPE_ARC )
    {
        fout<<mod.Fi<<"\t"<<mod.Gamma<<"\t"<<mod.N<<"\t"<<mod.NDist<<"\t"<<mod.R<<"\t"<<mod.UseMunk<<"\t";
        fout<<WingModPanConcStr[(int)mod.SpanPanConc]<<"\t";
    }
    else
        return false;
 
    //fout<<mod.Profil.Name.c_str()<<endl;
    WriteProfile( fout, mod.Profil );
 
    return true;
}
bool MS2_Data::WriteSection( ostream &fout, MS2_Section sect )
{
    //fout<<sect.Profil.Name<<endl;  //airfoil
    WriteProfile( fout, sect.Profil );
    fout << sect.Chord << endl;
    fout << sect.X    << "\t" << sect.Y    << "\t" << sect.Z    << endl;
    fout << sect.RotX << "\t" << sect.RotY << "\t" << sect.RotZ << endl;
    fout << sect.CtrlFlag << "\t" << sect.CoefPosFlag << "\n" << sect.Deflection << "\t" << sect.Hinge_X << "\t" << sect.Hinge_Z << endl;
    fout << sect.No << endl;
    return true;
}
 
bool MS2_Data::WriteProfile( ostream &fout, MS2_Profile airfoil )
{
    fout << AirfoilTypeStr[airfoil.iType] << endl;
    if( airfoil.iType == AIRFOIL_FILE )
        fout << airfoil.Name << endl;
    if( airfoil.iType == AIRFOIL_NACA )
        fout << GetNACANoAsString( airfoil.NACAnumber) << endl;
    if( airfoil.iType == AIRFOIL_DATA )
        fout << airfoil.ShortName << endl;
    return true;
}
 
bool MS2_Data::WriteEmbededProfiles( ostream &fout, vector<MS2_Profile> *airfoil )
{
    int N = airfoil->size();
    for( int i=0; i<N; i++ )
        {
        fout << endl;
        fout << "begin_airfoil" << i << endl;
        fout << airfoil->at(i).ShortName << endl;
        int NN = airfoil->at(i).Xd.size();
        fout << NN << endl;
        for( int ii=0; ii<NN; ii++ )
            {
            fout << airfoil->at(i).Xd[ii] << " ";
            fout << airfoil->at(i).Zd[ii] << " ";
            fout << airfoil->at(i).Xg[ii] << " ";
            fout << airfoil->at(i).Zg[ii] << " ";
            fout << endl;
            }
        fout << "end_airfoil" << endl << endl;
        }
 
    return true;
}
 
 
// temporary solution - to be changed
 
int MS2_Data::GetIndpWingNo( void )
{
    int iRet = 0;
    for( int i=0;i < (int)Wings.size();i++ )
        {
        if( Wings[i].DivSource == WING_DIV_MASTER ) iRet++;
        if( Wings[i].DivSource == WING_DIV_INDEPENDENT ) iRet++;
        }
    return iRet;
}
int MS2_Data::GetDpWingNo( void )
{
    int iRet = 0;
    for( int i=0;i < (int)Wings.size();i++ )
        {
        if( Wings[i].DivSource == WING_DIV_SLAVE ) iRet++;
        }
    return iRet;
}