HibisciDai 主页关于我归档标签分类相册
白云凹陷珠江组-恩平组高温高压低渗气层测井评价-软件核心代码
|测井计算
字数总计: 3.4k|阅读时长: 20 分钟

白云凹陷珠江组-恩平组高温高压低渗气层测井评价-软件核心代码

白云凹陷珠江组-恩平组高温高压低渗气层测井评价-软件核心代码

简介

本文有关《白云凹陷珠江组-恩平组高温高压低渗气层测井评价》附录1软件核心代码展示；

内容仅供学习参考，引用参考请标明本文代码来源，对本文代码进行恶意盗用或占用知识产权，本人及团队追究其法律责任。

泥质含量计算关键源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
public double VSHCal0()
{
double GR = this._gr.Value;
double VSH = -9999.99;
double IGR = (GR - this._grmin) / (this._grmax - this._grmin);

VSH = (Math.Pow(2, this._gcur * IGR) - 1) / (Math.Pow(2, this._gcur) - 1) * 100;

return VSH;
}

public double VSHCal1()
{
double GR = this._gr.Value;
double VSH = -9999.99;

VSH = this._shgr1 * GR + this._shgr2;

return VSH;
}

public double VSHCal2()
{
double TH = this._th.Value;
double VSH = -9999.99;

VSH = (TH - this._thmin) / (this._thmax - this._thmin) * 100;

return VSH;
}

public double CorrectVSH(double VSH)
{
if (-9999.99 == VSH)
{
return VSH;
}

double corVSH = VSH;
if (100 < corVSH)
corVSH = 100;
if (0 > corVSH)
corVSH = 0;

return corVSH;
}

孔隙度计算关键源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
public double PORCal0(double VSH)
{
double AC = this._ac.Value;

double POR = -9999.99;
POR = ((AC - this._poracma) / (this._poracf - this._poracma) / this._cp - (VSH / 100) * (this._poracsh - this._poracma) / (this._poracf - this._poracma)) * 100;

return POR;
}

AC+PORAC2
public double PORCal1()
{
double AC = this._ac.Value;

double POR = -9999.99;
POR = this._porac1 * AC + this._porac2;

return POR;
}

public double PORCal2(double VSH)
{
double CNL = this._cnl.Value;

double POR = -9999.99;
POR = (CNL - VSH / 100 * this._porcnlsh) * 100;

return POR;
}

public double PORCal3()
{
double CNL = this._cnl.Value;

double POR = -9999.99;
POR = this._porcnl1 * CNL + this._porcnl2;

return POR;
}

public double PORCal4(double VSH)
{
double DEN = this._den.Value;

double POR = -9999.99;
POR = ((DEN - this._pordenma4) / (this._pordenf4 - this._pordenma4) - (VSH / 100) * (this._pordensh - this._pordenma4) / (this._pordenf4 - this._pordenma4)) * 100;

return POR;
}

public double PORCal5()
{
double DEN = this._den.Value;

double POR = -9999.99;
POR = this._porden1 * DEN + this._porden2;

return POR;
}

public double PORCal6()
{
double CNL = this._cnl.Value;
double DEN = this._den.Value;

double PORDEN = (DEN - this._pordenf6) / (this._pordenma6 - this._pordenf6);
double PORCNL = (CNL - this._porcnlf) / (this._porcnlma - this._porcnlf);

double POR = -9999.99;
POR = Math.Pow((Math.Pow(PORDEN, 2) + Math.Pow(PORCNL, 2)) / 2, 0.5) * 100;

return POR;
}

public double PORCal7()
{
double AC = this._ac.Value;
double DEN = this._den.Value;

double POR = -9999.99;
POR = this._poracden1 * AC + this._poracden2 * DEN + this._poracden3;

return POR;
}

public double PORCal8()
{
double AC = this._ac.Value;
double CNL = this._cnl.Value;

double POR = -9999.99;
POR = this._poraccnl1 * AC + this._poraccnl2 * CNL + this._poraccnl3;

return POR;
}

public double PORCal9()
{
double CNL = this._cnl.Value;
double DEN = this._den.Value;

double POR = -9999.99;
POR = this._porcnlden1 * CNL + this._porcnlden2 * DEN + this._porcnlden3;

return POR;
}

public double PORCal10()
{
double AC = this._ac.Value;
double CNL = this._cnl.Value;
double DEN = this._den.Value;

double POR = -9999.99;
POR = this._poraccnlden1 * AC + this._poraccnlden2 * CNL + this._poraccnlden3 * DEN + this._poraccnlden4;

return POR;
}

public double CorrectPOR(double POR, double VSH)
{
double corPOR = POR;

if (-9999.99 == corPOR)
{
    return corPOR;
}

if (100 < corPOR)
    corPOR = 100;
if (0 > corPOR)
    corPOR = 0;

if (0 == this._porshcor)
{
    return corPOR;
}
else if (1 == this._porshcor)
{
    if (20 <= VSH && 45 >= VSH)
    {
        corPOR = (45 - VSH) / (45 - 20) * corPOR;
    }
    else if (45 < VSH)
    {
        corPOR = 0;
    }
}
else if (2 == this._porshcor)
{
    double vsh1 = 20;
    double vsh2 = 45;

    if (this._porvshc1 <= this._porvshc2)
    {
        vsh1 = this._porvshc1;
        vsh2 = this._porvshc2;
    }
    else
    {
        vsh1 = this._porvshc2;
        vsh2 = this._porvshc1;
    }

    if (vsh1 <= VSH && vsh2 >= VSH)
    {
        corPOR = (vsh2 - VSH) / (vsh2 - vsh1) * corPOR;
    }
    else if (vsh2 < VSH)
    {
        corPOR = 0;
    }
}

if (100 < corPOR)
    corPOR = 100;
if (0 > corPOR)
    corPOR = 0;

return corPOR;
}

渗透率计算关键源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
public double PERMCal0(double CPOR)
{
double PERM = -9999.99;
PERM = this._permpor1 * Math.Pow(Math.E, this._permpor2 * CPOR);

return PERM;
}

public double PERMCal1(double CPOR)
{
double PERM = -9999.99;
PERM = this._permti1 * Math.Pow(CPOR, this._permti2) / Math.Pow(this._swb, this._permti3);

return PERM;
}

public double PERMCal2(double CPOR)
{
double AC = this._ac.Value;
double CNL = this._cnl.Value;
double DEN = this._den.Value;

double FZI = 0;
FZI = this._permfzi1 + this._permfzi2 * AC + this._permfzi3 * CNL + this._permfzi4 * DEN;

double PERM = -9999.99;

double FZI1 = 5;
double FZI2 = 1;

if (this._permfzib1 >= this._permfzib2)
{
    FZI1 = this._permfzib1;
    FZI2 = this._permfzib2;
}
else
{
    FZI1 = this._permfzib2;
    FZI2 = this._permfzib1;
}

if (FZI1 <= FZI)
{
    PERM = this._permfzi1f1 * Math.Pow(CPOR, this._permfzi1f2);
}
else if (FZI2 <= FZI && FZI1 > FZI)
{
    PERM = this._permfzi2f1 * Math.Pow(CPOR, this._permfzi2f2);
}
else if (FZI2 > FZI)
{
    PERM = this._permfzi3f1 * Math.Pow(CPOR, this._permfzi3f2);
}

return PERM;
}

public double PERMCal3(double CPOR, double CVSH)
{
double DTST = this._dtst.Value;

double PERM = -9999.99;

PERM = Math.Pow(10, this._permdtst1f1) * Math.Pow(CPOR, this._permdtst1f2) * Math.Pow(DTST, this._permdtst1f3) * Math.Pow(CVSH, this._permdtst1f4);

return PERM;
}

public double PERMCal4(double CPOR, double CVSH)
{
double DTST = this._dtst.Value;

double PERM = -9999.99;

PERM = Math.Pow(10, this._permdtst2f1 + this._permdtst2f2 * CPOR + this._permdtst2f3 * DTST + this._permdtst2f4 * CVSH);

return PERM;
}

public double CorrectPERM(double PERM, double VSH)
{

if (-9999.99 == PERM)
{
    return PERM;
}

double corPERM = PERM;

if (0 > corPERM)
    corPERM = 0;

else if (1 == this._permshcor)
{
    if (20 <= VSH && 45 >= VSH)
    {
        corPERM = (45 - VSH) / (45 - 20) * corPERM;
    }
    else if (45 < VSH)
    {
        corPERM = 0;
    }
}

else if (2 == this._permshcor)
{
    double vsh1 = 20;
    double vsh2 = 45;

    if (this._permvshc1 <= this._permvshc2)
    {
        vsh1 = this._permvshc1;
        vsh2 = this._permvshc2;
    }
    else
    {
        vsh1 = this._permvshc2;
        vsh2 = this._permvshc1;
    }

    if (vsh1 <= VSH && vsh2 >= VSH)
    {
        corPERM = (vsh2 - VSH) / (vsh2 - vsh1) * corPERM;
    }
    else if (vsh2 < VSH)
    {
        corPERM = 0;
    }
}

if (0 > corPERM)
    corPERM = 0;

return corPERM;
}

含水饱和度计算关键源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
public double SWCal0(double POR)
{
    double RT = this._rt.Value;

    double SW = -9999.99;
    SW = Math.Pow(this._swaa * this._swab * this._swarw / RT / Math.Pow(POR / 100, this._swam), 1 / this._swan) * 100;

    return SW;
}

public double SWCal1(double POR)
{
    double a = 1;
    double b = 1;
    double m = 1.911;
    double n = 1.663;
    double RT = this._rt.Value;
    double SW = -9999.99;
    double T = 120;
    double P = 30;

    float swa2thd = this._manager.CurrentIndexValue;
    float swa2php = this._manager.CurrentIndexValue;

    if (0 == this._swa2tflag)
    {
        T = this._swa2t;
    }
    //T = T_sur + G_t×H_d / 100
    else if (1 == this._swa2tflag)
    {
        T = this._swa2ttsur + this._swa2tgt * swa2thd / 100;
    }

    if (0 == this._swa2pflag)
    {
        P = this._swa2p;
    }
    //P=G_p×H_p
    else if (1 == this._swa2pflag)
    {
        P = this._swa2pgp * swa2php;
    }

    a = this._swa2a;

    b = this._swa2b;
    if (0 == this._swa2mflag)
    {
        m = this._swa2m;
    }
    else if (1 == this._swa2mflag)
    {
        m = this._swa2zjsm1 + (this._swa2zjsm2 * T + this._swa2zjsm3) * Math.Log(P) + this._swa2zjsm4 * T;
    }
    else if (2 == this._swa2mflag)
    {
        m = this._swa2zjxm1 + (this._swa2zjxm2 * T + this._swa2zjxm3) * Math.Log(P) + this._swa2zjxm4 * T;
    }
    else if (3 == this._swa2mflag)
    {
        //(T ≤ 150℃，P ≤ 40MPa)
        if (150 >= T && 40 >= P) {
            m = this._swa2epm1 + (this._swa2epm2 * T + this._swa2epm3) * Math.Log(P) + this._swa2epm4 * T;
        }
        //(T > 150℃，P > 40MPa)
        if (150 < T && 40 < P) {
            m = this._swa2epm5 + (this._swa2epm6 * T + this._swa2epm7) * Math.Log(P) + this._swa2epm8 * T;
        }
    }

    if (0 == this._swa2nflag)
    {
        n = this._swa2n;
    }
    else if (1 == this._swa2nflag)
    {
        n = this._swa2zjsn1 + (this._swa2zjsn2 * T + this._swa2zjsn3) * Math.Log(P) + this._swa2zjsn4 * T;
    }
    else if (2 == this._swa2nflag)
    {
        n = this._swa2zjxn1 + (this._swa2zjxn2 * T + this._swa2zjxn3) * Math.Log(P) + this._swa2zjxn4 * T;
    }
    else if (3 == this._swa2nflag)
    {
        //(T ≤ 150℃，P ≤ 40MPa)
        if (150 >= T && 40 >= P)
        {
            n = this._swa2epn1 + (this._swa2epn2 * T + this._swa2epn3) * Math.Log(P) + this._swa2epn4 * T;
        }
        //(T > 150℃，P > 40MPa)
        if (150 < T && 40 < P)
        {
            n = this._swa2epn5 + (this._swa2epn6 * T + this._swa2epn7) * Math.Log(P) + this._swa2epn8 * T;
        }
    }

    SW = Math.Pow(a * b * this._swarw / RT / Math.Pow(POR / 100, m), 1 / n) * 100;

    return SW;
}

public double SWCal2(double POR, double VSH)
{
    double RT = this._rt.Value;

    double C = 1 - (VSH / 100) / 2;

    double SW = -9999.99;
    SW = Math.Pow((1 / RT * Math.Pow((Math.Pow(VSH / 100, C) / this._swyrsh) + (POR / 100 / Math.Pow(this._swya * this._swyrw, 0.5)), 2)), 0.5) * 100;

    return SW;
}

public double SWCal3(double POR, double VSH)
{
    double RT = this._rt.Value;

    double SW = -9999.99;
    SW = 0.4 * this._swsrw / Math.Pow(POR / 100, 2) * (Math.Pow((5 * Math.Pow(POR / 100, 2) / RT / this._swsrw + Math.Pow(VSH / 100 / this._swsrsh, 2)), 0.5) - VSH / 100 / this._swsrsh) * 100;

    return SW;
}

public double CorrectSW(double SW, double VSH)
{
    if (-9999.99 == SW)
    {
        return SW;
    }

    double corSW = SW;

    if (100 < corSW)
        corSW = 100;
    if (0 > corSW)
        corSW = 0;

    else if (1 == this._swshcor)
    {
        if (20 <= VSH && 45 >= VSH)
        {
            corSW = (45 - VSH) / (45 - 20) * corSW;
        }
        else if (45 < VSH)
        {
            corSW = 0;
        }
    }
    else if (2 == this._swshcor)
    {
        double vsh1 = 20;
        double vsh2 = 45;

        if (this._swvshc1 <= this._swvshc2)
        {
            vsh1 = this._swvshc1;
            vsh2 = this._swvshc2;
        }
        else
        {
            vsh1 = this._swvshc2;
            vsh2 = this._swvshc1;
        }

        if (vsh1 <= VSH && vsh2 >= VSH)
        {
            corSW = (vsh2 - VSH) / (vsh2 - vsh1) * corSW;
        }
        else if (vsh2 < VSH)
        {
            corSW = 0;
        }
    }

    if (100 < corSW)
        corSW = 100;
    if (0 > corSW)
        corSW = 0;

    return corSW;
}

束缚水饱和度计算关键源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
public double SWICal0(double GR, double POR)
{
    double SWI = -9999.99;

    double SWI0ISH = 1;
    double SWI0Y = 1;
    SWI0ISH = (GR - this._swi0grmin) / (this._swi0grmax - this._swi0grmin);
    SWI0Y = 3 * (1 - SWI0ISH) / (5 * Math.Pow(this._swi0pormax / 100, 2));

    if (SWI0ISH > 0.5)
    {
        SWI = (2 * SWI0ISH - SWI0Y) / (2 - SWI0Y) * 100;
    }
    else if (0.5 == SWI0ISH)
    {
        SWI = 50;
    }
    else if (SWI0ISH < 0.5)
    {
        SWI = 2 * SWI0ISH / (2 + SWI0Y) * 100;
    }

    return SWI;
}

public double SWICal1(double RT, double POR)
{
    double SWI = -9999.99;

    SWI = 1 / POR / 100 * Math.Pow(this._swi1rwb / RT, 0.5) * 100;

    return SWI;
}

public double SWICal2(double POR, double VSH)
{
    double SWI = -9999.99;

    SWI = (this._swi2a - Math.Log10(POR / VSH - this._swi2b)) * 100 / this._swi2c;

    return SWI;
}

public double CorrectSWI(double SWI)
{
    if (-9999.99 == SWI)
    {
        return SWI;
    }

    double corSWI = SWI;
    if (100 < corSWI)
        corSWI = 100;
    if (0 > corSWI)
        corSWI = 0;

    return corSWI;
}

层数据统计核心算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
public float[] getCurveArray(String CurveName, float StartDep, float EndDep)
{
    ICurve getCurve = this._manager.GetInCurve(CurveName);
    IDataAccessCollection a = getCurve.GetValues(StartDep, EndDep);
    float[] result = new float[a.Count];

    for (int i = 0; i < a.Count; i++)
    {
        IDataAccess temp = a.GetValue(i);
        float dtemp = BitConverter.ToSingle(temp.GetBytes(), 0);
        result[i] = dtemp;
    }

    return result;
}

public float getMax(float[] a)
{
    float max = a[0];

    for (int i = 0; i < a.Length; i++)
    {
        if (a[i] > max)
        {
            max = a[i];
        }
    }

    return max;
}

public float getMin(float[] a)
{
    float min = a[0];

    for (int i = 0; i < a.Length; i++)
    {
        if (a[i] < min)
        {
            min = a[i];
        }
    }

    return min;
}

public float getAve(float[] a)
{
    float sum = a[0];

    for (int i = 1; i < a.Length; i++)
    {
        sum += a[i];
    }

    float result = sum / a.Length;

    return result;
}

public float getHistogramPeak(float[] a)
{
    SortedList sortedListArray = new SortedList();

    sortedListArray.Add(a[0], 1);
    int sortedListArrayIndex = 0;

    for (int i = 1; i < a.Length; i++)
    {
        if (sortedListArray.ContainsKey(a[i]))
        {
            int index = sortedListArray.IndexOfKey(a[i]);

            int value = (int)sortedListArray.GetByIndex(index);

            value++;

            sortedListArray.Remove(a[i]);

            sortedListArray.Add(a[i], value);
        }
        else
        {
            sortedListArray.Add(a[i], 1);
        }
    }

    int MaxFrequency = 0;
    ICollection Values = sortedListArray.Values;
    foreach (int v in Values)
    {
        if (v > MaxFrequency)
        {
            MaxFrequency = v;
        }
    }

    int CountMaxFrequency = 0;
    ICollection Keys = sortedListArray.Keys;
    foreach (float k in Keys)
    {
        int value = (int)sortedListArray.GetByIndex(sortedListArray.IndexOfKey(k));
        if (MaxFrequency == value)
        {
            CountMaxFrequency++;
        }
    }

    float[] getResult = new float[CountMaxFrequency];
    int tempindex = 0;
    foreach (float k in Keys)
    {
        int value = (int)sortedListArray.GetByIndex(sortedListArray.IndexOfKey(k));
        if (MaxFrequency == value)
        {
            getResult[tempindex] = k;
            tempindex++;
        }
    }

    float resultSum = (float)0;

    for (int i = 0; i < getResult.Length; i++)
    {
        resultSum += getResult[i];
    }

    float result = resultSum / getResult.Length;

    return result;
}

气层识别计算关键源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
public int POIGZ0(float AC, float RT)
{
    if ((AC > 0 && AC < 69 && RT > 0 && RT < 9.5) || (AC > 69 && AC < 75 && RT > 0 && RT < (-0.4167 * AC + 38.25)) || (AC > 75 && RT > 0 && RT < 7))
    {
        return -1;
    }

    if (AC > 0 && AC < 62 && RT >= 9.5)
    {
        return 1;
    }

    if (AC >= 62 && AC < 69 && RT >= 9.5)
    {
        return -2;
    }

    if ((AC >= 69 && AC <= 75 && RT >= (-0.4167 * AC + 38.25)) || (AC > 75 && RT >= 7))
    {
        return 2;
    }

    return 0;
}

public int POIGZ1(float DEN, float RT)
{
    if ((DEN > 2.53 && RT > 0 && RT < 9.5) || (DEN > 2.43 && DEN < 2.53 && RT > 0 && RT < (27 * DEN - 58.81)) || (DEN > 0 && DEN < 2.43 && RT > 0 && RT < 6.8))
    {
        return -1;
    }

    if (DEN > 2.65 && DEN < 2.8 && RT >= 9.5)
    {
        return 1;
    }

    if (DEN >= 2.53 && DEN < 2.65 && RT >= 9.5)
    {
        return -2;
    }

    if ((DEN >= 2.53 && DEN <= 2.65 && RT >= (27 * DEN - 58.81)) || (DEN > 0 && DEN < 2.53 && RT >= 6.8))
    {
        return 2;
    }

    return 0;
}

public int POIGZ2(float CNL, float RT)
{
    if ((CNL > 0 && CNL < 8.5 && RT > 0 && RT < 9.5) || (CNL > 8.5 && CNL < 13 && RT > 0 && RT < (-0.6667 * CNL + 15.167)) || (CNL > 13 && RT > 0 && RT < 6.5))
    {
        return -1;
    }

    if (CNL > 0 && CNL < 5.9 && RT >= 9.5)
    {
        return 1;
    }

    if (CNL >= 5 && CNL < 8.5 && RT >= 9.5)
    {
        return -2;
    }

    if ((CNL >= 8.5 && CNL <= 13 && RT >= (-0.6667 * CNL + 15.167)) || (CNL > 13 && RT >= 6.5))
    {
        return 2;
    }

    return 0;
}

public int POIGZ3(float RT, float RS)
{
    float RTS = 0;
    RTS = RT / RS;

    if ((RT > 0 && RT < 6) || (RT > 6 && RT < 9 && RTS < (-0.4167 * RT + 4.7)))
    {
        return -1;
    }

    if (RT >= 9 && RTS > 0 && RTS < 0.95)
    {
        return 1;
    }

    if ((RT >= 6 && RT <= 9 && RTS >= (-0.4167 * RT + 4.7)) || (RT > 9 && RTS >= 0.95))
    {
        return 2;
    }

    return 0;
}

public int POIGZ4(float AC, float DEN, float POR, float RT)
{
    float PORAC = 1;
    float PORDEN = 1;
    float PORCNL = 1;
    float PORC = 1;

    PORAC = (float)((AC - this._poracma) / (this._poracf - this._poracma));
    PORDEN = (float)((DEN - this._pordenma) / (this._pordenf - this._pordenma));
    PORCNL = (float)((POR - this._porcnlma) / (this._porcnlf - this._porcnlma));
    PORC = (PORDEN - PORAC) / 2 - PORCNL;

    if ((PORC < -0.02 && RT > 0 && RT < 7) || (PORC > -0.02 && PORC < 0.0023 && RT > 0 && RT < (89.686 * PORC + 8.7937)) || (PORC > 0.0023 && RT > 0 && RT < 9))
    {
        return -1;
    }

    if (PORC > 0.05 && RT >= 9)
    {
        return 1;
    }

    if (PORC > 0.0023 && PORC <= 0.05 && RT >= 9)
    {
        return -2;
    }

    if ((PORC < -0.02 && RT >= 7) || (PORC >= -0.02 && PORC <= 0.0023 && RT >= (89.686 * PORC + 8.7937)))
    {
        return 2;
    }

    return 0;
}

public int POIGZ5(float RT, float CMPR, float POIS)
{
    double ND = 0;
    ND = (CMPR - this._cmprmin) / (this._cmprmax - this._cmprmin) - (POIS - this._poismin) / (this._poismax - this._poismin);

    if ((RT > 0 && RT < 6.8) || (RT > 6.8 && RT < 10 && ND < 0))
    {
        return -1;
    }

    if (RT >= 10 && ND < 0)
    {
        return 1;
    }

    if (RT >= 6.8 && ND >= 0)
    {
        return 2;
    }

    return 0;
}

配置文件加载代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<Toolbar>
<ID>1106</ID>
<Name>高温高压气层评价模块1</Name>
<Description>高温高压气层评价模块1</Description>
<LibraryFile>Cosl.ELIS.Process.BaiyunSagSWPU.dll</LibraryFile>
<ClassName>Cosl.ELIS.Process.BaiyunSagSWPU.MainProgressMethod</ClassName>
<Code>MainProgressMethod</Code>
<FunctionName>OnNewProcessMethod</FunctionName>
<FromDeep>false</FromDeep>
<StepIndex>0.1</StepIndex>
<Template>Normal Template\BAIYUNSAG.plt</Template>
<CollapseState>Large</CollapseState>
<MaxAllowedCollapseState>Large</MaxAllowedCollapseState>
<MinAllowedCollapseState>Large</MinAllowedCollapseState>
<VisualState>Default</VisualState>
<ImageFile>BaiyunSagSWPU.png</ImageFile>
</Toolbar>

<Toolbar>
<ID>1107</ID>
<Name>高温高压气层评价模块2</Name>
<Description>高温高压气层评价模块2</Description>
<LibraryFile>Cosl.ELIS.Process.BaiyunSagSWPU2.dll</LibraryFile>
<ClassName>Cosl.ELIS.Process.BaiyunSagSWPU2.MainProgressMethod</ClassName>
<Code>MainProgressMethod</Code>
<FunctionName>OnNewProcessMethod</FunctionName>
<FromDeep>false</FromDeep>
<StepIndex>0.1</StepIndex>
<Template>Normal Template\BAIYUNSAG.plt</Template>
<CollapseState>Large</CollapseState>
<MaxAllowedCollapseState>Large</MaxAllowedCollapseState>
<MinAllowedCollapseState>Large</MinAllowedCollapseState>
<VisualState>Default</VisualState>
<ImageFile>BaiyunSagSWPU2.png</ImageFile>
</Toolbar>
文章作者: HibisciDai
文章链接: http://hibiscidai.com/2022/03/20/白云凹陷珠江组-恩平组高温高压低渗气层测井评价-软件核心代码/
版权声明: 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 HibisciDai！
测井计算
好用、实惠、稳定的梯子,点击这里