The source code listed in the following sections is for reference only and is superseded by the files included with the installation.
This source code is protected by a license agreement.
Source code is listed for the following header files:
// bgUserIO.h #include "BgModel.h" //================================================================================================= // UserIO Interface Routines enum FileType { NoFile, // no interface available SingleFile, // pszUserPath will include the filename and extension. FixedFiles, // pszUserPath will specify the directory only. MultiFile, // pszUserPath will include the filename and extension, // but more than one file will be saved. }; // User must create these data items extern const int g_iOrder; // Controls location in menu. Group by 10, 20, ... Index by 1, 2, ... extern const FileType g_eImport; extern const FileType g_eExport; extern const char g_szFileDesc[64]; // ex: "My File" extern const char g_szFileType[16]; // ex: "myf", no period extern const int g_nErrorMsg; extern const char ** g_ppszErrorMsg; // User must define these functions. Return -1 if not implemented. // int UserImport( const char *pszUserPath, BgModel &Model ); // int UserExport( const char *pszUserPath, const char *pszBladeGenFileName, BgModel &Model );
Declared Classes:
Source
// BgArr.h - JMC - 1/7/96 #ifndef BgArr_h #define BgArr_h #include "xMsg.h" #include <string.h> #include <stdlib.h> #include <iostream.h> #define MAXINT 32767 /**# :[Description = "This template class acts as a resizeable array. All objects in the array are stored as pointers to objects. It is a simplified version of the basic BladeGen array."] */ template<class T> class BgArr { public: typedef T* PT; protected: bool m_bOwnsObjs; int m_nObj; int m_nGrowBy; int m_nObjMax; PT *m_ppObj; private: bool m_bDirty; public: /**# :[Description = "Basic Constructor."] */ BgArr( int nMax=16, bool bOwns=true ) { m_bOwnsObjs = bOwns; m_nObj = 0; m_nGrowBy = nMax; m_nObjMax = nMax; m_ppObj = NULL; Flush(); SetDirty( true ); } /**# :[Description = "Constructor from another BgArr<T> object. WARNING: Does not copy data, only settings."] */ BgArr( const BgArr& O ) { m_bOwnsObjs = O.m_bOwnsObjs; m_nObj = 0; m_nGrowBy = O.m_nGrowBy; m_nObjMax = O.m_nObjMax; m_ppObj = NULL; Flush(); SetDirty( true ); } /**# :[Description = "Assignment operator from another BgArr<T> object. WARNING: Does not copy data, only settings."] */ BgArr &operator=( const BgArr& O ) { Flush(); m_bOwnsObjs = O.m_bOwnsObjs; m_nGrowBy = O.m_nGrowBy; m_nObjMax = O.m_nObjMax; SetDirty( true ); return *this; } /**# :[Description = "Virtual Destructor."] */ virtual ~BgArr(); /**# :[Description = "Function prepends the specified values to this array."] */ virtual BgArr &Prepend( BgArr &A ); /**# :[Description = "Function appends the specified values to this array."] */ virtual BgArr &Append( BgArr &A ); /**# :[Description = "Operator returns a reference to the value at the specified index."] */ T* operator[]( int n ) { if ( n<m_nObj ) return m_ppObj[n]; return NULL; } /**# :[Description = "Operator returns a constant reference to the value at the specified index."] */ const T* operator[]( int n ) const { if ( n<m_nObj ) return m_ppObj[n]; return NULL; } /**# :[Description = "Function returns a reference to the first value of the array."] */ T* First() const { if ( !m_nObj ) return NULL; return m_ppObj[0]; } /**# :[Description = "Function returns a reference to the last value of the array."] */ T* Last() const { if ( !m_nObj ) return NULL; return m_ppObj[m_nObj-1]; } /**# :[Description = "Function returns the status of the dirty value. This value is set whenever the array is modified (added or removing objects)."] */ bool Dirty() const { return m_bDirty; } /**# :[Description = "Function sets the status of the dirty value. This value is set whenever the array is modified (added or removing objects)."] */ virtual void SetDirty( bool bVal = true ) { m_bDirty = bVal; } /**# :[Description = "Function returns the status of the owns object value. This value is indicates if the objects are destroyed when the array is destroyed."] */ bool OwnsObjs() const { return m_bOwnsObjs; } /**# :[Description = "Function sets the status of the owns object value. This value is indicates if the objects are destroyed when the array is destroyed."] */ void SetOwnsObjs( bool bOwns ) { m_bOwnsObjs = bOwns; } /**# :[Description = "Function returns the number of objects contained in the array."] */ int Count() const { return m_nObj; } /**# :[Description = "Function returns the number of objects that the array will grow by when objects are added."] */ int GrowBy() const { return m_nGrowBy; } /**# :[Description = "Function returns a reference to the value at the specified index."] */ T* ItemAt( int n ) { if ( n<m_nObj ) return m_ppObj[n]; return NULL; } /**# :[Description = "Function returns a reference to the value at the specified index."] */ T* ItemAt( int n ) const { if ( n<m_nObj ) return m_ppObj[n]; return NULL; } /**# :[Description = "Function returns true of the array contains the object (by memory address)."] */ virtual bool Has( const T *pObj ) const { return ( Find( pObj )!=MAXINT ); } /**# :[Description = "Function returns index to the specified object (by memory address). Returns MAXINT if object was not found."] */ virtual int Find( const T *pObj ) const; /**# :[Description = "Function adds the object to the array."] */ virtual bool Add( T *pObj ); /**# :[Description = "Function adds the object to the array at the position specified."] */ virtual bool AddAt( int n, T *pObj ); /**# :[Description = "Function removed the object at the specified index from the array."] */ virtual bool Detach( int n ); /**# :[Description = "Function removed the object from the array."] */ virtual bool Detach( T *pObj ) { return Detach( Find( pObj ) ); } /**# :[Description = "Function removed the object at the specified index from the array and destroys it."] */ virtual bool Destroy( int n ) { if ( n>=m_nObj ) return false; T *pObj = m_ppObj[n]; Detach( n ); delete pObj; SetDirty( true ); return true; } /**# :[Description = "Function removed the object from the array and destroys it."] */ virtual bool Destroy( T *pObj ) { return Destroy( Find( pObj ) ); } /**# :[Description = "Function removes all object from the array. If the bOwnsObjs flag is set, the objects are destroyed as well."] */ void Flush(); /**# :[Description = "Function reverses the order of the objects in the array."] */ void ReverseOrder(); }; /**# implementation BgArr:: id(C_1022270469) */ template<class T> BgArr<T>::~BgArr() { if ( m_bOwnsObjs ) { while ( m_nObj ) { delete m_ppObj[ --m_nObj ]; } } delete [] m_ppObj; } template<class T> BgArr<T> &BgArr<T>::Prepend( BgArr &A ) { m_nObjMax = ((m_nObj+A.m_nObj)/m_nGrowBy+1)*m_nGrowBy; PT *ppNew = new PT[m_nObjMax]; int i, j; for ( i=0; i<A.m_nObj; i++ ) { ppNew[i] = A.m_ppObj[i]; } for ( i=A.m_nObj, j=0; j<m_nObj; i++, j++ ) { ppNew[i] = m_ppObj[j]; } delete [] m_ppObj; m_ppObj = ppNew; m_nObj += A.m_nObj; delete [] A.m_ppObj; A.m_ppObj = new PT[A.m_nGrowBy]; A.m_nObj = 0; A.m_nObjMax = A.m_nGrowBy; SetDirty( true ); return *this; } template<class T> BgArr<T> &BgArr<T>::Append( BgArr &A ) { m_nObjMax = ((m_nObj+A.m_nObj)/m_nGrowBy+1)*m_nGrowBy; PT *ppNew = new PT[m_nObjMax]; int i, j; for ( i=0; i<m_nObj; i++ ) { ppNew[i] = m_ppObj[i]; } for ( i=m_nObj, j=0; j<A.m_nObj; i++, j++ ) { ppNew[i] = A.m_ppObj[j]; } delete [] m_ppObj; m_ppObj = ppNew; m_nObj += A.m_nObj; delete [] A.m_ppObj; A.m_ppObj = new PT[A.m_nGrowBy]; A.m_nObj = 0; A.m_nObjMax = A.m_nGrowBy; SetDirty( true ); return *this; } template<class T> void BgArr<T>::ReverseOrder() { PT *ppNew = new PT[m_nObjMax]; for ( int i=0, j=m_nObj-1; i<m_nObj; i++, j-- ) { ppNew[i] = m_ppObj[j]; } delete [] m_ppObj; m_ppObj = ppNew; SetDirty( true ); } template<class T> bool BgArr<T>::Add( T *pObj ) { if ( m_nObj>=m_nObjMax ) { PT *ppOld = m_ppObj; m_nObjMax += m_nGrowBy; m_ppObj = new PT[m_nObjMax]; for ( int i=0; i<m_nObj; i++ ) { m_ppObj[i] = ppOld[i]; } delete [] ppOld; } // add pObj into array m_ppObj[m_nObj++] = pObj; SetDirty( true ); return true; } template<class T> bool BgArr<T>::AddAt( int n, T *pObj ) { if ( m_nObj>=m_nObjMax ) { PT *ppOld = m_ppObj; m_nObjMax += m_nGrowBy; m_ppObj = new PT[m_nObjMax]; for ( int i=0; i<m_nObj; i++ ) { m_ppObj[i] = ppOld[i]; } delete [] ppOld; } if ( n<m_nObj ) { // make space for object PT *pD = &(m_ppObj[m_nObj]); PT *pS = &(m_ppObj[m_nObj-1]); PT *pE = &(m_ppObj[n]); while ( pS>pE ) { *(pD--) = *(pS--); } if ( pS==pE ) { *pD = *pS; } } // add pObj into array m_ppObj[n] = pObj; m_nObj++; SetDirty( true ); return true; } template<class T> bool BgArr<T>::Detach( int n ) { if ( n>=m_nObj ) return false; PT *pD = &(m_ppObj[n]); PT *pS = &(m_ppObj[n+1]); PT *pE = &(m_ppObj[m_nObj]); while ( pS<pE ) { *(pD++) = *(pS++); } m_nObj--; SetDirty( true ); return true; } template<class T> int BgArr<T>::Find( const T *pObj ) const { if ( !pObj ) return MAXINT; for ( int i=0; i<m_nObj; i++ ) { if ( pObj==m_ppObj[i] ) return i; } return MAXINT; } template<class T> void BgArr<T>::Flush() { if ( m_bOwnsObjs ) { while ( m_nObj ) { delete m_ppObj[--m_nObj]; } } delete [] m_ppObj; m_nObj = 0; m_nObjMax = m_nGrowBy; m_ppObj = new PT[m_nObjMax]; for ( int n=0; n<m_nObjMax; n++ ) { m_ppObj[n] = NULL; } SetDirty( true ); } #endif // BgArr_h
Declared Classes:
Source
// BgMLDat.h: interface for the BgMLDat class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_BGMLDAT_H__92F34EE5_264E_4C9F_AD69_C0452C30F4E3__INCLUDED_) #define AFX_BGMLDAT_H__92F34EE5_264E_4C9F_AD69_C0452C30F4E3__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 //#include "BladeData.h" #include "BgArr.h" #include <math.h> typedef unsigned int uint; #define M_2_PI 6.28318530717959647692 #define M_PI 3.14159265358979323846 #define M_PI_2 1.57079632679489661923 #define M_PI_4 0.78539816339744830962 /**# :[Description = "This class contains the common enumerators and static variables for the UserIO classes."] */ class BgEnum { public: enum AngDatType { Side1Ang=-1, MeanLineAng=0, Side2Ang=1 }; enum ThkDatType { TangMeanThk, NormMeanThk, NormCambThk }; enum DataSetType { AngData=0x01, ThkData=0x02, AllData=0x03 }; enum LeTeEndType { SquareEnd, CutOffEnd, EllipseEnd }; enum HubShrEndType { PlainEnd, GapEnd, FilletEnd }; }; /**# :[Description = "This class describes a 3 Dimensional Cartisian point. Basic operators are provided to allow addition, subtraction, and scaling. Basic functions are provided."] */ class Bg3dPnt { public: double dX; double dY; double dZ; public: Bg3dPnt( const double &x=0.0, const double &y=0.0, const double &z=0.0 ) { dX = x; dY = y; dZ = z; } /**# :[Description = "Adds two Bg3dPnt objects together."] */ Bg3dPnt operator+ ( const Bg3dPnt& P ) const { return Bg3dPnt( dX+P.dX, dY+P.dY, dZ+P.dZ ); } /**# :[Description = "Subtracts a Bg3dPnt object from another."] */ Bg3dPnt operator- ( const Bg3dPnt& P ) const { return Bg3dPnt( dX-P.dX, dY-P.dY, dZ-P.dZ ); } /**# :[Description = "Multiplies a Bg3dPnt object by a factor."] */ Bg3dPnt operator* ( const double& dFac ) const { return Bg3dPnt( dX*dFac, dY*dFac, dZ*dFac ); } /**# :[Description = "Divides a Bg3dPnt object by a factor."] */ Bg3dPnt operator/ ( const double& dFac ) const { if ( dFac ) { return Bg3dPnt( dX/dFac, dY/dFac, dZ/dFac ); } else { return Bg3dPnt(); } } /**# :[Description = "Multiplies a Bg3dPnt object by a factor."] */ friend Bg3dPnt operator* ( const double &dFac, const Bg3dPnt &V ) { return V*dFac; } /**# :[Description = "Divides a Bg3dPnt object by a factor."] */ friend Bg3dPnt operator/ ( const double &dFac, const Bg3dPnt &V ) { return V/dFac; } /**# :[Description = "Adds a Bg3dPnt object to this object."] */ Bg3dPnt &operator+= ( const Bg3dPnt& P ) { dX+=P.dX; dY+=P.dY; dZ+=P.dZ; return *this; } /**# :[Description = "Subtracts a Bg3dPnt object from this object."] */ Bg3dPnt &operator-= ( const Bg3dPnt& P ) { dX-=P.dX; dY-=P.dY; dZ-=P.dZ; return *this; } /**# :[Description = "Multiplies this object by a factor."] */ Bg3dPnt &operator*= ( const double& dFac ) { dX*=dFac; dY*=dFac; dZ*=dFac; return *this; } /**# :[Description = "Divides this object by a factor."] */ Bg3dPnt &operator/= ( const double& dFac ) { if ( dFac==0.0 ) { dX = dY = dZ = 1.0; } else { dX/=dFac; dY/=dFac; dZ/=dFac; } return *this; } /**# :[Description = "Urary negative, returns the negative of this object."] */ Bg3dPnt operator-() const { return Bg3dPnt( -dX, -dY, -dZ ); } /**# :[Description = "Function to return the length of a line from the origin to this point."] */ double Magnitude() const { return sqrt( dX*dX + dY*dY + dZ*dZ ); } /**# :[Description = "Friend function to return the length of a line from the origin to this point."] */ friend double Magnitude( const Bg3dPnt& V ) { return sqrt( V.dX*V.dX + V.dY*V.dY + V.dZ*V.dZ ); } /**# :[Description = "Friend function to return the square of the length of a line from the origin to this point."] */ friend double Magnitude2( const Bg3dPnt& V ) { return ( V.dX*V.dX + V.dY*V.dY + V.dZ*V.dZ ); } /**# :[Description = "Friend function to return the length of a line between two Bg3dPnt objects."] */ friend double Dist( const Bg3dPnt& V1, const Bg3dPnt& V2 ) { return ::Magnitude( V2-V1 ); } /**# :[Description = "Function to scale the object to a unit vector."] */ Bg3dPnt &Normalized() { double dLen = sqrt( dX*dX + dY*dY + dZ*dZ ); if ( dLen>0.0 ) { dX /= dLen; dY /= dLen; dZ /= dLen; } return *this; } /**# :[Description = "Friend function to return a unit vector of the supplied object."] */ friend Bg3dPnt UnitVector( const Bg3dPnt& V ) { double dLen = sqrt( V.dX*V.dX + V.dY*V.dY + V.dZ*V.dZ ); return ( dLen>1.0e-30 ? V/dLen : V ); } /**# :[Description = "Friend function to return the angle between two vectors, supplied as Bg3dPnt objects."] */ friend double AngleBetween( const Bg3dPnt &V1, const Bg3dPnt &V2 ) { double dM = V1.Magnitude()*V2.Magnitude(); if ( dM==0.0 ) return 0.0; return acos( min( (double)max( DotProduct(V1,V2)/dM, -1.0), 1.0) ); } /**# :[Description = "Friend function to return the dot product of two vectors, supplied as Bg3dPnt objects."] */ friend double DotProduct( const Bg3dPnt& v1, const Bg3dPnt& v2 ) { return( v1.dX*v2.dX + v1.dY*v2.dY + v1.dZ*v2.dZ ); } /**# :[Description = "Friend function to return the cross product of two vectors, supplied as Bg3dPnt objects."] */ friend Bg3dPnt CrossProduct( const Bg3dPnt& v1, const Bg3dPnt& v2 ) { return Bg3dPnt( v1.dY*v2.dZ - v1.dZ*v2.dY, v2.dX*v1.dZ - v1.dX*v2.dZ, v1.dX*v2.dY - v1.dY*v2.dX ); } /**# :[Description = "Function to return the result of rotating this object about the X axis by the specified angle (radians)."] */ Bg3dPnt RotatedAboutX( const double &dAng ) const { return Bg3dPnt( dX, dY*cos(dAng)-dZ*sin(dAng), dY*sin(dAng)+dZ*cos(dAng) ); } /**# :[Description = "Function to return the result of rotating this object about the Y axis by the specified angle (radians)."] */ Bg3dPnt RotatedAboutY( const double &dAng ) const { return Bg3dPnt( dX*cos(dAng)+dZ*sin(dAng), dY, dZ*cos(dAng)-dX*sin(dAng) ); } /**# :[Description = "Function to return the result of rotating this object about the Z axis by the specified angle (radians)."] */ Bg3dPnt RotatedAboutZ( const double &dAng ) const { return Bg3dPnt( dX*cos(dAng)-dY*sin(dAng), dX*sin(dAng)+dY*cos(dAng), dZ ); } }; /**# :[Description = "This class describes a mean line data point. The location is stored in Cylindrical coordinates and meridional coordinates are also provided."] */ class AFX_EXT_CLASS BgMLDat { public: enum { nVer=1 }; // Import Variables double dR; double dTheta; double dZ; double dNrmThk; bool bSharp; // Export Variables double dBeta; double dS; double dM; double dMp; double dC; double dSec; public: /**# :[Description = "Basic constructor for BgMLDat object from individual values."] */ BgMLDat( const double &dZi=0.0, const double &dRi=0.0, const double &dThetai=0.0, const double &dNrmThki=0.0, const double &dBetai=0.0, const double &dSi=0.0, const double &dMi=0.0, const double &dMpi=0.0, const double &dCi=0.0, const double &dSeci=0.0, bool bSharpi=false ); /**# :[Description = "Basic constructor for BgMLDat object another object."] */ BgMLDat( const BgMLDat &mlDat ); /**# :[Description = "Assignment operator."] */ BgMLDat &operator=( const BgMLDat &mlDat ); /**# :[Description = "Conversion operator returns a Bg3dPnt from a BgMLDat."] */ operator Bg3dPnt() { return Bg3dPnt( dR*cos(dTheta), dR*sin(dTheta), dZ ); } /**# :[Description = "Function returns R*Theta."] */ double RT() const { return dR*dTheta; } /**# :[Description = "Function returns R*(Theta-ThetaRef)."] */ double RT( const double &dThetaRef ) const { return dR*(dTheta-dThetaRef); } /**# :[Description = "Friend function returns the Blade-to-Blade (M-Prime vs. Theta or M vs R*Theta) distance between to BgMLDat objects."] */ friend double B2BDist( const BgMLDat &mlD1, const BgMLDat &mlD2, bool bTrueB2B = false ) { double dX = ( bTrueB2B ? mlD1.dMp - mlD2.dMp : mlD1.dM - mlD2.dM ); double dTa = ( mlD1.dTheta + mlD2.dTheta )/2.0; double dY = ( bTrueB2B ? mlD1.dTheta - mlD2.dTheta : mlD1.RT( dTa ) - mlD2.RT( dTa ) ); return sqrt( dX*dX + dY*dY ); } /**# :[Description = "Friend function returns the Meridional distance between to BgMLDat objects."] */ friend double MerDist( const BgMLDat &dD1, const BgMLDat &dD2 ) { BgMLDat D = dD2 - dD1; return sqrt( D.dR*D.dR + D.dZ*D.dZ ); } /**# :[Description = "Adds two BgMLDat objects together."] */ BgMLDat operator+( const BgMLDat &D ) const { BgMLDat R; R.dZ = dZ + D.dZ; R.dR = dR + D.dR; R.dTheta = dTheta + D.dTheta; R.dNrmThk = dNrmThk+D.dNrmThk; R.dBeta = dBeta+D.dBeta; R.dS = dS + D.dS; R.dM = dM + D.dM; R.dMp = dMp+ D.dMp; R.dC = dC + D.dC; return R; } /**# :[Description = "Subtracts a BgMLDat object from another."] */ BgMLDat operator-( const BgMLDat &D ) const { BgMLDat R; R.dZ = dZ - D.dZ; R.dR = dR - D.dR; R.dTheta = dTheta - D.dTheta; R.dNrmThk = dNrmThk-D.dNrmThk; R.dBeta = dBeta-D.dBeta; R.dS = dS - D.dS; R.dM = dM - D.dM; R.dMp = dMp- D.dMp; R.dC = dC - D.dC; return R; } /**# :[Description = "Multiplies a BgMLDat object by a factor."] */ BgMLDat operator*( const double &dFac ) const { BgMLDat R; R.dZ = dZ*dFac; R.dR = dR*dFac; R.dTheta = dTheta*dFac; R.dNrmThk = dNrmThk*dFac; R.dBeta = dBeta*dFac; R.dS = dS*dFac; R.dM = dM*dFac; R.dMp = dMp*dFac; R.dC = dC*dFac; return R; } /**# :[Description = "Friend function to return the S value."] */ friend const double &Sf( const BgMLDat &Dat ) { return Dat.dS; } /**# :[Description = "Friend function to return the M value."] */ friend const double &Mf( const BgMLDat &Dat ) { return Dat.dM; } /**# :[Description = "Friend function to return the M-Prime value."] */ friend const double &Mpf( const BgMLDat &Dat ) { return Dat.dMp; } /**# :[Description = "Friend function to return the C value."] */ friend const double &Cf( const BgMLDat &Dat ) { return Dat.dC; } // Interpolation Interface /**# :[Description = "Function returns the number of variables available for interpolation."] */ static int NumVar() { return 4; } /**# :[Description = "Function sets a variables identified by the index to the specified value."] */ void SetVar( int iVar, const double &dVal ) { switch ( iVar ) { default: break; case 0: dS = dVal; break; case 1: dM = dVal; break; case 2: dMp = dVal; break; case 3: dC = dVal; break; } } /**# :[Description = "Function returns a variables identified by the index."] */ const double &Var( int iVar ) const { switch ( iVar ) { default: case 0: return dS; case 1: return dM; case 2: return dMp; case 3: return dC; } } /**# :[Description = "Function reads a BgMLDat object from the input stream."] */ virtual void Read( istream &is ); /**# :[Description = "Function saves a BgMLDat object to the output stream."] */ virtual void Save( ostream &os ) const; }; /**# :[Description = "This class describes a layer of mean line data points."] */ class AFX_EXT_CLASS BgMLDatArr : public BgArr<BgMLDat>, public BgEnum { public: typedef const double &(*ValueFunc)( const BgMLDat & ); enum SideType { Side1=-1, Mean=0, Side2=1 }; enum { nVer=1 }; protected: ThkDatType m_eThkDat; uint m_uiFlags; public: /**# :[Description = "Basic Constructor."] */ BgMLDatArr( ThkDatType eThkDat=NormMeanThk, uint uiFlag=AllData ); /**# :[Description = "Constructor from another object, copies the entire array."] */ BgMLDatArr( const BgMLDatArr &Arr ); /**# :[Description = "Destructor."] */ virtual ~BgMLDatArr(); /**# :[Description = "Assignment operator, copies entire array."] */ BgMLDatArr &operator=( const BgMLDatArr &Arr ); /**# :[Description = "Function uses the Ref curve and generates this mean line curve the Side1 and Side2 curves, using the specified number of points."] */ void CreateMeanLineFrom( const BgMLDatArr &Ref, const BgMLDatArr &Side1, const BgMLDatArr &Side2, int nPnt=30 ); /**# :[Description = "Function returns the flag value."] */ uint Flags() const { return m_uiFlags; } /**# :[Description = "Function sets the flag value."] */ void SetFlags( uint uiVal ) { m_uiFlags = uiVal; } /**# :[Description = "Function returns interpolates to the nearest point to the specified point, in the Meridional (Z,R) coordinate system."] */ BgMLDat DatNearestMer( const BgMLDat &mlDat ); /**# :[Description = "Function returns interpolates to the nearest point to the specified point, in the Blade-To-Blade (Mp,Theta) coordinate system."] */ BgMLDat DatNearestB2B( const BgMLDat &mlDat ); /**# :[Description = "Function interpolates to the value specified using the BgMLDat value functions (Sf, Mf, Mpf, Cf)."] */ BgMLDat InterpUsing( ValueFunc Value, const double &dVal ); /**# :[Description = "Function returns the value at the specified S position, at the SideType location."] */ BgMLDat DatAt( const double &dS, SideType eSide ); /**# :[Description = "Function returns the value at the index, at the SideType location."] */ BgMLDat DatAt( int i, SideType eSide ); /**# :[Description = "Function converts mean line data to the specified SideType location."] */ BgMLDat ML2Cyl( const BgMLDat &mlDat, SideType eSide ); virtual void Read( istream &is ); virtual void Save( ostream &os ) const; }; /**# :[Description = "This class describes an array of mean line data arrays (layers), which can represent a blade."] */ class AFX_EXT_CLASS BgMLDatArrArr : public BgArr<BgMLDatArr>, public BgEnum { public: protected: /**# :[Description = "Specifies the angular value type that the arrays are describing (See BgEnum)."] */ AngDatType m_eAngDat; /**# :[Description = "Specifies the thickness value type that the arrays are describing (See BgEnum)."] */ ThkDatType m_eThkDat; public: /**# :[Description = "Basic Constructor."] */ BgMLDatArrArr( AngDatType eAngDat=MeanLineAng, ThkDatType eThkDat=NormMeanThk ); /**# :[Description = "Constructor from another object, copies the entire array."] */ BgMLDatArrArr( const BgMLDatArrArr &Arr ); /**# :[Description = "Destructor."] */ virtual ~BgMLDatArrArr(); /**# :[Description = "Assignment operator, copies entire array."] */ BgMLDatArrArr &operator=( const BgMLDatArrArr &Arr ); /**# :[Description = "Function returns the AngDatType value."] */ AngDatType AngDat() const { return m_eAngDat; } /**# :[Description = "Function sets the AngDatType value."] */ void SetAngDat( AngDatType eType ) { m_eAngDat = eType; } /**# :[Description = "Function returns the ThkDatType value."] */ ThkDatType ThkDat() const { return m_eThkDat; } /**# :[Description = "Function sets the ThkDatType value."] */ void SetThkDat( ThkDatType eType ) { m_eThkDat = eType; } /**# :[Description = "Function sets the AngDatType and ThkDatType values."] */ void SetDatType( AngDatType eAngDat, ThkDatType eThkDat ) { m_eAngDat = eAngDat; m_eThkDat = eThkDat; } }; /**# :[Description = "This class describes an array of layer arrays (blades), which can represent a blade system."] */ class BgMLDatArrArrArr : public BgArr<BgMLDatArrArr> { public: /**# :[Description = "Basic Constructor."] */ BgMLDatArrArrArr( int nGrow=4, bool bOwns=true ) : BgArr<BgMLDatArrArr>( nGrow, bOwns ) {} /**# :[Description = "Virtual Destructor."] */ virtual ~BgMLDatArrArrArr() {} }; #endif // !defined(AFX_BGMLDAT_H__92F34EE5_264E_4C9F_AD69_C0452C30F4E3__INCLUDED_)
Declared Classes:
// BgModel.h: interface for the BgModel class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_BGMODEL_H__B6C8BEFB_CBD0_4B16_AB9C_337AADB648F8__INCLUDED_) #define AFX_BGMODEL_H__B6C8BEFB_CBD0_4B16_AB9C_337AADB648F8__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #include "BgMLDat.h" #include "BgBlade.h" #include <iostream.h> class CBladeGeom; class CldModel; /**# :[Description = "This class describes a model and acts as the container of all model data. Access for imput and output is provided through the member functions of this class."] */ class AFX_EXT_CLASS BgModel : public BgEnum { public: enum AddType { LeaveSquare=0x00, AddExtension=0x01, AddFiling=0x02, AddEnd=0x04, AddTreatments=AddFiling|AddEnd }; enum EndType { UnknownEnd=-1, SquareEnd, CutOffEnd, EllipseEnd }; enum { nVer=1 }; private: /**# :[Description = "Pointer to BladeGen object."] */ CBladeGeom *m_pGeom; /**# :[Description = "Pointer to Layer Model object, created for periodic output only."] */ CldModel *m_pModel; public: /**# :[Description = "Basic Constructor."] */ BgModel(); /**# :[Description = "Virtual Destructor."] */ virtual ~BgModel(); /**# :[Description = "Clears all data from the model."] */ void Clear(); //============================================================================================== // Data Import Routines /**# :[Description = "Creates a Design Meridional Profile. Returns true if successful, false if uncessessful."] */ bool CreateDsgnMerDef( int nBladeSets, const BgBladeArr &BladeArr, bool bSafeCurveTypes=true, bool bBezierExtensions=false ); /**# :[Description = "Creates a Design Meridional Profile. Returns true if successful, false if uncessessful."] */ bool CreateDsgnMerDef( int nBladeSets, const BgMLDatArrArrArr &MeanArrArrArr, bool bSafeCurveTypes=true, bool bBezierExtensions=false ); /**# :[Description = "Creates a Design Meridional Profile. Returns true if successful, false if uncessessful."] */ bool CreateDsgnMerDef( int nBladeSets, const BgMLDatArrArr &MeanArrArr, bool bSafeCurveTypes=true, bool bBezierExtensions=false ); /**# :[Description = "Creates a Design Meridional Control Curve. Returns true if successful, false if uncessessful."] */ bool CreateDsgnCtrlCrv( const BgMLDatArr &Ctrl, const double &dEstS ); /**# :[Description = "Creates a set of blades from an array. Returns true if successful, false if uncessessful."] */ bool CreateBlades( const BgBladeArr &BladeArr ); /**# :[Description = "Creates a blade. The first is the main blade, second is a splitter... Returns true if successful, false if uncessessful."] */ bool CreateBlade( const BgBlade &Blade ); /**# :[Description = "Creates a Trim Meridional Definition. Design Definition must already exist. Returns true if successful, false if uncessessful."] */ bool CreateTrimMerDef( int nLayers, BgMLDatArr *pHub=NULL, BgMLDatArr *pShr=NULL ); /**# :[Description = "Creates a Trim Meridional Control Curve. Returns true if successful, false if uncessessful."] */ bool CreateTrimCtrlCrv( const BgMLDatArr &Ctrl, const double &dEstS ); //============================================================================================== // Data Export Routines /**# :[Description = "Exports the blades (1 or more) for the model. Returns true if successful, false if uncessessful."] */ bool ExportBlades( BgBladeArr &BladeArr ); /**# :[Description = "Returns the number of blade sets (1 or more). Equal to the number of "Main" blades."] */ int NumBladeSets(); /**# :[Description = "Returns the number of blades (1 or more). Equal to one plus the number of splitters."] */ int NumBlades(); /**# :[Description = "Returns the number of layers (2 or more). Equal to one plus the number of splitters."] */ int NumLayers(); //============================================================================================== // Meanline Data Export Routines // Periodic Surface Data /**# :[Description = "Creates a mean line data array for the periodic surface at the specified layer."] */ bool PeriodicLayerData( int nLayer, BgMLDatArr &DatArr ); // Blade Surface Data /**# :[Description = "Creates a mean line data array for the specified blade at the specified layer."] */ bool BladeLayerData( int nBlade, int nLayer, uint uiFlags, BgMLDatArr &DatArr ); // Extended Blade Surface Data (from inlet to outlet) /**# :[Description = "Creates a extended mean line data array for the specified blade at the specified layer. Data extends from inlet to outlet, extensions have a thickness value of zero."] */ bool ExBladeLayerData( int nBlade, int nLayer, uint uiFlags, BgMLDatArr &DatArr ); // Layer Information Routine /**# :[Description = "Returns the mid length span fraction for the specified layer."] */ double MidLenSpanFraction( int nLayer ) const; // Blade Information Routines /**# :[Description = "Defines the centroid and airfoil area of the specified blade at the specified layer. Returns true if successful, false if uncessessful."] */ bool AreaProps( int nBlade, int nLayer, BgMLDat &mldCentroid, double &dArea ); /**# :[Description = "Returns the pitch fraction for the specified blade."] */ double PitchFraction( int nBlade ) const; /**# :[Description = "Returns the type of end on the leading edge of the specified blade."] */ EndType BladeLeEndType( int nBlade ) const; /**# :[Description = "Returns the type of end on the trailing edge of the specified blade."] */ EndType BladeTeEndType( int nBlade ) const; /**# :[Description = "Returns the number of points in the leading edge of the specified blade. If bExtended is set to true, the number reflects the effect of the extension (if it exists)."] */ int NumLePoints( int nBlade, bool bExtended=false ) const; /**# :[Description = "Returns the number of points in the trailing edge of the specified blade. If bExtended is set to true, the number reflects the effect of the extension (if it exists)."] */ int NumTePoints( int nBlade, bool bExtended=false ) const; // Meridional Coordinate Export /**# :[Description = "Determines the meridional coordinate (Z,R) for the meridional position (U,V). Returns true if successful, false if uncessessful."] [Inputs = "const double &dZ, const double &dR"] [Output = "double &dU, double &dV"] */ bool PntAt( const double &dU, const double &dV, double &dZ, double &dR ); /**# :[Description = "Determines the meridional position (U,V) for the meridional coordinate (Z,R). Returns true if successful, false if uncessessful."] [Inputs = "const double &dZ, const double &dR"] [Output = "double &dU, double &dV"] */ bool CoordAt( const double &dZ, const double &dR, double &dU, double &dV ); //============================================================================================== // Data IO Routines bool SaveBGI( const char *pszFileName ); bool ReadBGI( const char *pszFileName, ostream *pos=NULL, int nArg=0, char *pszArg[]=NULL ); bool SaveBGD( const char *pszFileName ); bool ReadBGD( const char *pszFileName ); // virtual void Read( istream &is ); // virtual void Save( ostream &os ) const; }; #endif // !defined(AFX_BGMODEL_H__B6C8BEFB_CBD0_4B16_AB9C_337AADB648F8__INCLUDED_)
Declared Classes:
// BgBlade.h: interface for the BgBlade class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_BGBLADE_H__A8572FBF_9999_40EC_ADA2_602C0035F2C5__INCLUDED_) #define AFX_BGBLADE_H__A8572FBF_9999_40EC_ADA2_602C0035F2C5__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #include "BgMLDat.h" #include "BgSpanDef.h" #include "bgFilingData.h" /**# :[Description = "This class describes a blade through its variables and objects. The default constructor creates a default BladeGen blade, but without data arrays."] */ class AFX_EXT_CLASS BgBlade : public BgEnum { public: enum { nVer=1 }; protected: // Blade Data BgMLDatArrArr m_Mean; BgMLDatArrArr m_Side1; BgMLDatArrArr m_Side2; double m_dPitchFrac; bool m_bSafeCurveTypes; BgSpanDefAng m_AngDef; BgSpanDefThk m_ThkDef; // LE/TE End LeTeEndType m_eLeEnd; double m_dLeHubRatio; double m_dLeShrRatio; LeTeEndType m_eTeEnd; double m_dTeHubRatio; double m_dTeShrRatio; bool m_bEllipseTang; static const double s_dEllipseLimit; // Over/Under-Filing BgFilingData m_LeSide1Filing; BgFilingData m_LeSide2Filing; BgFilingData m_TeSide1Filing; BgFilingData m_TeSide2Filing; // Hub/Shr End Data HubShrEndType m_eHubType; double m_dHubLeRad; double m_dHubTeRad; HubShrEndType m_eShrType; double m_dShrLeRad; double m_dShrTeRad; public: /**# :[Description = "Basic Constructor."] */ BgBlade( const double dPitchFrac=0.0, bool bSafeCurveTypes=true ); /**# :[Description = "Constructor from another BgBlade object."] */ BgBlade( const BgBlade &B ); /**# :[Description = "Virtual Destructor."] */ virtual ~BgBlade(); /**# :[Description = "Assignment operator from another BgBlade object."] */ BgBlade &operator=( const BgBlade &B ); /**# :[Description = "Function returns the Mean Line Array."] */ BgMLDatArrArr &Mean(); /**# :[Description = "Function returns the Mean Line Array."] */ const BgMLDatArrArr &Mean() const; /**# :[Description = "Function returns the Side1 Array (only used for Prs/Sct Mode)."] */ BgMLDatArrArr &Side1(); /**# :[Description = "Function returns the Side1 Array (only used for Prs/Sct Mode)."] */ const BgMLDatArrArr &Side1() const; /**# :[Description = "Function returns the Side2 Array (only used for Prs/Sct Mode)."] */ BgMLDatArrArr &Side2(); /**# :[Description = "Function returns the Side2 Array (only used for Prs/Sct Mode)."] */ const BgMLDatArrArr &Side2() const; /**# :[Description = "Function returns the location of the Blade as pitch fraction."] */ const double &PitchFrac() const; /**# :[Description = "Function sets the location of the Blade as pitch fraction."] */ void SetPitchFrac( double &dVal ); /**# :[Description = "Function returns the SaveCurveTypes bool, used to control the curve types during BladeGen blade construction."] */ bool SafeCurveTypes() const; /**# :[Description = "Function sets the SaveCurveTypes bool, used to control the curve types during BladeGen blade construction."] */ void SetSafeCurveTypes( bool bSaveCurveTypes ); /**# :[Description = "Function returns a reference to the AngSpanDef object to allow modification."] */ BgSpanDefAng &AngSpanDef(); /**# :[Description = "Function returns a const reference to the AngSpanDef object to for interrogation."] */ const BgSpanDefAng &AngSpanDef() const; /**# :[Description = "Function returns a reference to the ThkSpanDef object to allow modification."] */ BgSpanDefThk &ThkSpanDef(); /**# :[Description = "Function returns a const reference to the ThkSpanDef object to for interrogation."] */ const BgSpanDefThk &ThkSpanDef() const; /**# :[Description = "Function returns the leading edge EndType value."] */ LeTeEndType LeEnd() const; /**# :[Description = "Function sets the leading edge EndType value."] */ void SetLeEnd( LeTeEndType eVal ); /**# :[Description = "Function returns the leading edge hub elliptical ratio, if applicable."] */ double LeHubRatio() const; /**# :[Description = "Function returns the leading edge shroud elliptical ratio, if applicable."] */ double LeShrRatio() const; /**# :[Description = "Function sets the leading edge hub and shroud elliptical ratio."] */ void SetLeEllipseRatios( const double &dHub, const double &dShr ); /**# :[Description = "Function returns the trailing edge EndType value."] */ LeTeEndType TeEnd() const; /**# :[Description = "Function sets the trailing edge EndType value."] */ void SetTeEnd( LeTeEndType eVal ); /**# :[Description = "Function returns the trailing edge hub elliptical ratio, if applicable."] */ double TeHubRatio() const; /**# :[Description = "Function returns the trailing edge shroud elliptical ratio, if applicable."] */ double TeShrRatio() const; /**# :[Description = "Function sets the trailing edge hub and shroud elliptical ratio."] */ void SetTeEllipseRatios( const double &dHub, const double &dShr ); /**# :[Description = "Function returns the bool flag for tangential ellipses."] */ bool EllipseTang() const; /**# :[Description = "Function sets the bool flag for tangential ellipses."] */ void SetEllipseTang( bool bVal ); /**# :[Description = "Function sets the leading edge, side 1 over/under-filing data."] */ void SetLeSide1Filing( const BgFilingData &LeSide1Filing ); /**# :[Description = "Function returns the leading edge, side 1 over/under-filing data for modification."] */ BgFilingData &LeSide1Filing(); /**# :[Description = "Function returns the leading edge, side 1 over/under-filing data for interrogation."] */ const BgFilingData &LeSide1Filing() const; /**# :[Description = "Function sets the leading edge, side 2 over/under-filing data."] */ void SetLeSide2Filing( const BgFilingData &LeSide2Filing ); /**# :[Description = "Function returns the leading edge, side 2 over/under-filing data for modification."] */ BgFilingData &LeSide2Filing(); /**# :[Description = "Function returns the leading edge, side 2 over/under-filing data for interrogation."] */ const BgFilingData &LeSide2Filing() const; /**# :[Description = "Function sets the trailing edge, side 1 over/under-filing data."] */ void SetTeSide1Filing( const BgFilingData &TeSide1Filing ); /**# :[Description = "Function returns the trailing edge, side 1 over/under-filing data for modification."] */ BgFilingData &TeSide1Filing(); /**# :[Description = "Function returns the trailing edge, side 1 over/under-filing data for interrogation."] */ const BgFilingData &TeSide1Filing() const; /**# :[Description = "Function sets the trailing edge, side 2 over/under-filing data."] */ void SetTeSide2Filing( const BgFilingData &TeSide2Filing ); /**# :[Description = "Function returns the trailing edge, side 2 over/under-filing data for modification."] */ BgFilingData &TeSide2Filing(); /**# :[Description = "Function returns the trailing edge, side 2 over/under-filing data for interrogation."] */ const BgFilingData &TeSide2Filing() const; /**# :[Description = "Function sets the hub edge configuration."] */ void SetHubEndType( HubShrEndType eType, const double &dLeRad=0.0, const double &dTeRad=0.0 ); /**# :[Description = "Function returns the hub edge type."] */ HubShrEndType HubEndType() const; /**# :[Description = "Function returns the hub leading edge radius value."] */ const double &HubLeRad() const; /**# :[Description = "Function returns the hub trailing edge radius value."] */ const double &HubTeRad() const; /**# :[Description = "Function sets the shroud edge configuration."] */ void SetShrEndType( HubShrEndType eType, const double &dLeRad=0.0, const double &dTeRad=0.0 ); /**# :[Description = "Function returns the shroud edge type."] */ HubShrEndType ShrEndType() const; /**# :[Description = "Function returns the shroud leading edge radius value."] */ const double &ShrLeRad() const; /**# :[Description = "Function returns the shroud trailing edge radius value."] */ const double &ShrTeRad() const; virtual void Read( istream &is ); virtual void Save( ostream &os ) const; }; /**# :[Description = "This array holds BgBlade objects."] */ class BgBladeArr : public BgArr<BgBlade> { public: /**# :[Description = "Basic Constructor."] */ BgBladeArr( int nGrow=4, bool bOwns=true ) : BgArr<BgBlade>( nGrow, bOwns ) {} /**# :[Description = "Virtual Destructor."] */ virtual ~BgBladeArr() {} }; #endif // !defined(AFX_BGBLADE_H__A8572FBF_9999_40EC_ADA2_602C0035F2C5__INCLUDED_) /**# implementation BgBladeArr:: id(C_1022391574) */
Declared Classes:
// BgFilingData.h: interface for the BgFilingData class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_BGFILINGDATA_H__5FAF5595_CD5E_4474_AA80_6631B318BFC9__INCLUDED_) #define AFX_BGFILINGDATA_H__5FAF5595_CD5E_4474_AA80_6631B318BFC9__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #include <iostream.h> /**# :[Description = "This class describes a Over\/Under-Filing, on one ’corner’ of the blade. Four instances of this class are used to describe the full description."] */ class BgFilingData { public: enum { nVer=1 }; protected: double m_dHubLen; double m_dShrLen; bool m_bSclLen; double m_dHubDep; double m_dShrDep; bool m_bSclDep; double m_dHubRad; double m_dShrRad; bool m_bSclRad; public: /**# :[Description = "Basic Constructor."] */ BgFilingData(); /**# :[Description = "Constructor from another BgFilingData object."] */ BgFilingData( const BgFilingData &D ); /**# :[Description = "Virtual Destructor."] */ virtual ~BgFilingData(); /**# :[Description = "Assignment operator from another BgFilingData object."] */ BgFilingData &operator=( const BgFilingData &D ); /**# :[Description = "Function removes the filing."] */ void Remove(); /**# :[Description = "Function removes the radius from the filing."] */ void RemoveRadius(); /**# :[Description = "Function returns the filing status."] */ bool Filed() const; /**# :[Description = "Function returns the filing radius status."] */ bool HasRadius() const; /**# :[Description = "Function sets the filing values."] */ void SetValues( const double &dHubLen, const double &dShrLen, bool bSclLen, const double &dHubDep, const double &dShrDep, bool bSclDep, const double &dHubRad, const double &dShrRad, bool bSclRad ); /**# :[Description = "Function returns the filing hub length."] */ const double &HubLen() const; /**# :[Description = "Function returns the filing shroud length."] */ const double &ShrLen() const; /**# :[Description = "Function returns the filing length scaling by thickness flag."] */ bool SclLen() const; /**# :[Description = "Function returns the filing hub depth."] */ const double &HubDep() const; /**# :[Description = "Function returns the filing shroud depth."] */ const double &ShrDep() const; /**# :[Description = "Function returns the filing depth scaling by thickness flag."] */ bool SclDep() const; /**# :[Description = "Function returns the filing hub radius."] */ const double &HubRad() const; /**# :[Description = "Function returns the filing shroud radius."] */ const double &ShrRad() const; /**# :[Description = "Function returns the filing radius scaling by thickness flag."] */ bool SclRad() const; void Read( istream &is ); void Save( ostream &os ) const; }; #endif // !defined(AFX_BGFILINGDATA_H__5FAF5595_CD5E_4474_AA80_6631B318BFC9__INCLUDED_)
Declared Classes:
// BgSpanDef.h: interface for the BgSpanDef class. // ////////////////////////////////////////////////////////////////////// #if !defined(AFX_BGSPANDEF_H__8A584DC5_21FF_410F_9608_5645ABA6911B__INCLUDED_) #define AFX_BGSPANDEF_H__8A584DC5_21FF_410F_9608_5645ABA6911B__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 #include <iostream.h> /**# :[Description = "The class describes the properties of a generic spanwise distribution."] */ class AFX_EXT_CLASS BgSpanDef { public: enum { nVer=1 }; protected: int m_nSpan; int m_nStrm; char *m_pszEquations; bool m_bAutoFit; double m_dInitStep; double m_dFinalStep; public: /**# :[Description = "Basic Constructor."] */ BgSpanDef( int nSpan=13, int nStrm=13, const char *pszEquations=NULL, bool bAutoFit=true, const double &dInitStep=0.1, const double &dFinalStep=1.0e-6 ); /**# :[Description = "Virtual Destructor."] */ virtual ~BgSpanDef(); /**# :[Description = "Function returns the number of span-wise points to use when fitting data (User-Defined Mode)."] */ int NumSpan() const; /**# :[Description = "Function returns the number of stream-wise points to use when fitting data (User-Defined Mode)."] */ int NumStrm() const; /**# :[Description = "Function sets the number of span-wise and stream-wise points to use when fitting data (User-Defined Mode)."] */ void SetNum( int nSpan, int nStrm ); /**# :[Description = "Function returns the equation string (User-Defined Mode)."] */ const char *Equations() const; /**# :[Description = "Function sets the equation string (User-Defined Mode)."] */ void SetEquations( const char *pszEquations ); /**# :[Description = "Function returns the flag to indicate if fitting is to be performed (User-Defined Mode)."] */ bool AutoFit() const; /**# :[Description = "Function returns the initial step size to use if fitting is to be performed (User-Defined Mode)."] */ const double &InitStep() const; /**# :[Description = "Function returns the final step size to use if fitting is to be performed (User-Defined Mode)."] */ const double &FinalStep() const; /**# :[Description = "Function sets the initial and final step sizes to use if fitting is to be performed (User-Defined Mode)."] */ void SetFitParm( bool bAutoFit=true, const double &dInitStep=0.1, const double &dFinalStep=1.0e-6 ); virtual void Read( istream &is ); virtual void Save( ostream &os ) const; }; /**# :[Description = "The class describes the properties of a angle definition spanwise distribution."] */ class AFX_EXT_CLASS BgSpanDefAng : public BgSpanDef { public: enum DefType { GenAngDef, AxialAngDef, RadialAngDef, UserAngDef, RuledAngDef }; enum { nVer=1 }; protected: DefType m_eDefType; public: /**# :[Description = "Basic Constructor."] */ BgSpanDefAng( DefType eDefType=GenAngDef, int nSpan=13, int nStrm=13, const char *pszEquations=NULL, bool bAutoFit=true, const double &dInitStep=0.1, const double &dFinalStep=1.0e-6 ); /**# :[Description = "Function returns the spanwise interpolation mode."] */ DefType SpanDef() const; /**# :[Description = "Function sets the spanwise interpolation mode."] */ void SetSpanDef( DefType eDefType=GenAngDef ); virtual void Read( istream &is ); virtual void Save( ostream &os ) const; }; /**# :[Description = "The class describes the properties of a thickness definition spanwise distribution."] */ class AFX_EXT_CLASS BgSpanDefThk : public BgSpanDef { public: enum DefType { GenThkDef, AxialThkDef, RadialThkDef, UserThkDef }; enum { nVer=1 }; protected: DefType m_eDefType; public: /**# :[Description = "Basic Constructor."] */ BgSpanDefThk( DefType eDefType=GenThkDef, int nSpan=13, int nStrm=13, const char *pszEquations=NULL, bool bAutoFit=true, const double &dInitStep=0.1, const double &dFinalStep=1.0e-6 ); /**# :[Description = "Function returns the spanwise interpolation mode."] */ DefType SpanDef() const; /**# :[Description = "Function sets the spanwise interpolation mode."] */ void SetSpanDef( DefType eDefType=GenThkDef ); virtual void Read( istream &is ); virtual void Save( ostream &os ) const; }; #endif // !defined(AFX_BGSPANDEF_H__8A584DC5_21FF_410F_9608_5645ABA6911B__INCLUDED_)
Declared Classes:
// xMsg.h - JMC - 10/10/96 #ifndef xMsg_h #define xMsg_h #include <string.h> #ifndef NOMFC /**# :[Description = "This class is used when an exception is thrown. It contains a string that can be used to describe the reason for the exception."] */ class xMsg : public CException #else class xMsg #endif { public: private: char *m_pszMsg; public: xMsg( const char *pszStr ) { m_pszMsg = NULL; SetMsg( pszStr ); } ~xMsg() { delete [] m_pszMsg; } xMsg( const xMsg &Msg ) { m_pszMsg = NULL; SetMsg( Msg.m_pszMsg ); } xMsg& operator=( const xMsg &Msg ) { SetMsg( Msg.m_pszMsg ); return *this; } void SetMsg( const char *pszStr ) { delete [] m_pszMsg; if ( pszStr && *pszStr ) { m_pszMsg = new char[ ( (strlen(pszStr)+1)/4+1 )*4 ]; strcpy( m_pszMsg, pszStr ); } else { m_pszMsg = new char[ 4 ]; *m_pszMsg = ’\0’; } } const char *Why() const { return m_pszMsg; } }; #endif // xMsg_h /**# implementation xMsg:: id(C_1022271081) */