MS2_Data Class Reference

MS2 data structure manipulation. More...

#include <ms2data.h>

Inheritance diagram for MS2_Data:

Public Member Functions
bool	WriteGeneral (std::ostream &f)
	writes general data, incuding reference values
bool	WriteWing (std::ostream &fout, MS2_Wing wing, int no)
	writes wing's data
bool	WriteWingModule (std::ostream &fout, MS2_ModWingModule mod)
	writes modular wing's data
bool	WriteSection (std::ostream &fout, MS2_Section sect)
	writes data of wing built from sections
bool	WriteProfile (std::ostream &fout, MS2_Profile airfoil)
	writes airfoil data
bool	WriteFuselage (std::ostream &fout)
	writes fuselage data
bool	WriteConns (std::ostream &fout, bool bCom=true)
	writes connections data
bool	WriteWakes (std::ostream &fout, bool bCom=true)
	writes extra wake infos
bool	WriteEmbededProfiles (std::ostream &fout, std::vector< MS2_Profile > *airfoil)
	writes embeded airfoil geometry
virtual bool	ReadWing (FILE *t, MS2_Wing &wing, int iW, bool bRestrictive, bool auto_mod)
	reads wing data (see MS2_Wing)
bool	ReadWingModule (FILE *t, MS2_ModWingModule &mod, bool bRestrictive)
	reads Wing Module data (see MS2_ModWingModule)
bool	ReadSection (FILE *t, MS2_Section &sect)
	reads Wing Section data (see MS2_Section)
bool	ReadProfile (FILE *t, MS2_Profile &airfoil, const char *desc, bool bRestrictive)
	reads Profile data structure (see MS2_Profile)
bool	ReadProfile (FILE *t, MS2_Profile &airfoil)
	reads Profile data in case AIRFOIL_FILE type
bool	ReadFusFromParams (FILE *t, bool bRestrictive)
	reads Fuselage data in case fuselage defined using modules
bool	ReadFusEllipse (FILE *t, MS2_SuperEllipse &SupEll, const char *desc)
	reads fuselage elipse data
bool	ReadFusAirfoil (FILE *t, MS2_FusAirfoil &airfoil, const char *desc, bool bRestrictive)
	reads airfoil data used to define fuselage shape
bool	ReadChordDivision (FILE *t, MS2_Wing &wing, bool bRestrictive)
	reads user define chord division (see DT_USER)
virtual void	Comment (void)
	displays comment (warning or information)
void	Clear (void)
	clear local variables
void	SetDefaults (void)
	set default reference values
bool	Read (const char *file, bool bRestrictive, bool auto_mod)
	reads ms2 file
bool	Write (const char *file)
	writes ms2 file
int	GetVersion (void)
	returns ms2 file version
int	GetNWings (void)
	returns number of wings
int	GetNConns (void)
	returns number of connections
int	GetNWakes (void)
	returns number of wake infos
int	GetNProfs (void)
	returns number of embeded airfoils
std::string	WingSurfName (int n)
	returns wing surface type (name) - see MS2WingSurf
std::string	DivTypeName (int div)
	returns chordwise division type (name) - see MS2DivType

Static Public Member Functions
static void	ClearFusCurve (MS2_FusCurve &cvr, int elltype)
	cleans MS2_FusCurve object (fuselge module)
static void	SetFusCurveDefs (MS2_FusCurve &cvr, int elltype)
	sets MS2_Profile object (airfoil)
static void	ClearGeneral (MS2_General &gen)
	cleans MS2_General object (general data)
static void	SetPrfDefs (MS2_Profile &prf)
	sets MS2_Profile object (airfoil)
static void	SetWingDefs (MS2_Wing &wing)
	sets MS2_Wing object (wing definition)
static void	SetSectionDefs (MS2_Section &sect)
	sets MS2_Section object (wing section definition)
static void	SetModuleDefs (MS2_ModWingModule &mod)
	sets MS2_ModWingModule object (wing module definition)
static void	SetNacelleWingDefs (MS2_NacelleWing &nac)
	sets MS2_NacelleWing object (jet nacelle definition)
static void	SetFuselageDefs (MS2_Fuselage &fus)
	sets MS2_Fuselage object (fuselage definition)
static void	SetConnectionDefs (MS2_Conn &conn)
	sets MS2_Conn object (wings connection)
static void	SetWakeDefs (MS2_Wake &wake)
	sets MS2_Wake object (wake information)
static void	ClearPrf (MS2_Profile &prf)
	cleans MS2_Profile object (airfoil)
static void	ClearWing (MS2_Wing &wing)
	cleans MS2_Wing object (wing definition)
static void	ClearSection (MS2_Section &sect)
	cleans MS2_Section object (wing section definition)
static void	ClearModule (MS2_ModWingModule &mod)
	cleans MS2_ModWingModule object (wing module definition)
static void	ClearNacelleWing (MS2_NacelleWing &nac)
	cleans MS2_NacelleWing object (jet nacelle definition)
static void	ClearFuselage (MS2_Fuselage &fus)
	cleans MS2_Fuselage object (fuselage definition)
static void	ClearConnection (MS2_Conn &conn)
	cleans MS2_Conn object (wings connection)
static void	ClearWake (MS2_Wake &wake)
	cleans MS2_Wake object (wake information)
static void	CONNECT2MS2_Conn (CONNECT_DATA &Con, MS2_Conn &newConn)
	converts CONNECT_DATA to MS2_Conn
static void	MS2_Conn2CONNECT (MS2_Conn &Conn, CONNECT_DATA &newCon)
	converts MS2_Conn to CONNECT_DATA
static int	find_section (FILE *ff, const char *sec)
	to find the section in ms2 file - imported from "mesh2.h"
static bool	has_section (FILE *t, const char *sec)
	check if section exist
static std::string	ConnTypeName (int n)
	returns connection type name
static std::string	WakeTypeName (int n)
	returns wake info type name
static std::string	TruncateQuotMarks (std::string str)
	truncates the quote marks from string
static std::string	RemoveWhiteSpaces (std::string str)
	removes white chars from string
static std::string	GetNACANoAsString (int no)
	converts NACA profile number to string
Static Public Member Functions inherited from IOFUN
static void	Win2Unix (char *s)
	conversion of directory separators - MS Windows to Unix
static void	Unix2Win (char *s)
	conversion of directory separators - Unix to MS Windows
static int	ReadComm (FILE *stream)
	Function to read of a comment till the end of line. It returns 0 or EOF if it is performed.
static void	ReadDummy (FILE *stream)
	Function to read a comment line.
static int	ReadPar (FILE *stream, const char *Format, void *Par)
	Function to read one variable. The type of variable depends on Format, compatible with stdio library.
static int	ReadPar (FILE *stream, const char *Format, void *Par1, void *Par2)
	Function to read two variables. The type of variables depends on Format, compatible with stdio library.
static int	ReadPar (FILE *stream, const char *Format, void *Par1, void *Par2, void *Par3)
	Function to read three variables. The type of variables depends on Format, compatible with stdio library.
static int	ReadPar (FILE *stream, const char *Format, void *Par1, void *Par2, void *Par3, void *Par4)
	Function to read four variables. The type of variables depends on Format, compatible with stdio library.
static int	ReadVect3 (FILE *stream, double *Par, double dScal=1.)
	Function to read double vector "Par" of "3" dimension from FILE "stream". The read values are scaled by multiplier "dScal".
static int	ReadVect3 (FILE *stream, float *Par, float fScal=1.)
	Function to read float vector "Par" of "3" dimension from FILE "stream". The read values are scaled by multiplier "fScal".
static int	ReadVect3 (FILE *stream, long *Par, long lScal=1)
	Function to read long vector "Par" of "3" dimension from FILE "stream". The read values are scaled by multiplier "lScal".
static int	ReadVect3 (FILE *stream, int *Par, int iScal=1)
	Function to read int vector "Par" of "3" dimension from FILE "stream". The read values are scaled by multiplier "iScal".
static int	ReadVect (FILE *stream, double *Par, int n, double dScal=1.)
	Function to read double vector "Par" of "n" dimension from FILE "stream". The read values are scaled by multiplier "dScal".
static int	ReadVect (FILE *stream, float *Par, int n, float fScal=1.)
	Function to read float vector "Par" of "n" dimension from FILE "stream". The read values are scaled by multiplier "fScal".
static int	ReadVect (FILE *stream, long *Par, int n, long lScal=1)
	Function to read long vector "Par" of "n" dimension from FILE "stream". The read values are scaled by multiplier "lScal".
static int	ReadVect (FILE *stream, int *Par, int n, int iScal=1)
	Function to read int vector "Par" of "n" dimension from FILE "stream". The read values are scaled by multiplier "iScal".
static int	ReadStr (FILE *stream, char *Par)
	Function to read the new line from FILE "stream" and to store it in table of char "Par". The starting and ending blanc charaters are clipped.
static void	ReadStrL (FILE *stream, char *Par, int *len)
	Function to read the string (Par) from FILE "stream". It reads from current pointer of FILE to the end of line or EOF. Number of read characters is returned in "len".
static void	ClipString (char *string)
	Clipping of the "string" up to the first blanc character or comment "#" character.
static void	ClipFileName (char *string)
	Clipping of the ending blanc characters of "string".
static bool	CompareStrings (char *str1, char *str2)
	Compares two strings (str1 and str2). Returns true if they match, false otherwise.
static int	file_exist (const char *name)
	Returns true (1) if file "name" does exist, 0 otherwise.
static const char *	filename_name (const char *name)
	Returns pointer to filename without path.
static const char *	filename_ext (const char *buf)
	Returns pointer to filename extension.
static char *	filename_setext (char *buf, int buflen, const char *ext)
	set/change filename extension
static int	filename_dir (char *name)
	returns the length of the path in (path)name
static const char *	filename_date (const char *name)
	Returns pointer to the string that contains the date of last file modification/creation.
static FILE *	fopen (const char *filename, const char *mode)
	Cross-platform function to fopen function that supports UTF-8 encoded name.
static int	stat (const char *f, struct stat *b)
	Cross-platform function to stat() a file using a UTF-8 encoded name or value.
static size_t	strlcpy (char *d, const char *s, size_t bufsize)
	The implementation of nonstandard strlcpy function.
static int	nLines (FILE *stream)
	Returns number of lines of text file from current pointer to EOF.
static int	nColumns (FILE *stream, char Par[][32])
	Returns number of columns of text file (number of strings in the first line). Names of columns are stored in Par array.
static int	isstrblank (char *cc, int iLen)
	Checks if string (cc) is blank (1/0)
static void	ReadVect3 (FILE *stream, VECTOR_3D *Vec, double dScal=1.)
	Function to read VECTOR_3D Vec components from FILE "stream". The read values are scaled by multiplier "dScal".
static int	readln (FILE *ff, char *value_x)
	Pascal style "readln" function to read string.
static int	readln (FILE *ff, int *value_x)
	Pascal style "readln" function to read int.
static int	readln (FILE *ff, long *value_x)
	Pascal style "readln" function to read long.
static int	readln (FILE *ff, float *value_x)
	Pascal style "readln" function to read float.
static int	readln (FILE *ff, double *value_x)
	Pascal style "readln" function to read double.
static int	readln (FILE *ff, long double *value_x)
	Pascal style "readln" function to read long double.
static int	readln (FILE *ff)
	Pascal style "readln" function to read comment.
static int	readln (FILE *ff, VECTOR_3D *vec)
	Pascal style "readln" function to read VECTOR_3D components.
static int	read (FILE *ff, char *value_x)
	Pascal style "read" function to read string.
static int	read (FILE *ff, int *value_x)
	Pascal style "read" function to read int.
static int	read (FILE *ff, long *value_x)
	Pascal style "read" function to read long.
static int	read (FILE *ff, float *value_x)
	Pascal style "read" function to read float.
static int	read (FILE *ff, double *value_x)
	Pascal style "read" function to read double.
static int	read (FILE *ff, long double *value_x)
	Pascal style "read" function to read long double.
static int	read (FILE *ff, VECTOR_3D *vec)
	Pascal style "read" function to read VECTOR_3D components.

Protected Member Functions
std::string	RemoveExt (std::string filename)
	removes the filename extention
int	GetIndpWingNo (void)
	returns number of indepedentend wings (MASTER & INDEPENDENT)
int	GetDpWingNo (void)
	returns number of depedentend wings (SLAVE)

Protected Attributes
int	iVersion
	version of read file
char	cComment [256]
	message text in case of error

Static Protected Attributes
static const int	CURRENT_VERSION = 55
	current version of ms2data module
static std::map< int, const char * >	AirfoilTypeStr = CreateAirfoilTypeStr()
	file, NACA, table
static std::map< int, const char * >	FusTypeStr = CreateFusTypeStr()
	file, parameters
static std::map< int, const char * >	FusCvrStr = CreateFusCvrStr()
	spine, up cvr etc.
static std::map< int, const char * >	FusCvrTypeStr = CreateFusCvrTypeStr()
	ellipse, airfoil etc.
static std::map< int, const char * >	FusAirfoilSide = CreateFusAirfoilSide()
	up , down
static std::map< int, const char * >	WingTypeStr = CreateWingTypeStr()
	sections, modules, nacelle
static std::map< int, const char * >	WingModTypeStr = CreateWingModTypeStr()
	root, equi line, arc, line
static std::map< int, const char * >	WingModPanConcStr = CreateWingModConcStr()
	paneling distribution in module wings modules ( left, right center )
static std::map< int, const char * >	WingDivSourceStr = CreateWingDivSourceStr()
	master, slave
static std::map< int, const char * >	WingSurfSideStr = CreateWingSurfSideStr()
	all, top, bottom
static std::map< int, const char * >	WingRibTypeStr = CreateWingRibTypeStr()
	open, external, both
static std::map< int, const char * >	WingSectionDivStr = CreateWingSectionDivStr()
	linear, cosine etc.
static std::map< int, const char * >	NacelleSwirlStr = CreateNacelleSwirlStr()
	swirl up, swirl down
static std::map< int, const char * >	NacelleRangeStr = CreateNacelleRangeStr()
	swirl range: full, half

Additional Inherited Members
Public Attributes inherited from MS2_Data_Struct
MS2_General	General
	general geometric data
MS2_Fuselage	Fuselage
	fuselage data
std::vector< MS2_Wing >	Wings
	wings data
std::vector< MS2_Conn >	Conns
	connections data
std::vector< MS2_Wake >	Wakes
	special info for wake calculation
std::vector< MS2_Profile >	Profiles
	embedded profiles

Detailed Description

MS2 data structure manipulation.

Definition at line 36 of file ms2data.h.

Constructor & Destructor Documentation

MS2_Data()

MS2_Data::MS2_Data

(

void

)

Definition at line 173 of file ms2data.cpp.

{
   Clear();
}

~MS2_Data()

MS2_Data::~MS2_Data ( void )

virtual

Definition at line 178 of file ms2data.cpp.

{
 
}

Member Function Documentation

Clear()

void MS2_Data::Clear

(

void

)

clear local variables

Definition at line 183 of file ms2data.cpp.

{
    //Version
    iVersion = 0;
    ClearGeneral( General );
    ClearFuselage( Fuselage );
    Wings.clear();
    Conns.clear();
    Wakes.clear();
}

ClearConnection()

void MS2_Data::ClearConnection ( MS2_Conn & conn )

static

cleans MS2_Conn object (wings connection)

Definition at line 465 of file ms2data.cpp.

{
    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;
}

Referenced by Read().

ClearFusCurve()

void MS2_Data::ClearFusCurve ( MS2_FusCurve & cvr, int elltype )

static

cleans MS2_FusCurve object (fuselge module)

Definition at line 279 of file ms2data.cpp.

{
    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;
}

Referenced by ClearFuselage().

ClearFuselage()

void MS2_Data::ClearFuselage ( MS2_Fuselage & fus )

static

cleans MS2_Fuselage object (fuselage definition)

Definition at line 231 of file ms2data.cpp.

{
    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 );
}

Referenced by Clear(), and Read().

ClearGeneral()

void MS2_Data::ClearGeneral ( MS2_General & gen )

static

cleans MS2_General object (general data)

Definition at line 220 of file ms2data.cpp.

{
    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;
}

Referenced by Clear(), and Read().

ClearModule()

void MS2_Data::ClearModule ( MS2_ModWingModule & mod )

static

cleans MS2_ModWingModule object (wing module definition)

Definition at line 430 of file ms2data.cpp.

{
    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;
}

Referenced by ReadWing().

ClearNacelleWing()

void MS2_Data::ClearNacelleWing ( MS2_NacelleWing & nac )

static

cleans MS2_NacelleWing object (jet nacelle definition)

Definition at line 517 of file ms2data.cpp.

{
    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;
}

Referenced by ClearWing(), and ReadWing().

ClearPrf()

void MS2_Data::ClearPrf ( MS2_Profile & prf )

static

cleans MS2_Profile object (airfoil)

Definition at line 406 of file ms2data.cpp.

{
    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;
}

Referenced by ReadProfile(), and ReadProfile().

ClearSection()

void MS2_Data::ClearSection ( MS2_Section & sect )

static

cleans MS2_Section object (wing section definition)

Definition at line 370 of file ms2data.cpp.

{
    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;
}

Referenced by ReadWing().

ClearWake()

void MS2_Data::ClearWake ( MS2_Wake & wake )

static

cleans MS2_Wake object (wake information)

Definition at line 493 of file ms2data.cpp.

{
    wake.Name .clear();
    wake.Type = 0;
    wake.Active = 0;
    wake.Wing1No = 0;
    wake.Wing2No = 0;
    wake.Wing1Rib = 0;
    wake.Wing2Rib = 0;
    wake.Wing2Surf = 0;
}

Referenced by Read().

ClearWing()

void MS2_Data::ClearWing ( MS2_Wing & wing )

static

cleans MS2_Wing object (wing definition)

Definition at line 310 of file ms2data.cpp.

{
    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 );
}

Referenced by Read(), and SetWingDefs().

Comment()

void MS2_Data::Comment ( void )

virtual

displays comment (warning or information)

Definition at line 674 of file ms2data.cpp.

{   
    fprintf( stderr, "%s\n", cComment );
}

Referenced by Read(), ReadChordDivision(), ReadFusAirfoil(), ReadFusFromParams(), ReadProfile(), ReadWing(), ReadWingModule(), and Write().

CONNECT2MS2_Conn()

void MS2_Data::CONNECT2MS2_Conn ( CONNECT_DATA & Con, MS2_Conn & newConn )

static

converts CONNECT_DATA to MS2_Conn

Definition at line 2258 of file ms2data.cpp.

{
    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() );
}

Referenced by Read().

ConnTypeName()

string MS2_Data::ConnTypeName ( int n )

static

returns connection type name

Definition at line 595 of file ms2data.cpp.

{
    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;
}

DivTypeName()

string MS2_Data::DivTypeName

(

int

div

)

returns chordwise division type (name) - see MS2DivType

Definition at line 569 of file ms2data.cpp.

{
    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;
}

find_section()

int MS2_Data::find_section ( FILE * ff, const char * sec )

static

to find the section in ms2 file - imported from "mesh2.h"

Definition at line 2287 of file ms2data.cpp.

{
//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;
}

Referenced by Read().

GetDpWingNo()

int MS2_Data::GetDpWingNo ( void )

protected

returns number of depedentend wings (SLAVE)

Definition at line 2923 of file ms2data.cpp.

{
    int iRet = 0;
    for( int i=0;i < (int)Wings.size();i++ )
        {
        if( Wings[i].DivSource == WING_DIV_SLAVE ) iRet++;
        }
    return iRet;
}

Referenced by WriteGeneral().

GetIndpWingNo()

int MS2_Data::GetIndpWingNo ( void )

protected

returns number of indepedentend wings (MASTER & INDEPENDENT)

Definition at line 2913 of file ms2data.cpp.

{
    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;
}

Referenced by WriteGeneral().

GetNACANoAsString()

string MS2_Data::GetNACANoAsString ( int no )

static

converts NACA profile number to string

Definition at line 664 of file ms2data.cpp.

{
    char tmp[11];
    if( no > 9999 )
        sprintf(tmp,"%05u",no);
    else
        sprintf(tmp,"%04u",no);
    return string( tmp );
}

Referenced by ReadProfile(), and WriteProfile().

GetNConns()

int MS2_Data::GetNConns ( void )

inline

returns number of connections

Definition at line 104 of file ms2data.h.

GetNProfs()

int MS2_Data::GetNProfs ( void )

inline

returns number of embeded airfoils

Definition at line 106 of file ms2data.h.

GetNWakes()

int MS2_Data::GetNWakes ( void )

inline

returns number of wake infos

Definition at line 105 of file ms2data.h.

GetNWings()

int MS2_Data::GetNWings ( void )

inline

returns number of wings

Definition at line 103 of file ms2data.h.

GetVersion()

int MS2_Data::GetVersion ( void )

inline

returns ms2 file version

Definition at line 102 of file ms2data.h.

has_section()

bool MS2_Data::has_section ( FILE * t, const char * sec )

static

check if section exist

Definition at line 2308 of file ms2data.cpp.

{
    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;
}

Referenced by Read().

MS2_Conn2CONNECT()

void MS2_Data::MS2_Conn2CONNECT ( MS2_Conn & Conn, CONNECT_DATA & newCon )

static

converts MS2_Conn to CONNECT_DATA

Definition at line 2273 of file ms2data.cpp.

{
    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;
}

Referenced by WriteConns().

Read()

bool MS2_Data::Read	(	const char *	file,
		bool	bRestrictive,
		bool	auto_mod )

reads ms2 file

Definition at line 681 of file ms2data.cpp.

{
    // 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;
}

ReadChordDivision()

bool MS2_Data::ReadChordDivision	(	FILE *	t,
		MS2_Wing &	wing,
		bool	bRestrictive )

reads user define chord division (see DT_USER)

Definition at line 1824 of file ms2data.cpp.

{
    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;
}

Referenced by ReadWing().

ReadFusAirfoil()

bool MS2_Data::ReadFusAirfoil	(	FILE *	t,
		MS2_FusAirfoil &	airfoil,
		const char *	desc,
		bool	bRestrictive )

reads airfoil data used to define fuselage shape

Definition at line 1347 of file ms2data.cpp.

{
    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;
}

Referenced by ReadFusFromParams().

ReadFusEllipse()

bool MS2_Data::ReadFusEllipse	(	FILE *	t,
		MS2_SuperEllipse &	SupEll,
		const char *	desc )

reads fuselage elipse data

Definition at line 1322 of file ms2data.cpp.

{
    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;
}

Referenced by ReadFusFromParams().

ReadFusFromParams()

bool MS2_Data::ReadFusFromParams	(	FILE *	t,
		bool	bRestrictive )

reads Fuselage data in case fuselage defined using modules

Definition at line 994 of file ms2data.cpp.

{
    //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;
}

Referenced by Read().

ReadProfile() [1/2]

bool MS2_Data::ReadProfile	(	FILE *	t,
		MS2_Profile &	airfoil )

reads Profile data in case AIRFOIL_FILE type

Definition at line 2233 of file ms2data.cpp.

{
    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;
}

ReadProfile() [2/2]

bool MS2_Data::ReadProfile	(	FILE *	t,
		MS2_Profile &	airfoil,
		const char *	desc,
		bool	bRestrictive )

reads Profile data structure (see MS2_Profile)

Definition at line 2107 of file ms2data.cpp.

{
    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;
}

Referenced by Read(), ReadFusAirfoil(), ReadSection(), ReadWing(), and ReadWingModule().

ReadSection()

bool MS2_Data::ReadSection	(	FILE *	t,
		MS2_Section &	sect )

reads Wing Section data (see MS2_Section)

Definition at line 2079 of file ms2data.cpp.

{
    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;
}

Referenced by ReadWing().

ReadWing()

bool MS2_Data::ReadWing ( FILE * t, MS2_Wing & wing, int iW, bool bRestrictive, bool auto_mod )

virtual

reads wing data (see MS2_Wing)

Definition at line 1452 of file ms2data.cpp.

{
    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 );
}

Referenced by Read().

ReadWingModule()

bool MS2_Data::ReadWingModule	(	FILE *	t,
		MS2_ModWingModule &	mod,
		bool	bRestrictive )

reads Wing Module data (see MS2_ModWingModule)

Definition at line 1956 of file ms2data.cpp.

{
    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;
}

Referenced by ReadWing().

RemoveExt()

std::string MS2_Data::RemoveExt ( std::string filename )

protected

removes the filename extention

Definition at line 2396 of file ms2data.cpp.

{
    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;
}

RemoveWhiteSpaces()

string MS2_Data::RemoveWhiteSpaces ( std::string str )

static

removes white chars from string

Definition at line 649 of file ms2data.cpp.

{
    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;
}

Referenced by TruncateQuotMarks().

SetConnectionDefs()

void MS2_Data::SetConnectionDefs ( MS2_Conn & conn )

static

sets MS2_Conn object (wings connection)

Definition at line 479 of file ms2data.cpp.

{
    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;
}

SetDefaults()

void MS2_Data::SetDefaults

(

void

)

set default reference values

Definition at line 194 of file ms2data.cpp.

{
    //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();
}

SetFusCurveDefs()

void MS2_Data::SetFusCurveDefs ( MS2_FusCurve & cvr, int elltype )

static

sets MS2_Profile object (airfoil)

Definition at line 294 of file ms2data.cpp.

{
    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;
}

Referenced by SetFuselageDefs().

SetFuselageDefs()

void MS2_Data::SetFuselageDefs ( MS2_Fuselage & fus )

static

sets MS2_Fuselage object (fuselage definition)

Definition at line 254 of file ms2data.cpp.

{
    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 );
}

Referenced by Read(), and SetDefaults().

SetModuleDefs()

void MS2_Data::SetModuleDefs ( MS2_ModWingModule & mod )

static

sets MS2_ModWingModule object (wing module definition)

Definition at line 447 of file ms2data.cpp.

{
    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;
}

SetNacelleWingDefs()

void MS2_Data::SetNacelleWingDefs ( MS2_NacelleWing & nac )

static

sets MS2_NacelleWing object (jet nacelle definition)

Definition at line 531 of file ms2data.cpp.

{
    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;
}

Referenced by SetWingDefs().

SetPrfDefs()

void MS2_Data::SetPrfDefs ( MS2_Profile & prf )

static

sets MS2_Profile object (airfoil)

Definition at line 418 of file ms2data.cpp.

{
    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;
}

SetSectionDefs()

void MS2_Data::SetSectionDefs ( MS2_Section & sect )

static

sets MS2_Section object (wing section definition)

Definition at line 388 of file ms2data.cpp.

{
    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;
}

SetWakeDefs()

void MS2_Data::SetWakeDefs ( MS2_Wake & wake )

static

sets MS2_Wake object (wake information)

Definition at line 505 of file ms2data.cpp.

{
    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;
}

SetWingDefs()

void MS2_Data::SetWingDefs ( MS2_Wing & wing )

static

sets MS2_Wing object (wing definition)

Definition at line 339 of file ms2data.cpp.

{
    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 );
}

TruncateQuotMarks()

string MS2_Data::TruncateQuotMarks ( std::string str )

static

truncates the quote marks from string

Definition at line 634 of file ms2data.cpp.

{
    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;
}

Referenced by Read(), ReadFusAirfoil(), ReadFusFromParams(), ReadProfile(), ReadSection(), ReadWing(), and ReadWingModule().

WakeTypeName()

string MS2_Data::WakeTypeName ( int n )

static

returns wake info type name

Definition at line 616 of file ms2data.cpp.

{
    string retStr = "";
    switch( n )
    {
        case WAKE_H :
            retStr = "Horizontal";
            break;
        case WAKE_V :
            retStr = "Vertical";
            break;
        default :
            retStr = "Horizontal";
            break;
    }
    return retStr;
}

Referenced by Read(), and WriteWakes().

WingSurfName()

string MS2_Data::WingSurfName

(

int

n

)

returns wing surface type (name) - see MS2WingSurf

Definition at line 546 of file ms2data.cpp.

{
    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;
}

Write()

bool MS2_Data::Write

(

const char *

file

)

writes ms2 file

Definition at line 2327 of file ms2data.cpp.

{
    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;
}

WriteConns()

bool MS2_Data::WriteConns	(	std::ostream &	fout,
		bool	bCom = true )

writes connections data

Definition at line 2685 of file ms2data.cpp.

{
    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;
}

Referenced by Write().

WriteEmbededProfiles()

bool MS2_Data::WriteEmbededProfiles	(	std::ostream &	fout,
		std::vector< MS2_Profile > *	airfoil )

writes embeded airfoil geometry

Definition at line 2886 of file ms2data.cpp.

{
    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;
}

Referenced by Write().

WriteFuselage()

bool MS2_Data::WriteFuselage

(

std::ostream &

fout

)

writes fuselage data

Definition at line 2503 of file ms2data.cpp.

{
    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;
}

Referenced by Write().

WriteGeneral()

bool MS2_Data::WriteGeneral

(

std::ostream &

f

)

writes general data, incuding reference values

Definition at line 2407 of file ms2data.cpp.

{
    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;
}

Referenced by Write().

WriteProfile()

bool MS2_Data::WriteProfile	(	std::ostream &	fout,
		MS2_Profile	airfoil )

writes airfoil data

Definition at line 2874 of file ms2data.cpp.

{
    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;
}

Referenced by WriteFuselage(), WriteSection(), WriteWing(), and WriteWingModule().

WriteSection()

bool MS2_Data::WriteSection	(	std::ostream &	fout,
		MS2_Section	sect )

writes data of wing built from sections

Definition at line 2862 of file ms2data.cpp.

{
    //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;
}

Referenced by WriteWing().

WriteWakes()

bool MS2_Data::WriteWakes	(	std::ostream &	fout,
		bool	bCom = true )

writes extra wake infos

Definition at line 2721 of file ms2data.cpp.

{
    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;
}

Referenced by Write().

WriteWing()

bool MS2_Data::WriteWing	(	std::ostream &	fout,
		MS2_Wing	wing,
		int	no )

writes wing's data

Definition at line 2761 of file ms2data.cpp.

{
    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;
}

Referenced by Write().

WriteWingModule()

bool MS2_Data::WriteWingModule	(	std::ostream &	fout,
		MS2_ModWingModule	mod )

writes modular wing's data

Definition at line 2831 of file ms2data.cpp.

{
    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;
}

Referenced by WriteWing().

Member Data Documentation

AirfoilTypeStr

map< int, const char * > MS2_Data::AirfoilTypeStr = CreateAirfoilTypeStr()

staticprotected

file, NACA, table

Definition at line 44 of file ms2data.h.

Referenced by ReadFusAirfoil(), ReadProfile(), and WriteProfile().

cComment

char MS2_Data::cComment[256]

protected

message text in case of error

Definition at line 41 of file ms2data.h.

Referenced by Comment(), Read(), ReadChordDivision(), ReadFusAirfoil(), ReadFusFromParams(), ReadProfile(), ReadWing(), ReadWingModule(), and Write().

CURRENT_VERSION

const int MS2_Data::CURRENT_VERSION = 55

staticprotected

current version of ms2data module

Definition at line 39 of file ms2data.h.

Referenced by Read(), SetDefaults(), and WriteGeneral().

FusAirfoilSide

map< int, const char * > MS2_Data::FusAirfoilSide = CreateFusAirfoilSide()

staticprotected

up , down

Definition at line 49 of file ms2data.h.

Referenced by ReadFusAirfoil(), and WriteFuselage().

FusCvrStr

map< int, const char * > MS2_Data::FusCvrStr = CreateFusCvrStr()

staticprotected

spine, up cvr etc.

Definition at line 47 of file ms2data.h.

Referenced by ReadFusFromParams(), and WriteFuselage().

FusCvrTypeStr

map< int, const char * > MS2_Data::FusCvrTypeStr = CreateFusCvrTypeStr()

staticprotected

ellipse, airfoil etc.

Definition at line 48 of file ms2data.h.

Referenced by ReadFusFromParams(), and WriteFuselage().

FusTypeStr

map< int, const char * > MS2_Data::FusTypeStr = CreateFusTypeStr()

staticprotected

file, parameters

Definition at line 46 of file ms2data.h.

Referenced by Read(), and WriteFuselage().

iVersion

int MS2_Data::iVersion

protected

version of read file

Definition at line 40 of file ms2data.h.

Referenced by Clear(), GetVersion(), Read(), ReadChordDivision(), ReadFusAirfoil(), ReadSection(), ReadWing(), ReadWingModule(), SetDefaults(), and WriteGeneral().

NacelleRangeStr

map< int, const char * > MS2_Data::NacelleRangeStr = CreateNacelleRangeStr()

staticprotected

swirl range: full, half

Definition at line 59 of file ms2data.h.

Referenced by ReadWing(), and WriteWing().

NacelleSwirlStr

map< int, const char * > MS2_Data::NacelleSwirlStr = CreateNacelleSwirlStr()

staticprotected

swirl up, swirl down

Definition at line 58 of file ms2data.h.

Referenced by ReadWing(), and WriteWing().

WingDivSourceStr

map< int, const char * > MS2_Data::WingDivSourceStr = CreateWingDivSourceStr()

staticprotected

master, slave

Definition at line 54 of file ms2data.h.

Referenced by ReadChordDivision(), ReadWing(), Write(), and WriteWing().

WingModPanConcStr

map< int, const char * > MS2_Data::WingModPanConcStr = CreateWingModConcStr()

staticprotected

paneling distribution in module wings modules ( left, right center )

Definition at line 53 of file ms2data.h.

Referenced by ReadWingModule(), and WriteWingModule().

WingModTypeStr

map< int, const char * > MS2_Data::WingModTypeStr = CreateWingModTypeStr()

staticprotected

root, equi line, arc, line

Definition at line 52 of file ms2data.h.

Referenced by ReadWingModule(), and WriteWingModule().

WingRibTypeStr

map< int, const char * > MS2_Data::WingRibTypeStr = CreateWingRibTypeStr()

staticprotected

open, external, both

Definition at line 56 of file ms2data.h.

Referenced by ReadWing(), Write(), and WriteWing().

WingSectionDivStr

map< int, const char * > MS2_Data::WingSectionDivStr = CreateWingSectionDivStr()

staticprotected

linear, cosine etc.

Definition at line 57 of file ms2data.h.

Referenced by DivTypeName(), ReadChordDivision(), and WriteWing().

WingSurfSideStr

map< int, const char * > MS2_Data::WingSurfSideStr = CreateWingSurfSideStr()

staticprotected

all, top, bottom

Definition at line 55 of file ms2data.h.

Referenced by ReadWing(), WingSurfName(), Write(), and WriteWing().

WingTypeStr

map< int, const char * > MS2_Data::WingTypeStr = CreateWingTypeStr()

staticprotected

sections, modules, nacelle

Definition at line 51 of file ms2data.h.

Referenced by ReadWing(), Write(), and WriteWing().

---

The documentation for this class was generated from the following files:

• ms2data.h
• ms2data.cpp