Пример #1
0
        public void ReadWellData()
        {
            FileReader br = new FileReader();

            Action <string> SetPosition = (name) =>
            {
                int  index    = Array.IndexOf(NAME[RESTART_STEP], name);
                long pointer  = POINTER[RESTART_STEP][index];
                long pointerb = POINTERB[RESTART_STEP][index];
                br.SetPosition(pointerb * 2147483648 + pointer);
            };

            //WELLS = new List<WELLDATA>();

            br.OpenBinaryFile(FILENAME);
            SetPosition("INTEHEAD");
            br.ReadHeader();
            int[] INTH = br.ReadIntList();
            NX     = INTH[8];
            NY     = INTH[9];
            NZ     = INTH[10];
            NACTIV = INTH[11];
            IPHS   = INTH[14];
            NWELLS = INTH[16];
            NCWMAX = INTH[17];
            NIWELZ = INTH[24];
            NSWELZ = INTH[25];
            NXWELZ = INTH[26];
            NZWELZ = INTH[27];
            NICONZ = INTH[32];
            NSCONZ = INTH[33];
            NXCONZ = INTH[34];

            if (INTH[94] < 0)
            {
                SIMTYPE = SIM_TYPE.OtherSim;
            }
            else
            {
                if (Enum.IsDefined(typeof(SIM_TYPE), INTH[94]))
                {
                    SIMTYPE = (SIM_TYPE)INTH[94];
                }
            }

            if (WELLS.Count != 0)
            {
                if (SIMTYPE != SIM_TYPE.IX) // Интерсект не выгружает данные по скважинам  и перфорациям
                {
                    SetPosition("ICON");
                    br.ReadHeader();
                    int[] ICON = br.ReadIntList();

                    SetPosition("SCON");
                    br.ReadHeader();
                    float[] SCON = br.ReadFloatList(br.header.count);

                    SetPosition("XCON");
                    br.ReadHeader();
                    double[] XCON = br.ReadDoubleList();

                    for (int IW = 0; IW < NWELLS; ++IW) // Для всех скважин и для всех перфораций
                    {
                        for (int IC = 0; IC < NCWMAX; ++IC)
                        {
                            if (ICON[IW * NICONZ * NCWMAX + IC * NICONZ + 0] != 0) // Если перфорация существует
                            {
                                WELLS[IW].COMPLS[IC].CF      = SCON[IW * NSCONZ * NCWMAX + IC * NSCONZ + 0];
                                WELLS[IW].COMPLS[IC].Depth   = SCON[IW * NSCONZ * NCWMAX + IC * NSCONZ + 1];
                                WELLS[IW].COMPLS[IC].D       = SCON[IW * NSCONZ * NCWMAX + IC * NSCONZ + 2];
                                WELLS[IW].COMPLS[IC].kh      = SCON[IW * NSCONZ * NCWMAX + IC * NSCONZ + 3];
                                WELLS[IW].COMPLS[IC].S       = SCON[IW * NSCONZ * NCWMAX + IC * NSCONZ + 4];
                                WELLS[IW].COMPLS[IC].Complex = SCON[IW * NSCONZ * NCWMAX + IC * NSCONZ + 6];
                                WELLS[IW].COMPLS[IC].H       = SCON[IW * NSCONZ * NCWMAX + IC * NSCONZ + 31];
                                WELLS[IW].COMPLS[IC].s38     = SCON[IW * NSCONZ * NCWMAX + IC * NSCONZ + 38];

                                WELLS[IW].COMPLS[IC].OPR   = XCON[IW * NXCONZ * NCWMAX + IC * NXCONZ + 0];
                                WELLS[IW].COMPLS[IC].WPR   = XCON[IW * NXCONZ * NCWMAX + IC * NXCONZ + 1];
                                WELLS[IW].COMPLS[IC].GPR   = XCON[IW * NXCONZ * NCWMAX + IC * NXCONZ + 2];
                                WELLS[IW].COMPLS[IC].OPT   = XCON[IW * NXCONZ * NCWMAX + IC * NXCONZ + 3];
                                WELLS[IW].COMPLS[IC].WPT   = XCON[IW * NXCONZ * NCWMAX + IC * NXCONZ + 4];
                                WELLS[IW].COMPLS[IC].GPT   = XCON[IW * NXCONZ * NCWMAX + IC * NXCONZ + 5];
                                WELLS[IW].COMPLS[IC].Hw    = XCON[IW * NXCONZ * NCWMAX + IC * NXCONZ + 9];
                                WELLS[IW].COMPLS[IC].PIO   = XCON[IW * NXCONZ * NCWMAX + IC * NXCONZ + 23];
                                WELLS[IW].COMPLS[IC].PIW   = XCON[IW * NXCONZ * NCWMAX + IC * NXCONZ + 24];
                                WELLS[IW].COMPLS[IC].PIG   = XCON[IW * NXCONZ * NCWMAX + IC * NXCONZ + 25];
                                WELLS[IW].COMPLS[IC].PRESS = XCON[IW * NXCONZ * NCWMAX + IC * NXCONZ + 34];
                                WELLS[IW].COMPLS[IC].SOIL  = XCON[IW * NXCONZ * NCWMAX + IC * NXCONZ + 35];
                            }
                        }
                    }
                }
            }

            br.CloseBinaryFile();
        }
Пример #2
0
        public void ReadRestart(string filename, int step)

        // для чтения показателей по перфорациям, я все таки вынес в отдельную процедуру
        // требуется редко, а читается постоянно
        {
            FILENAME = filename;

            // Проверка на LGR
            bool LGR = REPORT.Count != NAME.Count;

            RESTART_STEP = LGR ? step * 2 : step;

            FileReader br = new FileReader();

            Action <string> SetPosition = (name) =>
            {
                int  index    = Array.IndexOf(NAME[RESTART_STEP], name);
                long pointer  = POINTER[RESTART_STEP][index];
                long pointerb = POINTERB[RESTART_STEP][index];
                br.SetPosition(pointerb * 2147483648 + pointer);
            };

            WELLS = new List <WELLDATA>();

            br.OpenBinaryFile(filename);
            SetPosition("INTEHEAD");
            br.ReadHeader();
            int[] INTH = br.ReadIntList();
            NX     = INTH[8];
            NY     = INTH[9];
            NZ     = INTH[10];
            NACTIV = INTH[11];
            IPHS   = INTH[14];
            NWELLS = INTH[16];
            NCWMAX = INTH[17];
            NIWELZ = INTH[24];
            NSWELZ = INTH[25];
            NXWELZ = INTH[26];
            NZWELZ = INTH[27];
            NICONZ = INTH[32];
            NSCONZ = INTH[33];
            NXCONZ = INTH[34];

            if (INTH[94] < 0)
            {
                SIMTYPE = SIM_TYPE.OtherSim;
            }
            else
            {
                if (Enum.IsDefined(typeof(SIM_TYPE), INTH[94]))
                {
                    SIMTYPE = (SIM_TYPE)INTH[94];
                }
            }

            if (NWELLS != 0)
            {
                SetPosition("IWEL");
                br.ReadHeader();
                int[] IWEL = br.ReadIntList();

                for (int iw = 0; iw < NWELLS; ++iw)
                {
                    WELLS.Add(new WELLDATA
                    {
                        WINDEX     = iw,
                        I          = IWEL[iw * NIWELZ + 0],
                        J          = IWEL[iw * NIWELZ + 1],
                        K          = IWEL[iw * NIWELZ + 2],
                        COMPLNUM   = IWEL[iw * NIWELZ + 4],
                        GROUPNUM   = IWEL[iw * NIWELZ + 5],
                        WELLTYPE   = IWEL[iw * NIWELZ + 6],
                        WELLSTATUS = IWEL[iw * NIWELZ + 10],
                        LGR        = IWEL[iw * NIWELZ + 42]
                    });
                }

                if (SIMTYPE != SIM_TYPE.IX) // Интерсект не выгружает данные по скважинам  и перфорациям
                {
                    SetPosition("SWEL");
                    br.ReadHeader();

                    float[] SWEL = br.ReadFloatList(br.header.count);

                    for (int iw = 0; iw < NWELLS; ++iw)
                    {
                        WELLS[iw].WOPRH     = SWEL[iw * NSWELZ + 0];
                        WELLS[iw].WWPRH     = SWEL[iw * NSWELZ + 1];
                        WELLS[iw].WGPRH     = SWEL[iw * NSWELZ + 2];
                        WELLS[iw].WLPRH     = SWEL[iw * NSWELZ + 3];
                        WELLS[iw].REF_DEPTH = SWEL[iw * NSWELZ + 9];

                        if (NSWELZ > 10) // Навигатор NSWELS = 10
                        {
                            WELLS[iw].WEFA  = SWEL[iw * NSWELZ + 24];
                            WELLS[iw].WBHPH = SWEL[iw * NSWELZ + 68];
                        }
                    }

                    SetPosition("XWEL");

                    br.ReadHeader();

                    double[] XWEL = br.ReadDoubleList();

                    for (int iw = 0; iw < NWELLS; ++iw)
                    {
                        WELLS[iw].WOPR  = XWEL[iw * NXWELZ + 0];
                        WELLS[iw].WWPR  = XWEL[iw * NXWELZ + 1];
                        WELLS[iw].WLPR  = XWEL[iw * NXWELZ + 3];
                        WELLS[iw].WBHP  = XWEL[iw * NXWELZ + 6];
                        WELLS[iw].WWCT  = XWEL[iw * NXWELZ + 7];
                        WELLS[iw].WOPT  = XWEL[iw * NXWELZ + 18];
                        WELLS[iw].WWPT  = XWEL[iw * NXWELZ + 19];
                        WELLS[iw].WWIT  = XWEL[iw * NXWELZ + 23];
                        WELLS[iw].WPI   = XWEL[iw * NXWELZ + 55];
                        WELLS[iw].WOPTH = XWEL[iw * NXWELZ + 75];
                        WELLS[iw].WWPTH = XWEL[iw * NXWELZ + 76];
                        WELLS[iw].WWITH = XWEL[iw * NXWELZ + 81];
                    }
                }

                SetPosition("ZWEL");
                br.ReadHeader();

                string[] ZWEL = br.ReadStringList();

                for (int iw = 0; iw < NWELLS; ++iw)
                {
                    for (int ic = 0; ic < NZWELZ; ++ic)
                    {
                        WELLS[iw].WELLNAME = WELLS[iw].WELLNAME + ZWEL[iw * NZWELZ + ic];
                    }
                    WELLS[iw].WELLNAME.Trim();
                }

                SetPosition("ICON");
                br.ReadHeader();
                int[] ICON = br.ReadIntList();

                for (int IW = 0; IW < NWELLS; ++IW) // Для всех скважин и для всех перфораций
                {
                    for (int IC = 0; IC < NCWMAX; ++IC)
                    {
                        if (ICON[IW * NICONZ * NCWMAX + IC * NICONZ + 0] != 0) // Если перфорация существует
                        {
                            WELLS[IW].COMPLS.Add(new COMPLDATA
                            {
                                I      = ICON[IW * NICONZ * NCWMAX + IC * NICONZ + 1] - 1,
                                J      = ICON[IW * NICONZ * NCWMAX + IC * NICONZ + 2] - 1,
                                K      = ICON[IW * NICONZ * NCWMAX + IC * NICONZ + 3] - 1,
                                STATUS = ICON[IW * NICONZ * NCWMAX + IC * NICONZ + 5]
                            });
                        }
                    }
                }
            }

            br.CloseBinaryFile();
        }