panukl_struct.cpp

/*********************************************************************/ 
/*                                                                   */ 
/*                Panukl package - (C) TGG 2002                      */ 
/*                                                                   */ 
/*********************************************************************/ 
/*                          Warszawa, 2002                           */ 
/*********************************************************************/ 
/*                                                                   */
/* File: PanuklGlobalStruct.cpp                                      */
/*                                                                   */
/* Author: T.Grabowski                                               */
/*                                                                   */
/* Contents - structures definitions                                 */
/*                                                                   */ 
/*                                                                   */
/*********************************************************************/
/*                                                                   */
/*                                                                   */
 
#include <iostream>
#include <sstream>
#include <string>
#include <fstream>
 
#include "panukl_struct.h"
 
using namespace std;
 
GRID_ARRAYS::GRID_ARRAYS( void )
    {
    iMaxWakePanelNumber = MaxWakePanelNumber;
    iMaxWakesNumber = MaxWakesNumber;
    for( int i=0; i<23; i++ )pdWyniki[i] = 0;
    fVer = VERSION;
    }
 
GRID_ARRAYS::~GRID_ARRAYS( void )
    {
 
    DELETE_TAB( dX );
    DELETE_TAB( dXw );
    DELETE_TAB( dXkw );
    
    DELETE_TAB( iNeigh );
    DELETE_TAB( iNkw );
    DELETE_TAB( iKw );
 
    DELETE_TAB( iNnww );
    DELETE_TAB( iIpas );
    DELETE_TAB( iNpas );
 
    DELETE_TAB( dXp );
    DELETE_TAB( dYp );
    DELETE_TAB( dZp );
    DELETE_TAB( dQx );
    DELETE_TAB( dQy );
    DELETE_TAB( dQz );
    DELETE_TAB( dSig );
 
    DELETE_TAB( dSss );
    DELETE_TAB( dX0 );
    DELETE_TAB( dY0 );
    DELETE_TAB( dZ0 );
    DELETE_TAB( dAlf1 );
    DELETE_TAB( dAlf2 );
    DELETE_TAB( dAlf3 );
    DELETE_TAB( dBet1 );
    DELETE_TAB( dBet2 );
    DELETE_TAB( dBet3 );
    DELETE_TAB( dGam1 );
    DELETE_TAB( dGam2 );
    DELETE_TAB( dGam3 );
    
    DELETE_TAB( dAi );
    DELETE_TAB( dRhs );
    DELETE_TAB( dRh );
    DELETE_TAB( IPIV );
 
    DELETE_TAB( dVVVV );
    DELETE_TAB( dVxd );
    DELETE_TAB( dVyd );
    DELETE_TAB( dVzd );
    DELETE_TAB( dSs_rzut );
    DELETE_TAB( dCpp );
    DELETE_TAB( dVv2 );
    DELETE_TAB( dMach );
    
    DELETE_TAB( dCxi );
    DELETE_TAB( dCzi );
    DELETE_TAB( dCpr );
    DELETE_TAB( dSs_cpr0 );
    DELETE_TAB( dSs_cpr );
    DELETE_TAB( dCmr );
    DELETE_TAB( dCay );
    DELETE_TAB( dCxr );
    DELETE_TAB( dCyr );
    DELETE_TAB( dCzr );
    
    DELETE_TAB( dZzz );
    DELETE_TAB( dObr );
    DELETE_TAB( dCpb );
    }
 
//
//  Array element order (according to Fortran standard)
//
//      A3(n,m,l) = A(n*m*l)
//  A3(i,j,k) = A(fortran)( n*m * k(k-1)  + n * j(j-1) + i ) 
//
//      A2(n,m) = A(n*m)
//  A2(i,j) = A(fortran)( n * j(j-1) + i )
//
//
//
 
void GRID_ARRAYS::DeleteINP( void )
{
    DELETE_TAB( dX );
    DELETE_TAB( iNeigh );
    DELETE_TAB( dXkw );
    DELETE_TAB( iNkw );
    DELETE_TAB( iKw );
    Points.clear();
    Panels.clear();
}
 
void GRID_ARRAYS::Corner2Points( int *iD, VECTOR_3D *P )
{
    for(int j=0; j<(int)Points.size(); j++ )
        {
        if( Points[j] == *P )
            {
            *iD = j;
            return;
            }
        }
 
    Points.push_back( *P );
    *iD = Points.size()-1;
}
 
void GRID_ARRAYS::Panels2Points( void )
{
    Points.clear();
    for(int i=0; i<iN; i++)
        {
        Corner2Points( &Panels[i].IdP1, &Panels[i].P1 );
        Corner2Points( &Panels[i].IdP2, &Panels[i].P2 );
        Corner2Points( &Panels[i].IdP3, &Panels[i].P3 );
        Corner2Points( &Panels[i].IdP4, &Panels[i].P4 );
        }
}
 
void GRID_ARRAYS::Panels2Array( void )
{
    for( int i=0; i<iMaxPanelNumber; i++ )
        {
        dX[                     i ] = Panels[i].P1.x;
        dX[ iMaxPanelNumber*4 + i ] = Panels[i].P1.y;
        dX[ iMaxPanelNumber*8 + i ] = Panels[i].P1.z;
        
        dX[                     iMaxPanelNumber + i ] = Panels[i].P2.x;
        dX[ iMaxPanelNumber*4 + iMaxPanelNumber + i ] = Panels[i].P2.y;
        dX[ iMaxPanelNumber*8 + iMaxPanelNumber + i ] = Panels[i].P2.z;
        
        dX[                     iMaxPanelNumber*2 + i ] = Panels[i].P3.x;
        dX[ iMaxPanelNumber*4 + iMaxPanelNumber*2 + i ] = Panels[i].P3.y;
        dX[ iMaxPanelNumber*8 + iMaxPanelNumber*2 + i ] = Panels[i].P3.z;
        
        dX[                     iMaxPanelNumber*3 + i ] = Panels[i].P4.x;
        dX[ iMaxPanelNumber*4 + iMaxPanelNumber*3 + i ] = Panels[i].P4.y;
        dX[ iMaxPanelNumber*8 + iMaxPanelNumber*3 + i ] = Panels[i].P4.z;
        }
}
 
void GRID_ARRAYS::Array2Panels( void )
{
    Panels.clear();
    PANEL Panel;
    for( int i=0; i<iMaxPanelNumber; i++ )
        {
        Panel.P1.x = dX[             i ];
        Panel.P1.y = dX[ iMaxPanelNumber*4 + i ];
        Panel.P1.z = dX[ iMaxPanelNumber*8 + i ];
        
        Panel.P2.x = dX[             iMaxPanelNumber + i ];
        Panel.P2.y = dX[ iMaxPanelNumber*4 + iMaxPanelNumber + i ];
        Panel.P2.z = dX[ iMaxPanelNumber*8 + iMaxPanelNumber + i ];
        
        Panel.P3.x = dX[             iMaxPanelNumber*2 + i ];
        Panel.P3.y = dX[ iMaxPanelNumber*4 + iMaxPanelNumber*2 + i ];
        Panel.P3.z = dX[ iMaxPanelNumber*8 + iMaxPanelNumber*2 + i ];
        
        Panel.P4.x = dX[             iMaxPanelNumber*3 + i ];
        Panel.P4.y = dX[ iMaxPanelNumber*4 + iMaxPanelNumber*3 + i ];
        Panel.P4.z = dX[ iMaxPanelNumber*8 + iMaxPanelNumber*3 + i ];
        
        Panels.push_back( Panel );
        }
}
 
void GRID_ARRAYS::Points2Panels( void )
{
    for( int i=0; i<iN; i++ )
        {
        Panels[i].P1 = Points[ Panels[i].IdP1 ];
        Panels[i].P2 = Points[ Panels[i].IdP2 ];
        Panels[i].P3 = Points[ Panels[i].IdP3 ];
        Panels[i].P4 = Points[ Panels[i].IdP4 ];
        }
}
 
int GRID_ARRAYS::ReadINP( char *FileName )
{
    FILE *File;
    File = fopen( FileName, "r" );
    if( File == NULL )
        {
        fprintf( stderr, "[.INP] file open error (%s)\n", FileName );
        return (-1);
        }
        
    DeleteINP();
    
    strcpy( File_INP_date, filename_date(FileName) );
        
    char cRob[256], cc[10];
    int iReturn;
    ReadStr( File, cRob );
    if( !strncmp( cRob, "PANELS", 6 ) )
        {
        fscanf( File," %s %f %d", cc, &fVer, &iSym );
        iReturn = ReadIN1( File );
        }
    else if ( !strncmp( cRob, "POINTS", 6 ) )
        {
        fscanf( File," %s %f %d", cc, &fVer, &iSym );
        iReturn = ReadIN2( File );
        }
    else if ( !strncmp( cRob, "ver", 3 ) )
        {
        sscanf( cRob," %s %f %d", cc, &fVer, &iSym );
        iReturn = ReadIN1( File );
        }
    else
        {
        rewind( File );
        iSym = 99;
        iReturn = ReadIN1( File );
        }
        
    int iMaxBodyNeighbours_rob = 0;
    ReadPar( File, "%d", &iMaxBodyNeighbours_rob );
    iMaxBodyNeighbours = max( iMaxBodyNeighbours_rob, 1 );
    NEW_TAB( dXkw, double, iMaxWakePanelNumber*3*iMaxBodyNeighbours );
    NEW_TAB( iNkw, int, iMaxWakePanelNumber*iMaxBodyNeighbours );
    NEW_TAB( iKw, int, iMaxBodyNeighbours*3 );
    
    for( int i=0; i<3; i++ ) iKw[i] = 0;
        
    for( int k=0; k<iMaxBodyNeighbours_rob; k++ )
        {
        for( int i=0; i<3; i++ ) fscanf( File, "%d", &iKw[ iMaxBodyNeighbours*i + k ] );
        for( int i=0; i<iKw[ k ]; i++ )
            {
            for( int j=0; j<3; j++ ) fscanf( File, "%lf", &dXkw[ iMaxWakePanelNumber*3*k + iMaxWakePanelNumber*j + i ] );
            fscanf( File, "%d", &iNkw[ iMaxWakePanelNumber*k + i ] );
            }
        }
 
    ReadObjs( File );
        
    fclose( File );
    
    return iReturn;
}
 
int GRID_ARRAYS::ReadIN1( FILE *File )
{
    fscanf( File, " %d %lf %lf %lf %lf %lf %lf", 
            &iMaxPanelNumber, &dSS, &dCa, &dBs, &dXca25, &dZca25, &dWsp_sk );
 
    NEW_TAB( dX, double, iMaxPanelNumber * 4 * 3 );
    NEW_TAB( iNeigh, int, iMaxPanelNumber * 8 );
        
    int iRob;
    for( int i=0; i<iMaxPanelNumber; i++ )
        {
        fscanf( File, "%d", &iRob );
        for( int j=0; j<4; j++ )
            for( int k=0; k<3; k++ )
                fscanf( File, "%lf", &dX[ iMaxPanelNumber*4*k  + iMaxPanelNumber*j + i ] ); 
        }
        
    Array2Panels();
    Panels2Points();
    
    return(0);
}
 
int GRID_ARRAYS::ReadIN2( FILE *File )
{
    int iMaxPoints;
    fscanf( File, " %d %d %lf %lf %lf %lf %lf %lf", 
            &iMaxPanelNumber, &iMaxPoints, &dSS, &dCa, &dBs, &dXca25, &dZca25, &dWsp_sk );
 
    NEW_TAB( dX, double, iMaxPanelNumber * 4 * 3 );
    NEW_TAB( iNeigh, int, iMaxPanelNumber * 8 );
    iN = iMaxPanelNumber;
    
    int iRob;
    VECTOR_3D Point;
    Points.clear();
    for( int i=0; i<iMaxPoints; i++ )
        {
        fscanf (File,"%d ",&iRob);
        fscanf (File, "%lf %lf %lf", &Point.x, &Point.y, &Point.z );
        Points.push_back( Point );
        }
 
    PANEL Panel;
    for( int i=0; i<iMaxPanelNumber; i++ )
        {
        fscanf (File,"%d ",&iRob);
        fscanf (File, "%d %d %d %d", &Panel.IdP1, &Panel.IdP2, &Panel.IdP3, &Panel.IdP4 ); 
        Panels.push_back( Panel );
        }
        
    Points2Panels();
    Panels2Array();
    
    return(0);
}
 
int GRID_ARRAYS::WriteInpFromPanels( char *FileName, int iScale )
{
    FILE *File;
    File = fopen( FileName, "w" );
    if( File == NULL )
        {
        fprintf( stderr, "[.INP] file open error (%s)\n", FileName );
        return (-1);
        }
        
    fprintf( File, "PANELS\n");
    fprintf( File, "ver %5.2f %d\n", fVer, iSym );
    
    double dScale = iScale ? 1. : dWsp_sk;
        
    fprintf( File, "  %5d %10.4f %10.4f %10.4f %10.4f %10.4f %10.4f\n", 
        iMaxPanelNumber, dSS, dCa, dBs, dXca25, dZca25, dScale );
 
    PANEL rob;
    for( int i=0; i<(int)Panels.size(); i++ )
        {
        fprintf (File,"%5d ",i+1);
        rob.PutTo( Panels[i].P1*dWsp_sk, Panels[i].P2*dWsp_sk, Panels[i].P3*dWsp_sk, Panels[i].P4*dWsp_sk );
        rob.Vout(File);
        fprintf (File,"\n");
        }
 
    fprintf( File, "%d\n", iMaxBodyNeighbours );
        
    for( int k=0; k<iMaxBodyNeighbours; k++ )
        {
        for( int i=0; i<3; i++ ) fprintf( File, "%d ", iKw[ iMaxBodyNeighbours*i + k ] );
        fprintf( File, "\n" );
        for( int i=0; i<iKw[ k ]; i++ )
            {
            for( int j=0; j<3; j++ ) fprintf( File, "%12.7f ", dXkw[ iMaxWakePanelNumber*3*k + iMaxWakePanelNumber*j + i ]*dWsp_sk );
            fprintf( File, "%d\n", iNkw[ iMaxWakePanelNumber*k + i ] );
            }
        }
 
    WriteObjs( File );
    fclose( File );
    
    return 0;
}
 
int GRID_ARRAYS::WriteInpFromPoints( char *FileName, int iScale )
{
    FILE *File;
    File = fopen( FileName, "w" );
    if( File == NULL )
        {
        fprintf( stderr, "[.INP] file open error (%s)\n", FileName );
        return (-1);
        }
        
    fprintf( File, "POINTS\n");
    fprintf( File, "ver %5.2f %d\n", fVer, iSym );
    
    double dScale = iScale ? 1. : dWsp_sk;
        
    fprintf( File, "  %5d %5d %10.4f %10.4f %10.4f %10.4f %10.4f %10.4f\n", 
        iMaxPanelNumber, (int)Points.size(), dSS, dCa, dBs, dXca25, dZca25, dScale );
 
    VECTOR_3D rob;
    for( int i=0; i<(int)Points.size(); i++ )
        {
        fprintf (File,"%5d ",i+1);
        rob = Points[i]*dWsp_sk;
        vout( File, rob );
        fprintf (File,"\n");
        }
 
    for( int i=0; i<(int)Panels.size(); i++ )
        {
        fprintf (File,"%5d ",i+1);
        Panels[i].Iout(File);
        fprintf (File,"\n");
        }
 
    fprintf( File, "%d\n", iMaxBodyNeighbours );
        
    for( int k=0; k<iMaxBodyNeighbours; k++ )
        {
        for( int i=0; i<3; i++ ) fprintf( File, "%d ", iKw[ iMaxBodyNeighbours*i + k ] );
        fprintf( File, "\n" );
        for( int i=0; i<iKw[ k ]; i++ )
            {
            for( int j=0; j<3; j++ ) fprintf( File, "%12.7f ", dXkw[ iMaxWakePanelNumber*3*k + iMaxWakePanelNumber*j + i ]*dWsp_sk );
            fprintf( File, "%d\n", iNkw[ iMaxWakePanelNumber*k + i ] );
            }
        }
 
    WriteObjs( File );
    fclose( File );
    
    return 0;
}
 
int GRID_ARRAYS::ReadObjs( FILE *File )
{
    Objs.clear();
    return ReadObjs( File, Objs, 0, fVer );
}
 
int GRID_ARRAYS::ReadObjs( FILE *File, vector<MS2_OBJ> &Objs, int N1, float fVer )
{
    int iNobj = 0;
    int iRet = ReadPar( File, "%d", &iNobj );
    if( iRet == EOF || iNobj <= 0 )return 0;
    
    char name[200];
    MS2_OBJ rob;
    
//  Objs.clear();
    
    for( int i=0; i<iNobj; i++ )
        {
        if(fVer < 4.)
            fscanf( File, "%d %d", &rob.n1, &rob.n2 );
        else
            fscanf( File, "%d %d %d %d %d %d %d %d %d", &rob.n1, &rob.n2, &rob.ID, &rob.iType,
                &rob.SurfType, &rob.RibNr, &rob.iClosingRib, &rob.DivNo, &rob.DivType );
        rob.n1 += N1;
        rob.n2 += N1;
        ReadStr( File, name );
        rob.Name = string( name );
        Objs.push_back( rob );
        }
    
    return iNobj;
}
 
int GRID_ARRAYS::ReadObjs( ifstream &f, vector<MS2_OBJ> &Objs, int N1, float fVer )
{
    int iNobj = 0;
    f >> iNobj;
    if( f.eof() || iNobj <= 0 )return 0;
    
    MS2_OBJ rob;
    
//  Objs.clear();
    
    for( int i=0; i<iNobj; i++ )
        {
        if(fVer < 4.)
            f >> rob.n1 >> rob.n2;
        else
            f >> rob.n1 >> rob.n2 >> rob.ID >> rob.iType >> rob.SurfType >> rob.RibNr >> rob.iClosingRib >> rob.DivNo >> rob.DivType;
        rob.n1 += N1;
        rob.n2 += N1;
        getline( f, rob.Name );
        Objs.push_back( rob );
        }
    
    return iNobj;
}
 
void GRID_ARRAYS::WriteObjs( FILE *File )
{
    WriteObjs( File, Objs );
}
 
void GRID_ARRAYS::WriteObjs( FILE *File, std::vector<MS2_OBJ> &Objs )
{
#ifdef x86_64
 #ifdef Linux   
    fprintf( File, " %5lu\n", Objs.size() );
 #else
    fprintf( File, " %5llu\n", Objs.size() );
 #endif
#else
    fprintf( File, " %5d\n", Objs.size() );
#endif
    for( int i=0; i<(int)Objs.size(); i++ )
        fprintf( File, "%5d %5d %5d %5d %5d %5d %5d %5d %5d %s\n", 
            Objs[i].n1, Objs[i].n2, Objs[i].ID, Objs[i].iType,
            Objs[i].SurfType, Objs[i].RibNr, Objs[i].iClosingRib,
            Objs[i].DivNo, Objs[i].DivType, Objs[i].Name.c_str() );
}
 
void GRID_ARRAYS::DeleteDAT( void )
{
    DELETE_TAB( dX );
    DELETE_TAB( iNeigh );
    DELETE_TAB( iNnww );
    DELETE_TAB( iIpas );
}
 
int GRID_ARRAYS::ReadDAT( char *FileName, int iProg )
{
    FILE *File;
    File = fopen( FileName, "r" );
    if( File == NULL )
        {
        fprintf( stderr, "[.DAT] file open error (%s)\n", FileName );
        return (-1);
        }
        
    DeleteDAT();
        
    strcpy( File_DAT_date, filename_date(FileName) );
 
    char cRob[256];
    ReadStr( File, cRob );
    if( !strncmp( cRob, "ver", 3 ) )
        {
        char cc[10];
        sscanf( cRob," %s %f %d", cc, &fVer, &iSym );
        fscanf( File, " %d %d %d %lf %lf %lf %lf %lf", 
            &iMaxPanelNumber, &iLiczw, &iLiczp, &dSS, &dCa, &dBs, &dXca25, &dZca25 );
        }
    else
        {
        sscanf( cRob, " %d %d %d %lf %lf %lf %lf %lf", 
            &iMaxPanelNumber, &iLiczw, &iLiczp, &dSS, &dCa, &dBs, &dXca25, &dZca25 );
        iSym = 99;
        }
 
    iN = iMaxPanelNumber;
    
    iNw = iN + iLiczw;      // samolot + slad (gora) (1 panel/pasmo)
    iNw2 = iNw + iLiczw;        // samolot + slad (gora+dol) (1 panel/pasmo)
    iNww = iN + iLiczp;     // samolot + slad (gora)
    iNww2 = iNww + iLiczw;      // j.w. + dol sladu (1 panel/pasmo)
    
    NEW_TAB( dX, double, iNww2 * 4 * 3 );
    NEW_TAB( iNeigh, int, iNww2 * 8 );
        
    int iRob;
    for( int i=0; i<iN; i++ )
        {
        fscanf( File, "%d", &iRob );
        for( int j=0; j<4; j++ )
            for( int k=0; k<3; k++ )
                fscanf( File, "%lf", &dX[ iNww2*4*k  + iNww2*j + i ] ); 
        }
        
    ReadPar( File, "%d", &iLiczp );
    NEW_TAB( iNnww, int, iLiczw * 5 );
    NEW_TAB( iIpas, int, iLiczw * iMaxWakePanelNumber );
 
    for( int i=iN; i<iN+iLiczp; i++ )
        {
        fscanf( File, "%d", &iRob );
        for( int j=0; j<4; j++ )
            for( int k=0; k<3; k++ )
                fscanf( File, "%lf", &dX[ iNww2*4*k  + iNww2*j + i ] ); 
        }
    
    for( int i=0; i<iN; i++ )
        {
        fscanf( File, "%d", &iRob );
        for( int j=0; j<8; j++ ) fscanf( File, "%d", &iNeigh[ iNww2*j + i ] );
        }
 
    for( int i=0; i<iLiczw; i++ )
        {
        fscanf( File, "%d", &iRob );
        fscanf( File, "%d", &iNnww[ i ]);   
        fscanf( File, "%d", &iNnww[ iLiczw + i ]);
        fscanf( File, "%d", &iNnww[ iLiczw*2 + i ]);
        for( int j=0; j<iNnww[iLiczw*2+i]+1; j++ )
            fscanf( File, "%d", &iIpas[ iLiczw*j + i ] );
        }
 
    ReadObjs( File );       
    
    fclose( File );
 
    if( iProg == 1 )
        InitForPanukl();
    else if( iProg == 2 )
        InitForPress();
    
    dWsp_sk = 1.;
 
    return(0);
}
 
void GRID_ARRAYS::DeleteDATw( void )
{
    DELETE_TAB( dX );
    DELETE_TAB( iNeigh );
    DELETE_TAB( dXw );
 
    DELETE_TAB( iNnww )
    DELETE_TAB( iIpas );
    DELETE_TAB( iNpas );
}
 
int GRID_ARRAYS::ReadDATw( char *FileName )
{
    FILE *File;
    File = fopen( FileName, "r" );
    if( File == NULL )
        {
        fprintf( stderr, "[.DAT] file open error (%s)\n", FileName );
        return (-1);
        }
        
    DeleteDATw();
        
    strcpy( File_DAT_date, filename_date(FileName) );
        
    char cRob[256];
    ReadStr( File, cRob );
    if( !strncmp( cRob, "ver", 3 ) )
        {
        char cc[10];
        sscanf( cRob," %s %f %d", cc, &fVer, &iSym );
        fscanf( File, " %d %d %d %lf %lf %lf %lf %lf", 
            &iMaxPanelNumber, &iLiczw, &iLiczp, &dSS, &dCa, &dBs, &dXca25, &dZca25 );
        }
    else
        sscanf( cRob, " %d %d %d %lf %lf %lf %lf %lf", 
            &iMaxPanelNumber, &iLiczw, &iLiczp, &dSS, &dCa, &dBs, &dXca25, &dZca25 );
 
    iN = iMaxPanelNumber;
 
    NEW_TAB( dX, double, iMaxPanelNumber * 4 * 3 );
    NEW_TAB( iNeigh, int, iMaxPanelNumber * 8 );
        
    int iRob;
    for( int i=0; i<iMaxPanelNumber; i++ )
        {
        fscanf( File, "%d", &iRob );
        for( int j=0; j<4; j++ )
            for( int k=0; k<3; k++ )
                fscanf( File, "%lf", &dX[ iMaxPanelNumber*4*k  + iMaxPanelNumber*j + i ] ); 
        }
        
    ReadPar( File, "%d", &iLiczp );
    InitRob();
 
    int iMaxWP = iMaxWakesNumber*iMaxWakePanelNumber;
    for( int i=0; i<iLiczp; i++ )
        {
        fscanf( File, "%d", &iRob );
        for( int j=0; j<4; j++ )
            for( int k=0; k<3; k++ )
                fscanf( File, "%lf", &dXw[ iMaxWP*4*k  + iMaxWP*j + i ] ); 
        }
    
    for( int i=0; i<iMaxPanelNumber; i++ )
        {
        fscanf( File, "%d", &iRob );
        for( int j=0; j<8; j++ ) fscanf( File, "%d", &iNeigh[ iMaxPanelNumber*j + i ] );
        }
 
    for( int i=0; i<iLiczw; i++ )
        {
        fscanf( File, "%d", &iRob );
        fscanf( File, "%d", &iNnww[ i ]);   
        fscanf( File, "%d", &iNnww[ iMaxWakesNumber + i ]);
        fscanf( File, "%d", &iNpas[ i ]);
        for( int j=0; j<iNpas[i]+1; j++ )
            fscanf( File, "%d", &iIpas[ iMaxWakesNumber*j + i ] );
        }
        
    ReadObjs( File );       
    
    fclose( File );
    
    dWsp_sk = 1.;
    
    return(0);
}
 
int GRID_ARRAYS::WriteDAT( char *FileName )
{
    FILE *File;
    File = fopen( FileName, "w" );
    if( File == NULL )
        {
        fprintf( stderr, "[.DAT] file open error (%s)\n", FileName );
        return (-1);
        }
        
    fprintf( File, "ver %f %d\n", fVer, iSym );
        
    fprintf( File, "  %5d %5d %5d %10.4f %10.4f %10.4f %10.4f %10.4f\n", 
        iMaxPanelNumber, iLiczw, iLiczp, dSS, dCa, dBs, dXca25, dZca25 );
 
    for( int i=0; i<iMaxPanelNumber; i++ )
        {
        fprintf( File, " %4d", i+1 );
        for( int j=0; j<4; j++ )
            for( int k=0; k<3; k++ )
                fprintf( File, " %12.7f", dX[ iMaxPanelNumber*4*k  + iMaxPanelNumber*j + i ] ); 
        fprintf( File, "\n" );
        }
        
    fprintf( File, " %d\n", iLiczp );
 
    int iRob = iMaxWakesNumber*iMaxWakePanelNumber;
    for( int i=0; i<iLiczp; i++ )
        {
        fprintf( File, " %4d", i+iMaxPanelNumber+1 );
        for( int j=0; j<4; j++ )
            for( int k=0; k<3; k++ )
                fprintf( File, " %12.7f", dXw[ iRob*4*k  + iRob*j + i ] ); 
        fprintf( File, "\n" );
        }
    
    for( int i=0; i<iMaxPanelNumber; i++ )
        {
        fprintf( File, "  %5d", i+1 );
        for( int j=0; j<8; j++ ) fprintf( File, " %5d", iNeigh[ iMaxPanelNumber*j + i ] );
        fprintf( File, "\n" );
        }
 
    for( int i=0; i<iLiczw; i++ )
        {
        fprintf( File, "  %5d", i+1 );
        fprintf( File, " %5d", iNnww[ i ]); 
        fprintf( File, " %5d", iNnww[ iMaxWakesNumber + i ]);
        fprintf( File, " %5d", iNpas[ i ]);
        for( int j=0; j<iNpas[i]+1; j++ )
            fprintf( File, " %5d", iIpas[ iMaxWakesNumber*j + i ] );
        fprintf( File, "\n" );
        }
    
    WriteObjs( File );
    
    fclose( File );
    
    return(0);
}
 
int GRID_ARRAYS::ReadWyn( char *FileName )
{
    DeleteWyn();
    
    FILE *f = fopen( FileName, "r" );
    if( f == NULL )return( -1 );
    
    strcpy( TXTfile, FileName );
    strcpy( File_TXT_date, filename_date(FileName) );
 
    ReadComm( f );
    int N, NN = 0;
    do
        {
        N = 0;
        ReadPar( f, "%d", &N );
        if( N ) NN = N;
        }
    while( N > 0 );
    
    for( int i=0; i<23; i++ ) pdWyniki[i] = new double[NN];
    rewind( f );
//  fseek( f, 0L, SEEK_SET );
    ReadComm( f );
    char cRob[1024];
    int iM = 0;
    for( int i=0; i<NN; i++ )
        {
        ReadStr( f, cRob );
        string ccc = cRob;
        
        istringstream iss(ccc,istringstream::in);
        iss.clear();
        iss >> N;
        for( int j=0; j<23; j++ )
            {
            if( iss.good() ) iM = j+1;
            iss >> pdWyniki[j][i];
            }
        
        /*
        fscanf( f, "%d", &N );
        for( int j=0; j<23; j++ )
            fscanf( f, "%lf", &pdWyniki[j][i] );
        */          
        }
    fclose( f );
    
    iNwyn = NN;
    iMwyn = iM;
    
    fprintf( stderr, "mwyn = %d nwyn = %d\n", iMwyn, iNwyn );
    
    return( 0 );
}
 
void GRID_ARRAYS::SupWyn( void )
{
    int k,jj,n1,n2,n3;
    double x,y,z;
    VECTOR_3D v;
    
    for( int i=0; i<iN; i++ )
        {
            for( int j=0; j<4; j++ )
                {
                k = 0; x = dX[ iMaxPanelNumber*4*k  + iMaxPanelNumber*j + i ];
                k = 1; y = dX[ iMaxPanelNumber*4*k  + iMaxPanelNumber*j + i ];
                k = 2; z = dX[ iMaxPanelNumber*4*k  + iMaxPanelNumber*j + i ];
                
                v.x = x-pdWyniki[10][i];
                v.y = y-pdWyniki[11][i];
                v.z = z-pdWyniki[12][i];
                double dRob = v.Len();
          
                double dSum=1./dRob;
                pdWyniki[14+j][i]=pdWyniki[9][i]/dRob;
          
                jj = 1;
                n1 = 2*j - 1;
                if( n1 < 0 )n1 = 7;
                n2 = 2*j;
                n3 = 2*j + 1;
 
                k = iNeigh[ iMaxPanelNumber*n1 + i ]-1;
                if( k >= 0 && k < iMaxPanelNumber )
              {
                  v.x = x-pdWyniki[10][k];
                  v.y = y-pdWyniki[11][k];
                  v.z = z-pdWyniki[12][k];
                  dRob = v.Len();
                  dSum += 1./dRob;
                  pdWyniki[14+j][i]+=pdWyniki[9][k]/dRob;
                  jj=jj+1;
                  }
 
                k = iNeigh[ iMaxPanelNumber*n2 + i ]-1;
                if( k >= 0 && k < iMaxPanelNumber )
              {
                  v.x = x-pdWyniki[10][k];
                  v.y = y-pdWyniki[11][k];
                  v.z = z-pdWyniki[12][k];
                  dRob = v.Len();
                  dSum += 1./dRob;
                  pdWyniki[14+j][i]+=pdWyniki[9][k]/dRob;
                  jj=jj+1;
                  }
 
                k = iNeigh[ iMaxPanelNumber*n3 + i ]-1;
                if( k >= 0 && k < iMaxPanelNumber )
              {
                  v.x = x-pdWyniki[10][k];
                  v.y = y-pdWyniki[11][k];
                  v.z = z-pdWyniki[12][k];
                  dRob = v.Len();
                  dSum += 1./dRob;
                  pdWyniki[14+j][i]+=pdWyniki[9][k]/dRob;
                  jj=jj+1;
              }
              
            pdWyniki[14+j][i] /= dSum;
            //pdWyniki[14+j][i] /= jj;
                }
                
            for( int j=0; j<4; j++ )
                {
                k = 0; x = 0.5 * dX[ iMaxPanelNumber*4*k  + iMaxPanelNumber*j + i ];
                k = 1; y = 0.5 * dX[ iMaxPanelNumber*4*k  + iMaxPanelNumber*j + i ];
                k = 2; z = 0.5 * dX[ iMaxPanelNumber*4*k  + iMaxPanelNumber*j + i ];
                
                int j1=(j+1)%4;
                k = 0; x += 0.5 * dX[ iMaxPanelNumber*4*k  + iMaxPanelNumber*j1 + i ];
                k = 1; y += 0.5 * dX[ iMaxPanelNumber*4*k  + iMaxPanelNumber*j1 + i ];
                k = 2; z += 0.5 * dX[ iMaxPanelNumber*4*k  + iMaxPanelNumber*j1 + i ];
                
                v.x = x-pdWyniki[10][i];
                v.y = y-pdWyniki[11][i];
                v.z = z-pdWyniki[12][i];
                double dRob = v.Len();
          
                double dSum=1./dRob;
                pdWyniki[18+j][i]=pdWyniki[9][i]/dRob;
 
                k = iNeigh[ iMaxPanelNumber*(2*j+1) + i ]-1;
                if( k >= 0 && k < iMaxPanelNumber )
                  {
                  v.x = x-pdWyniki[10][k];
                  v.y = y-pdWyniki[11][k];
                  v.z = z-pdWyniki[12][k];
                  dRob = v.Len();
                  dSum += 1./dRob;
                  pdWyniki[18+j][i]+=pdWyniki[9][k]/dRob;
                  }
              
                pdWyniki[18+j][i] /= dSum;
                }
        }
 
    iMwyn = 22;
    
    //tg_filename_setext( TXTfile, ".tx0" );
    //WriteWyn( TXTfile );
}
 
int GRID_ARRAYS::WriteWyn( char *FileName )
{
    FILE *f = fopen( FileName, "w" );
    if( f == NULL )
        {
        fprintf(stderr, "Open problem %s: %s\n", FileName, strerror(errno) );
        return( -1 );
        }
 
    fprintf(f, "No doublet source vxd vyd vzd qx qy qz v^2 cp x y z Ma cp1 cp2 cp3 cp4 cpw1 cpw2 cpw3 cpw4 ss\n");
    for( int i=0; i<iN; i++ )
        {
        fprintf( f, " %5d", i+1 );
        for( int j=0; j<23; j++ )
            fprintf( f, " %16.8g", pdWyniki[j][i] );
        fprintf( f, "\n" );
        }
    fclose( f );
    
    return( 0 );
}
 
void GRID_ARRAYS::DeleteWyn( void )
{
    for( int i=0; i<23; i++ ) DELETE_TAB( pdWyniki[i] );
    iNwyn = 0;
    iMwyn = 0;
}
 
void GRID_ARRAYS::InitRob( void )
{
    NEW_TAB( dXw, double, iMaxWakesNumber*iMaxWakePanelNumber * 4 * 3 );
 
    NEW_TAB( iNnww, int, iMaxWakesNumber * 3 );
    NEW_TAB( iIpas, int, iMaxWakesNumber * iMaxWakePanelNumber );
    NEW_TAB( iNpas, int, iMaxWakesNumber );
}
 
void GRID_ARRAYS::InitCommon( void )
{
    NEW_TAB( dQx, double, iN );
    NEW_TAB( dQy, double, iN );
    NEW_TAB( dQz, double, iN );
    NEW_TAB( dSig, double, iN );
 
    NEW_TAB( dSss, double, iNww2 );
    NEW_TAB( dX0, double, iNww2 );
    NEW_TAB( dY0, double, iNww2 );
    NEW_TAB( dZ0, double, iNww2 );
    NEW_TAB( dAlf1, double, iNww2 );
    NEW_TAB( dAlf2, double, iNww2 );
    NEW_TAB( dAlf3, double, iNww2 );
    NEW_TAB( dBet1, double, iNww2 );
    NEW_TAB( dBet2, double, iNww2 );
    NEW_TAB( dBet3, double, iNww2 );
    NEW_TAB( dGam1, double, iNww2 );
    NEW_TAB( dGam2, double, iNww2 );
    NEW_TAB( dGam3, double, iNww2 );
    
    NEW_TAB( dRhs, double, iNww2 );
}   
 
void GRID_ARRAYS::InitForPanukl( void )
{
    InitCommon();
 
    NEW_TAB( dXp, double, iN );
    NEW_TAB( dYp, double, iN );
    NEW_TAB( dZp, double, iN );
 
    NEW_TAB( dAi, double, iN*iNww );
    NEW_TAB( dRh, double, iN );
    NEW_TAB( IPIV, int, iN );
}   
 
void GRID_ARRAYS::InitForPress( void )
{
    InitCommon();
    NEW_TAB( dVVVV, double, iN );
    NEW_TAB( dVxd, double, iN );
    NEW_TAB( dVyd, double, iN );
    NEW_TAB( dVzd, double, iN );
    NEW_TAB( dSs_rzut, double, iN );
    NEW_TAB( dCpp, double, iN );
    NEW_TAB( dVv2, double, iN );
    NEW_TAB( dMach, double, iN );
    
    NEW_TAB( dCxi, double, iLiczw );
    NEW_TAB( dCzi, double, iLiczw );
    NEW_TAB( dCpr, double, iLiczw );
    NEW_TAB( dSs_cpr0, double, iLiczw );
    NEW_TAB( dSs_cpr, double, iLiczw );
    NEW_TAB( dCmr, double, iLiczw );
    NEW_TAB( dCay, double, iLiczw );
    NEW_TAB( dCzr, double, iLiczw );
    NEW_TAB( dCyr, double, iLiczw );
    NEW_TAB( dCxr, double, iLiczw );
    
    NEW_TAB( dZzz, double, iN*4*3 );
    NEW_TAB( dObr, double, iN*4 );
    NEW_TAB( dCpb, double, iN*4 );
}