Esempio n. 1
0
        public void FromSonic()
        {
            int count = dtLog.SampleCount;

            List <WellLogSample> LogDt = new List <WellLogSample>(dtLog.Samples);

            double[] Imp = new double[count];

            for (int i = 0; i < count; i++)
            {
                Imp[i] = 1000.0d * GCoef * Math.Pow(1 / dtLog[i].Value, GExp) / dtLog[i].Value;
            }
            Borehole b1 = dtLog.Borehole;

            using (ITransaction trans = DataManager.NewTransaction())
            {
                IPropertyVersionService pvs  = PetrelSystem.PropertyVersionService;
                ILogTemplate            glob = pvs.FindTemplateByMnemonics("Acoustic Impedance");
                PropertyVersion         pv   = pvs.FindOrCreate(glob);
                trans.Lock(b1);
                WellLog log = b1.Logs.CreateWellLog(pv);
                //log.Name = "rhoB";
                WellLogSample[] tsamples = new WellLogSample[count];
                for (int i2 = 0; i2 < count; i2++)
                {
                    double md  = LogDt[i2].MD;
                    float  val = (float)Imp[i2];
                    tsamples[i2] = new WellLogSample(md, val);
                }
                log.Samples = tsamples;
                trans.Commit();
            }
            PetrelLogger.InfoBox("The Impedance Log has been created in the same Well");
        }
Esempio n. 2
0
        //List<Borehole> b2 = new List<Borehole>();
        //public Borehole b1;

        public void save(WellLog LogType, int count, double startMD, double interval, Double[] array, string name)
        {
            //Borehole b1;
            //int count = LogType.SampleCount;

            List <WellLogSample> TypeLog = new List <WellLogSample>(LogType.Samples);
            Borehole             b1      = LogType.Borehole;

            //List<Borehole> b2 = new List<Borehole>();
            using (ITransaction trans = DataManager.NewTransaction())
            {
                IPropertyVersionService pvs  = PetrelSystem.PropertyVersionService;
                ILogTemplate            glob = pvs.FindTemplateByMnemonics(name);
                PropertyVersion         pv   = pvs.FindOrCreate(glob);
                trans.Lock(b1);
                WellLog log = b1.Logs.CreateWellLog(pv);
                //log.Name = "rhoB";
                WellLogSample[] tsamples = new WellLogSample[count];
                for (int i2 = 0; i2 < count; i2++)
                {
                    double md  = startMD + i2 * interval;
                    float  val = (float)array[i2];
                    tsamples[i2] = new WellLogSample(md, val);
                }
                log.Samples = tsamples;
                trans.Commit();
            }
        }
Esempio n. 3
0
        public void save()
        {
            List <WellLogSample> LogDens = new List <WellLogSample>(densLog.Samples);
            Borehole             b1      = densLog.Borehole;

            using (ITransaction trans = DataManager.NewTransaction())
            {
                IPropertyVersionService pvs  = PetrelSystem.PropertyVersionService;
                ILogTemplate            glob = pvs.FindTemplateByMnemonics("Velocity");
                PropertyVersion         pv   = pvs.FindOrCreate(glob);
                trans.Lock(b1);
                WellLog log = b1.Logs.CreateWellLog(pv);
                //log.Name = "rhoB";
                WellLogSample[] tsamples = new WellLogSample[count];
                for (int i2 = 0; i2 < count; i2++)
                {
                    double md  = LogDens[i2].MD;
                    float  val = (float)vel[i2];
                    tsamples[i2] = new WellLogSample(md, val);
                }
                log.Samples = tsamples;
                trans.Commit();
            }
            PetrelLogger.InfoBox("The Velocity Log has been created in the same Well");
        }
Esempio n. 4
0
        public void FromDensity()
        {
            //int count = Math.Min(velLog.SampleCount, densLog.SampleCount);

            List <WellLogSample> LogVel  = new List <WellLogSample>(velLog.Samples);
            List <WellLogSample> LogDens = new List <WellLogSample>(densLog.Samples);

            TwoLogCheck c2    = new TwoLogCheck(velLog, densLog);
            int         count = c2.count;

            if (count == 0)
            {
                PetrelLogger.ErrorBox("INPUT LOGS DO NOT HAVE SAME DEPTH SPACING");
                return;
            }
            double startMD = c2.startMD, endMD = c2.endMD;
            int    startVel = c2.startLog1, startDens = c2.startLog2;

            double[] Imp = new double[count];

            for (int i = 0; i < count; i++)
            {
                if (LogDens[i + startDens].Value.ToString() == "NaN")
                {
                    continue;
                }

                if (LogVel[i + startVel].Value.ToString() == "NaN")
                {
                    continue;
                }

                vel    = LogVel[i + startVel].Value;
                rhob   = LogDens[i + startDens].Value;
                Imp[i] = vel * rhob;
            }
            Borehole b1 = densLog.Borehole;

            using (ITransaction trans = DataManager.NewTransaction())
            {
                IPropertyVersionService pvs  = PetrelSystem.PropertyVersionService;
                ILogTemplate            glob = pvs.FindTemplateByMnemonics("Acoustic Impedance");
                PropertyVersion         pv   = pvs.FindOrCreate(glob);
                trans.Lock(b1);
                WellLog log = b1.Logs.CreateWellLog(pv);
                //log.Name = "rhoB";
                WellLogSample[] tsamples = new WellLogSample[count];

                for (int i2 = 0; i2 < count; i2++)
                {
                    double md  = startMD + i2 * c2.interval2;
                    float  val = (float)Imp[i2];
                    tsamples[i2] = new WellLogSample(md, val);
                }
                log.Samples = tsamples;
                trans.Commit();
            }
            PetrelLogger.InfoBox("The Impedance Log has been created in the same Well");
        }
Esempio n. 5
0
        public void fromimpedance()
        {
            //int count;
            //count = ImpLog.SampleCount;
            List <WellLogSample> LogImp = new List <WellLogSample>(ImpLog.Samples);
            List <WellLogSample> LogVel = new List <WellLogSample>(VelLog.Samples);

            TwoLogCheck C2    = new TwoLogCheck(ImpLog, VelLog);
            int         count = C2.count;

            if (count == 0)
            {
                PetrelLogger.ErrorBox("INPUT LOGS DO NOT HAVE SAME DEPTH SPACING");
                return;
            }
            int startImp = C2.startLog1, startVel = C2.startLog2;

            double[] rhob = new double[count];

            for (int i = 0; i < count; i++)
            {
                if (LogImp[i + startImp].Value.ToString() == "NaN")
                {
                    continue;
                }

                if (LogVel[i + startVel].Value.ToString() == "NaN")
                {
                    continue;
                }
                rhob[i] = (double)LogImp[i + startImp].Value / LogVel[i + startVel].Value;
            }
            Borehole b1 = ImpLog.Borehole;

            using (ITransaction trans = DataManager.NewTransaction())
            {
                IPropertyVersionService pvs  = PetrelSystem.PropertyVersionService;
                ILogTemplate            glob = pvs.FindTemplateByMnemonics("Density");
                PropertyVersion         pv   = pvs.FindOrCreate(glob);
                trans.Lock(b1);
                WellLog log = b1.Logs.CreateWellLog(pv);
                //log.Name = "rhoB";
                WellLogSample[] tsamples = new WellLogSample[count];
                for (int i2 = 0; i2 < count; i2++)
                {
                    double md  = C2.startMD + C2.interval1 * i2;
                    float  val = (float)rhob[i2];
                    tsamples[i2] = new WellLogSample(md, val);
                }
                log.Samples = tsamples;
                trans.Commit();
            }
            PetrelLogger.InfoBox("The Density Log has been created in the same Well");
        }
Esempio n. 6
0
        public void convertToSeismic(string fileName)
        {
            // Check if parent collection contains any 2D data
            SeismicCollection coll = (SeismicCollection)FTReciever.parent;

            while (coll.MemberType == typeof(SeismicLine2DCollection))
            {
                MessageBox.Show("The Seismic Collection you selected was of SeismicLine2DCollection");
                List <SeismicCollection> cols  = Discuss.getAllSeismicCollections();
                List <string>            names = new List <string>();
                foreach (SeismicCollection col in cols)
                {
                    names.Add(col.Name);
                }
                objSelect selector = new objSelect("Select a Seismic collection to add the cube to", names);
                if (selector.ShowDialog() == DialogResult.Cancel)
                {
                    return;
                }
                coll = cols[objSelect.SelectedIndex];
            }
            // Get Service

            ISegyFormat segyFormat = CoreSystem.GetService <ISegyFormat>();
            // Find property version
            IPropertyVersionService pvService = PetrelSystem.PropertyVersionService;
            ITemplate       seisTemplate      = PetrelUnitSystem.TemplateGroupSeismicColor.SeismicDefault;
            PropertyVersion pv   = pvService.FindOrCreate(PetrelSystem.GetGlobalPropertyVersionContainer(), seisTemplate);
            SeismicCube     cube = SeismicCube.NullObject;

            // Lock the parent
            using (ITransaction txn = DataManager.NewTransaction())
            {
                try
                {
                    txn.Lock(coll);
                    cube = segyFormat.ImportSeismic3D(fileName, (SeismicCollection)FTReciever.parent, "", Domain.ELEVATION_DEPTH, pv);
                }
                catch (InvalidOperationException e)
                {
                    MessageBox.Show(e.Message);
                }
                finally
                {
                    txn.Commit();
                }
            }
        }
Esempio n. 7
0
        public void FromGamma()
        {
            int count;

            count = grLog.SampleCount;
            List <WellLogSample> LogGr = new List <WellLogSample>(grLog.Samples);

            double[] vsh = new double[count];
            double[] Gr  = new double[count];
            for (int i = 0; i < count; i++)
            {
                Gr[i]  = LogGr[i].Value;
                vsh[i] = (LogGr[i].Value - Gr0) / (Gr100 - Gr0);
            }
            double max = 0, min = 0;

            for (int k = 0; k < count; k++)
            {
                max = Math.Max(Gr[k], max);
                min = Math.Min(Gr[k], min);
            }

            Borehole b1 = grLog.Borehole;

            using (ITransaction trans = DataManager.NewTransaction())
            {
                IPropertyVersionService pvs  = PetrelSystem.PropertyVersionService;
                ILogTemplate            glob = pvs.FindTemplateByMnemonics("VShale");
                PropertyVersion         pv   = pvs.FindOrCreate(glob);
                trans.Lock(b1);
                WellLog log = b1.Logs.CreateWellLog(pv);

                WellLogSample[] tsamples = new WellLogSample[count];
                for (int i2 = 0; i2 < count; i2++)
                {
                    double md  = LogGr[i2].MD;
                    float  val = (float)vsh[i2];
                    tsamples[i2] = new WellLogSample(md, val);
                }
                log.Samples = tsamples;
                trans.Commit();
            }
            PetrelLogger.InfoBox("The Shale Volume Fraction Log has been created in the same Well");
        }
Esempio n. 8
0
        public void FromDensity2()
        {
            int count = densLog.SampleCount;

            List <WellLogSample> LogDens = new List <WellLogSample>(densLog.Samples);
            Velocity             V1      = new Velocity(densLog);

            V1.GCoef = GCoef;
            V1.GExp  = GExp;
            V1.FromDensity();
            double[] Imp = new double[count];

            for (int i = 0; i < count; i++)
            {
                rhob   = LogDens[i].Value;
                Imp[i] = V1.vel[i] * rhob;
            }

            Borehole b1 = densLog.Borehole;

            using (ITransaction trans = DataManager.NewTransaction())
            {
                IPropertyVersionService pvs  = PetrelSystem.PropertyVersionService;
                ILogTemplate            glob = pvs.FindTemplateByMnemonics("Acoustic Impedance");
                PropertyVersion         pv   = pvs.FindOrCreate(glob);
                trans.Lock(b1);
                WellLog log = b1.Logs.CreateWellLog(pv);
                //log.Name = "rhoB";
                WellLogSample[] tsamples = new WellLogSample[count];

                for (int i2 = 0; i2 < count; i2++)
                {
                    double md  = LogDens[i2].MD;
                    float  val = (float)Imp[i2];
                    tsamples[i2] = new WellLogSample(md, val);
                }
                log.Samples = tsamples;
                trans.Commit();
            }
            PetrelLogger.InfoBox("The Impedance Log has been created in the same Well");
        }
        public void FromAcImp()
        {
            int count;

            count = AcImpLog.SampleCount;
            List <WellLogSample> LogAcImp = new List <WellLogSample>(AcImpLog.Samples);

            double[] RC = new double[count];

            for (int i = 0; i < count; i++)
            {
                if (i != count - 1)
                {
                    RC[i] = (LogAcImp[i + 1].Value - LogAcImp[i].Value) / (LogAcImp[i + 1].Value + LogAcImp[i].Value);
                }
            }
            Borehole b1 = AcImpLog.Borehole;

            using (ITransaction trans = DataManager.NewTransaction())
            {
                IPropertyVersionService pvs  = PetrelSystem.PropertyVersionService;
                ILogTemplate            glob = pvs.FindTemplateByMnemonics("Reflection coefficients");
                PropertyVersion         pv   = pvs.FindOrCreate(glob);
                trans.Lock(b1);
                WellLog log = b1.Logs.CreateWellLog(pv);
                //log.Name = "rhoB";
                WellLogSample[] tsamples = new WellLogSample[count];
                for (int i2 = 0; i2 < count; i2++)
                {
                    double md  = LogAcImp[i2].MD;
                    float  val = (float)RC[i2];
                    tsamples[i2] = new WellLogSample(md, val);
                }
                log.Samples = tsamples;
                trans.Commit();
            }
            PetrelLogger.InfoBox("The Reflection coefficient Log has been created in the same Well");
        }
Esempio n. 10
0
        public void fromvelocity()
        {
            int count;
            List <WellLogSample> LogVel = new List <WellLogSample>(velLog.Samples);

            count = velLog.SampleCount;

            double[] rhob = new double[count];

            for (int i = 0; i < count; i++)
            {
                vel     = (double)LogVel[i].Value;
                rhob[i] = 1000.0d * gcoef * Math.Pow(vel, gexp);
            }
            Borehole b1 = velLog.Borehole;

            using (ITransaction trans = DataManager.NewTransaction())
            {
                IPropertyVersionService pvs  = PetrelSystem.PropertyVersionService;
                ILogTemplate            glob = pvs.FindTemplateByMnemonics("Density");
                PropertyVersion         pv   = pvs.FindOrCreate(glob);
                trans.Lock(b1);
                WellLog log = b1.Logs.CreateWellLog(pv);
                //log.Name = "rhoB";
                WellLogSample[] tsamples = new WellLogSample[count];
                for (int i2 = 0; i2 < count; i2++)
                {
                    double md  = LogVel[i2].MD;
                    float  val = (float)rhob[i2];
                    tsamples[i2] = new WellLogSample(md, val);
                }
                log.Samples = tsamples;
                trans.Commit();
            }
            PetrelLogger.InfoBox("The Density Log has been created in the same Well");
        }
Esempio n. 11
0
        public void FromSP()
        {
            int count;

            count = spLog.SampleCount;
            List <WellLogSample> LogSp = new List <WellLogSample>(spLog.Samples);

            double[] vsh = new double[count];
            double[] Sp  = new double[count];
            for (int i = 0; i < count; i++)
            {
                Sp[i]  = LogSp[i].Value;
                vsh[i] = (LogSp[i].Value - Sp0) / (Sp100 - Sp0);
            }
            Borehole b1 = spLog.Borehole;

            using (ITransaction trans = DataManager.NewTransaction())
            {
                IPropertyVersionService pvs  = PetrelSystem.PropertyVersionService;
                ILogTemplate            glob = pvs.FindTemplateByMnemonics("VShale");
                PropertyVersion         pv   = pvs.FindOrCreate(glob);
                trans.Lock(b1);
                WellLog log = b1.Logs.CreateWellLog(pv);

                WellLogSample[] tsamples = new WellLogSample[count];
                for (int i2 = 0; i2 < count; i2++)
                {
                    double md  = LogSp[i2].MD;
                    float  val = (float)vsh[i2];
                    tsamples[i2] = new WellLogSample(md, val);
                }
                log.Samples = tsamples;
                trans.Commit();
            }
            PetrelLogger.InfoBox("The Shale Volume Fraction Log has been created in the same Well");
        }
Esempio n. 12
0
        public void FromDensity()
        {
            //int count;
            //count = Math.Min(densLog.SampleCount, vshLog.SampleCount);
            //count = Math.Min(count, swLog.SampleCount);

            List <WellLogSample> LogDens = new List <WellLogSample>(densLog.Samples);
            List <WellLogSample> LogSw   = new List <WellLogSample>(swLog.Samples);
            List <WellLogSample> LogVsh  = new List <WellLogSample>(vshLog.Samples);

            ThreeLogCheck C1    = new ThreeLogCheck(densLog, swLog, vshLog);
            int           count = C1.count;

            if (count == 0)
            {
                PetrelLogger.ErrorBox("INPUT LOGS DO NOT HAVE SAME DEPTH SPACING");
                return;
            }
            int startDens = C1.startLog1, startSw = C1.startLog2, startVsh = C1.startLog3;

            double[] phie = new double[count];

            for (int i = 0; i < count; i++)
            {
                if (LogDens[i + startDens].Value.ToString() == "NaN")
                {
                    continue;
                }

                if (LogSw[i + startSw].Value.ToString() == "NaN")
                {
                    continue;
                }

                if (LogVsh[i + startVsh].Value.ToString() == "NaN")
                {
                    continue;
                }

                dens    = (double)LogDens[i + startDens].Value;
                sw      = (double)LogSw[i + startSw].Value;
                vsh     = (double)LogVsh[i + startVsh].Value;
                rhof    = sw * rhow + (1 - sw) * rhoh;
                phie[i] = (dens - (1 - vsh) * rhomat - vsh * rhosh) / (rhof - rhomat - vsh * rhosh);
            }

            Borehole b1 = densLog.Borehole;

            using (ITransaction trans = DataManager.NewTransaction())
            {
                IPropertyVersionService pvs  = PetrelSystem.PropertyVersionService;
                ILogTemplate            glob = pvs.FindTemplateByMnemonics("Porosity");
                PropertyVersion         pv   = pvs.FindOrCreate(glob);
                trans.Lock(b1);
                WellLog log = b1.Logs.CreateWellLog(pv);
                //log.Name = "rhoB";
                WellLogSample[] tsamples = new WellLogSample[count];
                for (int i2 = 0; i2 < count; i2++)
                {
                    double md  = C1.startMD + i2 * C1.interval1;
                    float  val = (float)phie[i2];
                    tsamples[i2] = new WellLogSample(md, val);
                }
                log.Samples = tsamples;
                trans.Commit();
            }
            PetrelLogger.InfoBox("The Porosity Log has been created in the same Well");
        }
Esempio n. 13
0
        public void FromPorosity2()
        {
            //int count;
            //count = Math.Min(porLog.SampleCount, vshLog.SampleCount);
            //count = Math.Min(count, swLog.SampleCount);

            List <WellLogSample> LogPhie = new List <WellLogSample>(porLog.Samples);
            List <WellLogSample> LogSw   = new List <WellLogSample>(swLog.Samples);
            List <WellLogSample> LogVsh  = new List <WellLogSample>(vshLog.Samples);
            ThreeLogCheck        C1      = new ThreeLogCheck(porLog, swLog, vshLog);
            int count = C1.count;

            if (count == 0)
            {
                PetrelLogger.ErrorBox("INPUT LOGS DO NOT HAVE SAME DEPTH SPACING");
                return;
            }
            int startPor = C1.startLog1, startSw = C1.startLog2, startVsh = C1.startLog3;

            double[] vel = new double[count];

            for (int i = 0; i < count; i++)
            {
                if (LogPhie[i + startPor].Value.ToString() == "NaN")
                {
                    continue;
                }

                if (LogSw[i + startSw].Value.ToString() == "NaN")
                {
                    continue;
                }

                if (LogVsh[i + startVsh].Value.ToString() == "NaN")
                {
                    continue;
                }

                phie   = (double)LogPhie[i + startPor].Value;
                sw     = (double)LogSw[i + startSw].Value;
                vsh    = (double)LogVsh[i + startVsh].Value;
                c      = vsh / (1 - phie);
                vf     = sw / dtw + (1 - sw) / dth;
                vm     = c / dtsh + (1 - c) / dtmat;
                vel[i] = Math.Pow((1 - phie), 2) * vm + phie * vf;
                //vel[i] = 1 / dt;
            }

            Borehole b1 = porLog.Borehole;

            using (ITransaction trans = DataManager.NewTransaction())
            {
                IPropertyVersionService pvs  = PetrelSystem.PropertyVersionService;
                ILogTemplate            glob = pvs.FindTemplateByMnemonics("Velocity");
                PropertyVersion         pv   = pvs.FindOrCreate(glob);
                trans.Lock(b1);
                WellLog log = b1.Logs.CreateWellLog(pv);
                //log.Name = "rhoB";
                WellLogSample[] tsamples = new WellLogSample[count];
                for (int i2 = 0; i2 < count; i2++)
                {
                    double md  = C1.startMD + C1.interval1 * i2;
                    float  val = (float)vel[i2];
                    tsamples[i2] = new WellLogSample(md, val);
                }
                log.Samples = tsamples;
                trans.Commit();
            }
            PetrelLogger.InfoBox("The Velocity Log has been created in the same Well");
        }
        private void button2_Click(object sender, EventArgs e)
        {
            PetrelLogger.InfoOutputWindow("Generating array for edited cube");
            float[, ,] newVal = new float[scube.NumSamplesIJK.I, scube.NumSamplesIJK.J, scube.NumSamplesIJK.K];
            double min_newVal = 10e+16;
            double max_newVal = 10e-16;

            using (IProgress i1 = PetrelLogger.NewProgress(1, scube.NumSamplesIJK.I))
            {
                for (int ii = 0; ii < scube.NumSamplesIJK.I; ii++)
                {
                    for (int jj = 0; jj < scube.NumSamplesIJK.J; jj++)
                    {
                        for (int kk = 0; kk < scube.NumSamplesIJK.K; kk++)
                        {
                            newVal[ii, jj, kk] = (float)sr.Function(ii, jj, kk, vals[ii, jj, kk]);
                            if (newVal[ii, jj, kk] < min_newVal)
                            {
                                min_newVal = (double)newVal[ii, jj, kk];
                            }
                            if (newVal[ii, jj, kk] > max_newVal)
                            {
                                max_newVal = (double)newVal[ii, jj, kk];
                            }
                        }
                    }
                    i1.ProgressStatus = ii + 1;
                }
            }
            using (ITransaction txn = DataManager.NewTransaction())
            {
                try
                {
                    txn.Lock(scube.SeismicCollection);
                    Index3       size      = new Index3(scube.NumSamplesIJK.I, scube.NumSamplesIJK.J, scube.NumSamplesIJK.K);
                    IndexDouble3 tempindex = new IndexDouble3(0, 0, 0);
                    Point3       origin    = scube.PositionAtIndex(tempindex);

                    double d1, d2, d3;

                    d1 = scube.PositionAtIndex(new IndexDouble3(1, 0, 0)).X - origin.X;
                    d2 = scube.PositionAtIndex(new IndexDouble3(1, 0, 0)).Y - origin.Y;
                    d3 = scube.PositionAtIndex(new IndexDouble3(1, 0, 0)).Z - origin.Z;
                    Vector3 iVec = new Vector3(d1, d2, d3);

                    d1 = scube.PositionAtIndex(new IndexDouble3(0, 1, 0)).X - origin.X;
                    d2 = scube.PositionAtIndex(new IndexDouble3(0, 1, 0)).Y - origin.Y;
                    d3 = scube.PositionAtIndex(new IndexDouble3(0, 1, 0)).Z - origin.Z;
                    Vector3 jVec = new Vector3(d1, d2, d3);

                    d1 = scube.PositionAtIndex(new IndexDouble3(0, 0, 1)).X - origin.X;
                    d2 = scube.PositionAtIndex(new IndexDouble3(0, 0, 1)).Y - origin.Y;
                    d3 = scube.PositionAtIndex(new IndexDouble3(0, 0, 1)).Z - origin.Z;
                    Vector3 kVec = new Vector3(d1, d2, d3);

                    if (scube.SeismicCollection.CanCreateSeismicCube(size, origin, iVec, jVec, kVec))
                    {
                        Type   dataType              = typeof(float);
                        Domain vDomain               = scube.Domain;
                        IPropertyVersionService pvs  = PetrelSystem.PropertyVersionService;
                        ILogTemplate            glob = pvs.FindTemplateByMnemonics("Seismic");
                        PropertyVersion         pv   = pvs.FindOrCreate(glob);
                        Range1 <double>         r    = new Range1 <double>(min_newVal, max_newVal);
                        PetrelLogger.InfoOutputWindow("OUTPUT TEMPLATE UNDER PROCESS");
                        try
                        {
                            newCube = scube.SeismicCollection.CreateSeismicCube(size, origin, iVec, jVec, kVec, dataType, vDomain, pv, r);
                            PetrelLogger.InfoOutputWindow("OUTPUT CUBE  TEMPLATE Construction completed");
                        }
                        catch (System.InvalidOperationException e1)
                        {
                            PetrelLogger.ErrorBox(e1.Message);
                        }
                        catch (System.ArgumentNullException e1)
                        {
                            PetrelLogger.InfoOutputWindow(e1.Message);
                        }
                    }
                    newCube.Name = cubename.Text;
                    if (newCube.IsWritable)
                    {
                        txn.Lock(newCube);
                        PetrelLogger.InfoOutputWindow("Writing Data in the new cube");
                        Index3   start = new Index3(0, 0, 0);
                        Index3   end   = new Index3(newCube.NumSamplesIJK.I - 1, newCube.NumSamplesIJK.J - 1, newCube.NumSamplesIJK.K - 1);
                        ISubCube to    = newCube.GetSubCube(start, end);
                        to.CopyFrom(newVal);
                        txn.Commit();
                    }
                }
                catch (ArgumentNullException e2)
                {
                    PetrelLogger.ErrorBox("Seismic cube name or propertyVersion can not be blank (null)" + e2.Message);
                }
            }
        }
Esempio n. 15
0
        //double[] LogPhie, LogSw, LogVsh;
        //WellLog LogType4;

        public void fromporosity()
        {
            //int count;
            //count = porLog.SampleCount;
            List <WellLogSample> LogPhie = new List <WellLogSample>(porLog.Samples);
            List <WellLogSample> LogSw   = new List <WellLogSample>(swLog.Samples);
            List <WellLogSample> LogVsh  = new List <WellLogSample>(vshLog.Samples);
            //List<WellLogSample> LogRhob = new List<WellLogSample>(LogType4.Samples);

            ThreeLogCheck C1    = new ThreeLogCheck(porLog, swLog, vshLog);
            int           count = C1.count;

            if (count == 0)
            {
                PetrelLogger.ErrorBox("INPUT LOGS DO NOT HAVE SAME DEPTH SPACING");
                return;
            }
            int startPor = C1.startLog1, startSw = C1.startLog2, startVsh = C1.startLog3;

            double[] rhob = new double[count];

            for (int i = 0; i < count; i++)
            {
                if (LogPhie[i + startPor].Value.ToString() == "NaN")
                {
                    continue;
                }

                if (LogSw[i + startSw].Value.ToString() == "NaN")
                {
                    continue;
                }

                if (LogVsh[i + startVsh].Value.ToString() == "NaN")
                {
                    continue;
                }

                phie    = (double)LogPhie[i + startPor].Value;
                sw      = (double)LogSw[i + startSw].Value;
                vsh     = (double)LogVsh[i + startVsh].Value;
                rhof    = sw * rhow + (1 - sw) * rhoh;
                rhom    = vsh * rhosh + (1 - vsh - phie) * rhomat;
                rhob[i] = phie * rhof + rhom;
                //PetrelLogger.InfoOutputWindow(rhob.ToString());
                //LogRhob[count].Value = (float)rhob;
            }
            Borehole b1 = porLog.Borehole;

            using (ITransaction trans = DataManager.NewTransaction())
            {
                IPropertyVersionService pvs  = PetrelSystem.PropertyVersionService;
                ILogTemplate            glob = pvs.FindTemplateByMnemonics("Density");
                PropertyVersion         pv   = pvs.FindOrCreate(glob);
                trans.Lock(b1);
                WellLog log = b1.Logs.CreateWellLog(pv);
                //log.Name = "rhoB";
                WellLogSample[] tsamples = new WellLogSample[count];
                for (int i2 = 0; i2 < count; i2++)
                {
                    double md  = C1.startMD + C1.interval1 * i2;
                    float  val = (float)rhob[i2];
                    tsamples[i2] = new WellLogSample(md, val);
                }
                log.Samples = tsamples;
                trans.Commit();
            }
            PetrelLogger.InfoBox("The Density Log has been created in the same Well");
        }
Esempio n. 16
0
        public void workingFunction()
        {
            List <WellLogSample> den = new List <WellLogSample>(density.Samples);
            List <WellLogSample> dt  = new List <WellLogSample>(sonic.Samples);

            if (den.Count == 0 || dt.Count == 0)
            {
                PetrelLogger.ErrorBox("NULL LOG found");
                return;
            }
            Console.WriteLine(den.Count);
            Console.WriteLine(dt.Count);

            int    i;
            double startMD, endMD;
            int    startden = 0,
                   endden   = 0,
                   startdt  = 0,
                   enddt    = 0;

            int    count     = 0;
            double interval1 = den[1].MD - den[0].MD;
            double interval2 = dt[1].MD - dt[0].MD;

            if (Math.Abs(interval1 - interval2) > 10e-4)
            {
                PetrelLogger.ErrorBox("DEPTH INTERVAL MISMATCH");
                return;
            }
            double interval = interval1;

            if (!(Math.Abs(den[0].MD - dt[0].MD) < 10e-4 && Math.Abs(den[den.Count - 1].MD - dt[dt.Count - 1].MD) < 10e-4))
            {
                if (den[0].MD > dt[0].MD)
                {
                    startMD = den[0].MD;
                }
                else
                {
                    startMD = dt[0].MD;
                }
                if (den[den.Count - 1].MD > dt[dt.Count - 1].MD)
                {
                    endMD = dt[dt.Count - 1].MD;
                }
                else
                {
                    endMD = den[den.Count].MD;
                }
                for (int xxx = 0; xxx < den.Count; xxx++)
                {
                    if (Math.Abs(den[xxx].MD - startMD) < 10e-4)
                    {
                        startden = xxx;
                    }
                    if (Math.Abs(den[xxx].MD - endMD) < 10e-4)
                    {
                        endden = xxx;
                    }
                }
                for (int xxx = 0; xxx < dt.Count; xxx++)
                {
                    if (Math.Abs(dt[xxx].MD - startMD) < 10e-4)
                    {
                        startdt = xxx;
                    }
                    if (Math.Abs(dt[xxx].MD - endMD) < 10e-4)
                    {
                        enddt = xxx;
                    }
                }
                count = endden - startden + 1;
            }
            else
            {
                count   = den.Count;
                startMD = den[0].MD;
                endMD   = den[den.Count - 1].MD;
            }


            float[] C2     = new float[count];
            float[] S2     = new float[count];
            float[] phi2   = new float[count];
            float[] error1 = new float[count];


            using (IProgress i1 = PetrelLogger.NewProgress(1, count))
            {
                for (i = 0; i < count; i++)
                {
                    float ac_imp;
                    if (den[i + startden].Value.ToString() == "NaN")
                    {
                        continue;
                    }
                    if (dt[i + startdt].Value.ToString() == "NaN")
                    {
                        continue;
                    }
                    float rho  = den[i + startden].Value;
                    float son  = dt[i + startdt].Value;
                    float Vinv = 1.0f / son;
                    ac_imp    = rho * Vinv;
                    error1[i] = 1.0e35f;
                    for (float phi = (float)minPor; phi <= (float)(maxPor + 0.1); phi += 0.1f)
                    {
                        for (float S = (float)minWater; S <= (float)(maxWater + 0.1); S += 0.1f)
                        {
                            for (float C = (float)minClay; C <= (float)(maxClay + 0.1); C += 0.1f)
                            {
                                double error = dfunc(ac_imp, rho, Vinv, C, S, phi);
                                if (error1[i] > (float)error)
                                {
                                    C2[i]     = C;
                                    S2[i]     = S;
                                    phi2[i]   = phi;
                                    error1[i] = (float)error;
                                }
                            }
                        }
                    }
                    updateVals(ac_imp, rho, Vinv, ref C2[i], ref S2[i], ref phi2[i]);
                    i1.ProgressStatus = i + 1;
                }
            }
            b1 = density.Borehole;
            using (ITransaction trans = DataManager.NewTransaction())
            {
                IPropertyVersionService pvs  = PetrelSystem.PropertyVersionService;
                ILogTemplate            glob = pvs.FindTemplateByMnemonics("Porosity");
                PropertyVersion         pv   = pvs.FindOrCreate(glob);
                trans.Lock(b1);
                WellLog         log      = b1.Logs.CreateWellLog(pv);
                WellLogSample[] tsamples = new WellLogSample[count];
                for (int i2 = 0; i2 < count; i2++)
                {
                    double md  = startMD + i2 * interval;
                    float  val = phi2[i2];
                    tsamples[i2] = new WellLogSample(md, val);
                }
                log.Samples = tsamples;
                trans.Commit();
            }
            using (ITransaction trans = DataManager.NewTransaction())
            {
                IPropertyVersionService pvs  = PetrelSystem.PropertyVersionService;
                ILogTemplate            glob = pvs.FindTemplateByMnemonics(clayLog);
                PropertyVersion         pv   = pvs.FindOrCreate(glob);
                trans.Lock(b1);
                WellLog         log      = b1.Logs.CreateWellLog(pv);
                WellLogSample[] tsamples = new WellLogSample[count];
                for (int i2 = 0; i2 < count; i2++)
                {
                    double md  = startMD + i2 * interval;
                    float  val = C2[i2];
                    tsamples[i2] = new WellLogSample(md, val);
                }
                log.Samples = tsamples;
                trans.Commit();
            }
            using (ITransaction trans = DataManager.NewTransaction())
            {
                IPropertyVersionService pvs  = PetrelSystem.PropertyVersionService;
                ILogTemplate            glob = pvs.FindTemplateByMnemonics(waterLog);

                PropertyVersion pv = pvs.FindOrCreate(glob);
                trans.Lock(b1);
                WellLog         log      = b1.Logs.CreateWellLog(pv);
                WellLogSample[] tsamples = new WellLogSample[count];
                for (int i2 = 0; i2 < count; i2++)
                {
                    double md  = startMD + i2 * interval;
                    float  val = S2[i2];
                    tsamples[i2] = new WellLogSample(md, val);
                }
                log.Samples = tsamples;
                trans.Commit();
            }
        }
Esempio n. 17
0
        public void workingFunction()
        {
            maincomboIndex = 0;
            SeismicRoot    seismicRoot = SeismicRoot.Get(PetrelProject.PrimaryProject);
            SeismicProject proj        = seismicRoot.SeismicProject;


            float[, ,] phi2 = new float[cubeDensity.NumSamplesIJK.I, cubeDensity.NumSamplesIJK.J, cubeDensity.NumSamplesIJK.K];
            float[, ,] S2   = new float[cubeDensity.NumSamplesIJK.I, cubeDensity.NumSamplesIJK.J, cubeDensity.NumSamplesIJK.K];
            float[, ,] C2   = new float[cubeDensity.NumSamplesIJK.I, cubeDensity.NumSamplesIJK.J, cubeDensity.NumSamplesIJK.K];
            float minphi2 = 1.0f;
            float maxphi2 = 0.0f;
            float minC2   = 1.0f;
            float maxC2   = 0.0f;
            float minS2   = 1.0f;
            float maxS2   = 0.0f;

            using (ITransaction txn = DataManager.NewTransaction())
            {
                try
                {
                    using (IProgress i1 = PetrelLogger.NewProgress(1, cubeDensity.NumSamplesIJK.J))
                    {
                        for (int p = 0; p < cubeDensity.NumSamplesIJK.I; p++)
                        {
                            for (int q = 0; q < cubeDensity.NumSamplesIJK.J; q++)
                            {
                                ITrace trace1 = cubeDensity.GetTrace(p, q);
                                ITrace trace2 = cubeSonic.GetTrace(p, q);
                                //ITrace tracePor = PHI_CUBE.GetTrace(p, q);
                                //ITrace traceSw = SW_CUBE.GetTrace(p, q);
                                //ITrace traceVSh = VSHALE_CUBE.GetTrace(p, q);
                                for (int k = 0; k < trace1.Length; k++)
                                {
                                    double sample1 = trace1[k];
                                    double sample2 = trace2[k];
                                    float  rho     = (float)sample1;
                                    float  Vinv    = (float)(1.0 / sample2);
                                    float  ac_imp  = rho * Vinv;
                                    float  error1  = 100e30f;

                                    for (float phi = (float)minPor; phi <= (float)(maxPor + 0.1); phi += 0.1f)
                                    {
                                        for (float S = (float)minWater; S <= (float)(maxWater + 0.1); S += 0.1f)
                                        {
                                            for (float C = (float)minClay; C <= (float)(maxClay + 0.1); C += 0.1f)
                                            {
                                                double error = dfunc(ac_imp, rho, Vinv, C, S, phi);
                                                if (error1 > (float)error)
                                                {
                                                    C2[p, q, k]   = C;
                                                    S2[p, q, k]   = S;
                                                    phi2[p, q, k] = phi;
                                                    error1        = (float)error;
                                                }
                                            }
                                        }
                                    }
                                    updateVals(ac_imp, rho, Vinv, ref C2[p, q, k], ref S2[p, q, k], ref phi2[p, q, k]);
                                    if (phi2[p, q, k] < minphi2)
                                    {
                                        minphi2 = phi2[p, q, k];
                                    }
                                    if (phi2[p, q, k] > maxphi2)
                                    {
                                        maxphi2 = phi2[p, q, k];
                                    }
                                    if (C2[p, q, k] < minC2)
                                    {
                                        minC2 = C2[p, q, k];
                                    }
                                    if (C2[p, q, k] > maxC2)
                                    {
                                        maxC2 = C2[p, q, k];
                                    }
                                    if (S2[p, q, k] < minS2)
                                    {
                                        minS2 = S2[p, q, k];
                                    }
                                    if (S2[p, q, k] > maxS2)
                                    {
                                        maxS2 = S2[p, q, k];
                                    }
                                }
                            }
                            i1.ProgressStatus = p + 1;
                        }
                    }
                    txn.Lock(proj);
                    txn.Lock(scol);
                    Index3       size      = new Index3(cubeDensity.NumSamplesIJK.I, cubeDensity.NumSamplesIJK.J, cubeDensity.NumSamplesIJK.K);
                    IndexDouble3 tempindex = new IndexDouble3(0, 0, 0);
                    Point3       origin    = cubeDensity.PositionAtIndex(tempindex);

                    double d1, d2, d3;

                    d1 = cubeDensity.PositionAtIndex(new IndexDouble3(1, 0, 0)).X - origin.X;
                    d2 = cubeDensity.PositionAtIndex(new IndexDouble3(1, 0, 0)).Y - origin.Y;
                    d3 = cubeDensity.PositionAtIndex(new IndexDouble3(1, 0, 0)).Z - origin.Z;
                    Vector3 iVec = new Vector3(d1, d2, d3);

                    d1 = cubeDensity.PositionAtIndex(new IndexDouble3(0, 1, 0)).X - origin.X;
                    d2 = cubeDensity.PositionAtIndex(new IndexDouble3(0, 1, 0)).Y - origin.Y;
                    d3 = cubeDensity.PositionAtIndex(new IndexDouble3(0, 1, 0)).Z - origin.Z;
                    Vector3 jVec = new Vector3(d1, d2, d3);

                    d1 = cubeDensity.PositionAtIndex(new IndexDouble3(0, 0, 1)).X - origin.X;
                    d2 = cubeDensity.PositionAtIndex(new IndexDouble3(0, 0, 1)).Y - origin.Y;
                    d3 = cubeDensity.PositionAtIndex(new IndexDouble3(0, 0, 1)).Z - origin.Z;
                    Vector3 kVec = new Vector3(d1, d2, d3);


                    /*double inlineI = (cubeDensity.Lattice.Single.SpacingI) * Math.Sin(cubeDensity.Lattice.Single.RotationJ);
                     * double inlineJ = (cubeDensity.Lattice.Single.SpacingI) * Math.Cos(cubeDensity.Lattice.Single.RotationJ);
                     * double crosslineI = (cubeDensity.Lattice.Single.SpacingJ) * Math.Sin(cubeDensity.Lattice.Single.RotationJ);
                     * double crosslineJ = (cubeDensity.Lattice.Single.SpacingJ) * -Math.Cos(cubeDensity.Lattice.Single.RotationJ);
                     * Vector3 iSpacing = new Vector3(inlineJ, inlineI, 0.0);
                     * Vector3 jSpacing = new Vector3(crosslineI, crosslineJ, 0.0);
                     * Vector3 kSpacing = new Vector3(0.0, 0.0, 3.048);
                     */
                    if (scol.CanCreateSeismicCube(size, origin, iVec, jVec, kVec))
                    {
                        Type   dataType              = typeof(float);
                        Domain vDomain               = cubeDensity.Domain;
                        IPropertyVersionService pvs  = PetrelSystem.PropertyVersionService;
                        ILogTemplate            glob = pvs.FindTemplateByMnemonics("Seismic");
                        PropertyVersion         pv   = pvs.FindOrCreate(glob);
                        //PropertyVersion pv = cubeDensity.PropertyVersion;
                        Range1 <double> r1 = new Range1 <double>(minphi2, maxphi2);
                        Range1 <double> r2 = new Range1 <double>(minS2, maxS2);
                        Range1 <double> r3 = new Range1 <double>(minC2, maxC2);
                        PetrelLogger.InfoOutputWindow("OUTPUT TEMPLATE UNDER PROCESS");
                        try
                        {
                            PHI_CUBE    = scol.CreateSeismicCube(size, origin, iVec, jVec, kVec, dataType, vDomain, pv, r1);
                            SW_CUBE     = scol.CreateSeismicCube(size, origin, iVec, jVec, kVec, dataType, vDomain, pv, r2);
                            VSHALE_CUBE = scol.CreateSeismicCube(size, origin, iVec, jVec, kVec, dataType, vDomain, pv, r3);
                        }
                        catch (System.InvalidOperationException e)
                        {
                            PetrelLogger.ErrorBox(e.Message);
                        }
                        catch (System.ArgumentNullException e)
                        {
                            PetrelLogger.InfoOutputWindow(e.Message);
                        }
                    }

                    PHI_CUBE.Name    = porCube;
                    SW_CUBE.Name     = waterCube;
                    VSHALE_CUBE.Name = clayCube;

                    if (PHI_CUBE.IsWritable)
                    {
                        using (ITransaction txn1 = DataManager.NewTransaction())
                        {
                            PetrelLogger.InfoOutputWindow("Writing Data in the Porosity cube");
                            Index3   start = new Index3(0, 0, 0);
                            Index3   end   = new Index3(cubeDensity.NumSamplesIJK.I - 1, cubeDensity.NumSamplesIJK.J - 1, cubeDensity.NumSamplesIJK.K - 1);
                            ISubCube to    = cubeDensity.GetSubCube(start, end);
                            to.CopyFrom(phi2);
                            txn1.Commit();
                        }
                    }
                    if (SW_CUBE.IsWritable)
                    {
                        using (ITransaction txn1 = DataManager.NewTransaction())
                        {
                            PetrelLogger.InfoOutputWindow("Writing Data in the Water Saturation cube");
                            Index3   start = new Index3(0, 0, 0);
                            Index3   end   = new Index3(cubeDensity.NumSamplesIJK.I - 1, cubeDensity.NumSamplesIJK.J - 1, cubeDensity.NumSamplesIJK.K - 1);
                            ISubCube to    = cubeDensity.GetSubCube(start, end);
                            to.CopyFrom(S2);
                            txn1.Commit();
                        }
                    }
                    if (VSHALE_CUBE.IsWritable)
                    {
                        using (ITransaction txn1 = DataManager.NewTransaction())
                        {
                            PetrelLogger.InfoOutputWindow("Writing Data in the Shale Volume cube");
                            Index3   start = new Index3(0, 0, 0);
                            Index3   end   = new Index3(cubeDensity.NumSamplesIJK.I - 1, cubeDensity.NumSamplesIJK.J - 1, cubeDensity.NumSamplesIJK.K - 1);
                            ISubCube to    = cubeDensity.GetSubCube(start, end);
                            to.CopyFrom(C2);
                            txn1.Commit();
                        }
                    }
                    txn.Commit();
                    PetrelLogger.InfoOutputWindow("OUTPUT CUBES' Construction completed");
                }

                catch (ArgumentNullException e)
                {
                    PetrelLogger.ErrorBox("Seismic cube name or propertyVersion can not be blank (null)" + e.Message);
                }
            }
        }
Esempio n. 18
0
        public void FromNeutron()
        {
            //int count;
            //count = GnLog.SampleCount;

            //count=Math.Min(GnLog.SampleCount, vshLog.SampleCount);

            List <WellLogSample> LogGn  = new List <WellLogSample>(GnLog.Samples);
            List <WellLogSample> LogVsh = new List <WellLogSample>(vshLog.Samples);

            TwoLogCheck C4    = new TwoLogCheck(GnLog, vshLog);
            int         count = C4.count;

            if (count == 0)
            {
                PetrelLogger.ErrorBox("INPUT LOGS DO NOT HAVE SAME DEPTH SPACING");
                return;
            }
            int startGn = C4.startLog1, startVsh = C4.startLog2;

            double[] phie = new double[count];

            for (int i = 0; i < count; i++)
            {
                if (LogGn[i + startGn].Value.ToString() == "NaN")
                {
                    continue;
                }

                if (LogVsh[i + startVsh].Value.ToString() == "NaN")
                {
                    continue;
                }

                Gn      = (double)LogGn[i + startGn].Value;
                vsh     = (double)LogVsh[i + startVsh].Value;
                phie[i] = Gn - vsh * Gnsh * 100;
            }

            Borehole b1 = vshLog.Borehole;

            using (ITransaction trans = DataManager.NewTransaction())
            {
                IPropertyVersionService pvs  = PetrelSystem.PropertyVersionService;
                ILogTemplate            glob = pvs.FindTemplateByMnemonics("Porosity");
                PropertyVersion         pv   = pvs.FindOrCreate(glob);
                trans.Lock(b1);
                WellLog log = b1.Logs.CreateWellLog(pv);
                //log.Name = "rhoB";
                WellLogSample[] tsamples = new WellLogSample[count];
                for (int i2 = 0; i2 < count; i2++)
                {
                    double md  = C4.startMD + i2 * C4.interval1;
                    float  val = (float)phie[i2];
                    tsamples[i2] = new WellLogSample(md, val);
                }
                log.Samples = tsamples;
                trans.Commit();
            }
            PetrelLogger.InfoBox("The Porosity Log has been created in the same Well");
        }