ccitonline.com

A. Project Title

Standard Rankine Cycle Calculator using Property Table Look Up and Interpolation

B. Author Complete Name

Luqman Alifio Arhab

2506565446

C. Affiliation

Departemen Teknik Mesin UI, Depok, Indonesia

D. Abstract

Summarize the report in 150–250 words, highlighting the objectives, methodology, key findings, and conclusions.

E. Author Declaration

Author akan berusaha mengikuti frame work DAI5 sebisa mungkin

5.1. Deep Awareness (of) I

Dengan tahap ini, author akan mendalami dan membangun kesadaran mengenai dampak dari proyek ini kepada diri author sendiri dan masyarakat

• Memberi manfaat bagi masyarakat dengan mengembangkan program penghitungan praktis
• Meningkatkan pemahaman mengenai rankine cycle baik cara kerjanya maupun teori dibaliknya
• Membangun kesadaran terhadap pencipta dengan meniatkan pelaksanaan proyek sebagai suatu bentuk ibadah

5.2. Intention of the Project Activity

Dengan tahap ini, author akan mendalami tujuan dan motivasi author dalam pengerjaan proyek ini

• Membangun alat penghitung pembangkit listrik rankine cycle yang dapat bermanfaat bagi masyarakat
• Mengembangkan alat penelitian rankine cycle yang dapat berguna bagi masyarakat sebagai pembangkit listrik

F. Introduction

Rankine cycle, lebih tepatnya Steam rankine cycle yang digunakan pada proyek ini, adalah siklus mekanik yang dapat mengubah energi panas menjadi energi termal. Steam Rankine cycle didukung dengan 4 komponen utama yaitu: boiler, kondensor, ekspander dan pompa. rankine cycle memanfaatkan perbedaan temperatur dan entalpi uap antara dua keadaan tekanan untuk menghasilkan kerja melalui proses ekspansi. Rankine cycle bekerja dengan mengambil panas di bagian evaporator lalu mengekspansi fluida kerja didalamnya, umumnya air, untuk menghasilkan kerja mekanik di ekspander. sisa energi yang tidak dapat diubah akan dilepaskan lewat kondenser.

6.1. Initial Thinking (about the Problem):

Pada tahap ini, author akan membongkar lebih lanjut mengenai rankine cycle. Hasil dekomposisi yang ditemukan adalah:

• Terdapat 4 proses utama pada rankine cycle yaitu kompresi, heating/evaporasi, ekspansi, dan cooling/kondensasi
• Diantara keempat proses, terdapat dua proses dimana energi diberikan kepada sistem yaitu kompresi dan heating serta dua proses dimana energi dikeluarkan dari sistem yaitu ekspansi dan cooling
• Seluruh perubahan energi pada rankine cycle muncul pada fluida kerja sebagai perubahan entalpi
• Diantara proses pengeluaran energi, energi keluaran yang dapat digunakan hanya berasal dari proses ekspansi sementara pada proses cooling energi hanya dibuang kelingkungan (terdapat kemungkinan penggunaan kembali menggunakan waste heat recovery)
• Pada proses kompresi, energi diberikan pada fluida cair untuk meningkatkan tekanan fluida
• Pada proses heating, energi diberikan pada fluida cair untuk memanaskan/menaikkan suhunya, peningkatan entalpi tertinggi terjadi pada proses ini
• Pada proses ekspansi, energi dapat dikeluarkan dari siklus menjadi energi yang dapat digunakan, menurunkan tekanannya
• Pada proses cooling, energi dikeluarkan dari fluida sehingga fluida mendingin dan terkondensasi sehingga fluida dapat mengambil kembali panas
• Energi yang benar benar dapat digunakan adalah energi yang diperoleh dari proses ekspansi dikurangi energi yang dibutuhkan untuk  pengoprasian pompa

G. Methods & Procedures

Perhitungan energi rankine cycle akan dilakukan menggunakan data dari tabel properti terutama data entalpi dan entropi. Data tabel properti akan dimasukkan pada program kemudian diambil datanya menggunakan look up, jika data tidak terdapat pada tabel properti, data akan dicari menggunakan interpolasi linear dari data disekitarnya.

7.1. Idealization:

Pada tahap ini, author akan menjabarkan asumsi serta rumusan yang akan digunakan:

• Diasumsikan rankine cycle standard yang hanya memiliki 4 komponen utama
• Perhitungan rankine cycle didasarkan pada 2 tekanan fluida(tinggi dan rendah) serta satu temperatur boiler fluida(hasil proses heating)
• Seluruh proses akan terjadi pada efisiensi maksimal dan tidak ada keluaran kalor di luar proses kondensasi
• Seluruh proses ekspansi dan kompresi akan terjadi secara isentropik
• Seluruh perhitungan akan dilakukan dengan data dari tabel periodik
• Pada proses kompresi, energi dihitung menggunakan data volume dan perubahan tekanan

W_p=v_l*(P2-P1)

Yang mana perubahan energi akan berubah menjadi entalpi keadaan 2

h2=h_l+W_p

dengan h_l merupakan entalpi saturasi liquid pada tekanan rendah

• Pada proses heating, energi dihitung sebagai:

Q_in = h3-h2

Dengan h2 merupakan entalpi setelah proses pertama sementara h_3 adalah entalpi pada tekanan tinggi dan temperatur boiler

• Pada proses ekspansi, energi dicari lewat entropi dengan mencari nilai entalpi pada tekanan rendah saat nilai entropinya sama dengan nilai entropi keadaan 3

W_t=h3-h4

• Pada proses cooling, energi yang dikeluarkan dihitung dengan

Q_out=h4-h_l

• Energi yang diperoleh dari rankine cycle dihitung sebagai:

Energi=W_t-W_p

Sementara efisiensinya dihitung sebagai:

Efisiensi=energi/Q_in

Adapun energi yang dikeluarkan dari rankine cycle dapat diperoleh dari Q_out

7.2. Instruction (Set):

Pada proses ini akan diberikan flowchart, penjelasan program serta kode python proyek ini.

Flowchartnya sebagai berikut:

Algoritma program bekerja dengan cara:

1. User menginput tekanan masuk dan keluar turbin, serta temperatur yang dihasilkan boiler
2. Mengambil tabel properti
3. Lakukan look up (pencarian) pada tabel properti berdasarkan nilai P input turbin dan T boiler
4. Jika ada tekanan dan temperatur yang cocok pada tabel, ambil nilai entalpi  dan entropi dari tabel properti, jika tidak ada yang cocok, lakukan interpolasi linear
5. Lakukan look up (pencarian) pada tabel properti berdasarkan nilai P output turbin
6. Jika ada tekanan yang cocok pada tabel, ambil nilai entalpi dan entropi saturasi(cair dan gas) serta volume saturasi cair dari tabel properti, jika tidak ada yang cocok, lakukan interpolasi linear
7. Lakukan perhitungan berdasarkan rumus dibawah
8. Tampilkan kerja yang dihasilkan, energi yang terbuang, dan efisiensi rankine cycle

Kumpulan rumusnya adalah:

H. Results & Discussion

Program tersebut telah berjalan dan hasilnya dapat ditonton pada:

Keluaran program hanya berupa nilai angka dengan contoh keluaran

“

Starting Rankine Cycle Calculation

Input P_high (Turbine Inlet Pressure): 6.5

Input P_low (Condenser Pressure): 0.15

Input T_boil (Boiler Temperature): 400

Searching for P1 and T1 properties…

preparing interpolation….

Searching for P2 saturation properties…

preparing interpolation….

Performing Cycle Calculations…

— RESULTS —

Kerja yang dihasilkan (W_cycle): 804.8004

Energi yang terbuang (Q_out): 2243.9126

Efisiensi Rankine Cycle (eta/η): 0.2640 (26.40%)

—————–

 Finish

“

Selain program, dibuat juga AI agent dengan mensupply knowledge. Berikut hasil testing AI agent

• Tester: Luqman Alifio Arhab

• Tester: Azfa Rhazasta Abiandra

https://youtu.be/5tZ0PDAm3tA?si=SFCDRBpAgS6HucSh

• Tester: Febryan Andhika Saputra

I. Conclusion, Closing Remarks, Recommendations

Program dan AI agent berhasil dibuat dan dapat dijalankan dengan aman. Hanya saja masih terdapat kekurangan berupa keterbatasan keadaan yang dapat digunakan karena keterbatasan tabel properti yang diberikan pada program. Sehingga tabel properti perlu di-update

J. Acknowledgments

Author mengucapkan terimakasih kepada Profesor Ahmad Indra serta teman teman di kelas komputasi teknik semester gasal 2025/2026 Teknik mesin UI. Author juga berterimakasih terhadap AIDAI5 yang memungkinkan pembuatan AI agent.

K. (References) Literature Cited

Proyek ini dibuat dengan bantuan Gemini AI.

L. Appendices

link drive dokumentasi

https://drive.google.com/drive/folders/1URfd1ykl1KPe67e35uGpATNYq4q_3ty6?usp=sharing

Berikut kode python yang digunakan pada proyek ini

import math

HIGH_PROP_TABLE = [
    {"P": 4.0, "T": 300.0, "h": 3066.0, "s": 7.371},
    {"P": 5.0, "T": 350.0, "h": 3192.3, "s": 7.531},
    {"P": 6.0, "T": 400.0, "h": 3270.3, "s": 7.625},
    {"P": 7.0, "T": 450.0, "h": 3370.0, "s": 7.749},
]

LOW_PROP_TABLE = [
    {"P": 0.05, "hl": 137.8, "hg": 2561.4, "sl": 0.4764, "sg": 8.3951, "vl": 0.001005},
    {"P": 0.10, "hl": 191.8, "hg": 2584.7, "sl": 0.6493, "sg": 8.1502, "vl": 0.001010},
    {"P": 0.20, "hl": 251.4, "hg": 2609.9, "sl": 0.8320, "sg": 7.9085, "vl": 0.001017},
    {"P": 0.30, "hl": 289.2, "hg": 2624.6, "sl": 0.9441, "sg": 7.7667, "vl": 0.001023},
]

def interpolate_2d(P_high, T_boil, n):
    """
    Performs 2-dimensional interpolation for enthalpy (h1) and entropy (s1)
    based on the specific formula provided in the flowchart (Page 3).

    Inputs (as taken from the main program and property table):
    P_high (P1), T_boil (T1): The target point (pressure and temperature).
    P_upper (P[n]), P_lower (P[n-1]): Pressure bounds from the property table.
    T_upper (T[n]), T_lower (T[n-1]): Temperature bounds from the property table.
    h_upper (h[n]), h_lower (h[n-1]): Enthalpy bounds.
    s_upper (s[n]), s_lower (s[n-1]): Entropy bounds.

    Returns:
    h1, s1: Interpolated enthalpy and entropy values.
    """

    # P1 = P_high and T1 = T_boil are established here [cite: 44, 45]
    P1 = P_high
    T1 = T_boil
    upperentry = HIGH_PROP_TABLE[n]
    P_upper=upperentry["P"]
    T_upper=upperentry["T"]
    h_upper=upperentry["h"]
    s_upper=upperentry["s"]

    lowerentry = HIGH_PROP_TABLE[n-1]
    P_lower=lowerentry["P"]
    T_lower=lowerentry["T"]
    h_lower=lowerentry["h"]
    s_lower=lowerentry["s"]

    # 1. Calculate the numerator: (P1 - P_lower)^2 + (T1 - T_lower)^2
    numerator = (P1 - P_lower)**2 + (T1 - T_lower)**2

    # 2. Calculate the denominator: (P_upper - P_lower)^2 + (T_upper - T_lower)^2
    denominator = (P_upper - P_lower)**2 + (T_upper - T_lower)**2

    # Handle the case where bounds are identical
    if denominator == 0:
        raise ValueError("Interpolation bounds are identical. Cannot perform division.")

    # 3. Calculate the ratio
    ratio = numerator / denominator

    # 4. Apply the interpolation formulas as provided in the flowchart [cite: 53]
    # Note: The formula provided is unusual for a standard linear interpolation
    # as it does not add back the lower bound value (e.g., h_lower).

    # Calculate h1:
    h1 = ((ratio ** 0.5) * (h_upper - h_lower)) + h_lower

    # Calculate s1:
    s1 = ((ratio ** 0.5) * (s_upper - s_lower)) + s_lower

    # 5. Return h1 and s1 to the main program [cite: 54]
    return h1, s1

def interpolate_1d(P_low, m):
    """
    Performs 2-dimensional interpolation for enthalpy (h1) and entropy (s1)
    based on the specific formula provided in the flowchart (Page 3).

    Inputs (as taken from the main program and property table): hl,2, hg,2, sl,2, sg,2, and vl,2
    P_low (P1): The target point (pressure and temperature).
    P_upper (P[n]), P_lower (P[n-1]): Pressure bounds from the property table.
    hl_upper (hl[n]), hl_lower (hl[n-1]): saturated liquid enthalpy bounds from the property table.
    hg_upper (hg[n]), hg_lower (hg[n-1]): saturated gas enthalpy bounds.
    sl_upper (sl[n]), sl_lower (sl[n-1]): saturated liquid entropy bounds.
    sg_upper (sg[n]), sg_lower (sg[n-1]): saturated gas entropy bounds.
    vl_upper (vl[n]), vl_lower (vl[n-1]): saturated liquid specific volume bounds.

    Returns:
    hl2, hg2, sl2, sg2, vl2: Interpolated enthalpy and entropy values.
    """

    P2 = P_low
    upperentry = LOW_PROP_TABLE[m]
    P_upper=upperentry["P"]
    hl_upper=upperentry["hl"]
    hg_upper=upperentry["hg"]
    sl_upper=upperentry["sl"]
    sg_upper=upperentry["sg"]
    vl_upper=upperentry["vl"]
    lowerentry = LOW_PROP_TABLE[m-1]
    P_lower=lowerentry["P"]
    hl_lower=lowerentry["hl"]
    hg_lower=lowerentry["hg"]
    sl_lower=lowerentry["sl"]
    sg_lower=lowerentry["sg"]
    vl_lower=lowerentry["vl"]

    # 1. Calculate the numerator: (P2 - P_lower)
    numerator = (P2 - P_lower)

    # 2. Calculate the denominator: (P_upper - P_lower)
    denominator = (P_upper - P_lower)

    # Handle the case where bounds are identical
    if denominator == 0:
        raise ValueError("Interpolation bounds are identical. Cannot perform division.")

    # 3. Calculate the ratio
    ratio = numerator / denominator

    # 4. Apply the interpolation formulas as provided in the flowchart [cite: 53]
    # Note: The formula provided is unusual for a standard linear interpolation
    # as it does not add back the lower bound value (e.g., h_lower).

    # Calculate hl2:
    hl2 = (ratio * (hl_upper - hl_lower)) + hl_lower

    # Calculate hg2:
    hg2 = (ratio * (hg_upper - hg_lower)) + hg_lower

    # Calculate sl2:
    sl2 = (ratio * (sl_upper - sl_lower)) + sl_lower

    # Calculate sg2:
    sg2 = (ratio * (sg_upper - sg_lower)) + sg_lower

    # Calculate vl2:
    vl2 = (ratio * (vl_upper - vl_lower)) + vl_lower

    # 5. Return h1 and s1 to the main program [cite: 54]
    return hl2, hg2, sl2, sg2, vl2

def lookup_properties_pt(P_high, T_boil):
    """
    Looks up for h and s from the property table at specific P and T.
    Returns (h, s) if found, otherwise None
    Uses a single index 'n' for iteration.
    """
    print("Searching for P1 and T1 properties...")
    n = 0
    # Search for bounds based on P and T
    while n < len(HIGH_PROP_TABLE):
        entry = HIGH_PROP_TABLE[n]
        # [cite_start]P[n] <= P_high? T[m] <= T_boil? [cite: 12]
        if entry["P"] < P_high and entry["T"] < T_boil:
            n += 1
        else:
            break

    # Check for direct match: P[n]=P_high? [cite_start]T[n]=T_boil? [cite: 13]
    if n < len(HIGH_PROP_TABLE) and HIGH_PROP_TABLE[n]["P"] == P_high and HIGH_PROP_TABLE[n]["T"] == T_boil:
        print("Direct match found.")
        h1 = HIGH_PROP_TABLE[n]["h"]
        s1 = HIGH_PROP_TABLE[n]["s"]
    else:
      print("preparing interpolation....")
      h1, s1 = interpolate_2d(P_high, T_boil, n)
    return h1, s1


def lookup_saturated_properties_p(P_low):
    """
    Look up saturated properties for the low-pressure point (P2).
    Uses index 'm' for iteration.
    """
    print("Searching for P2 saturation properties...")
    m = 0
    # Search for bounds based on P
    while m < len(LOW_PROP_TABLE):
        entry = LOW_PROP_TABLE[m]
        # [cite_start]P[m] <= P_low? [cite: 18]
        if entry["P"] < P_low:
            m += 1
        else:
            break

    # [cite_start]Check for direct match: P[m]=P_low? [cite: 19]
    if m < len(LOW_PROP_TABLE) and LOW_PROP_TABLE[m]["P"] == P_low:
        print("Direct match found.")
        entry = LOW_PROP_TABLE[m]
        hl2=entry["hl"]
        hg2=entry["hg"]
        sl2=entry["sl"]
        sg2=entry["sg"]
        vl2=entry["vl"]
    else:
        print("preparing interpolation....")
        hl2, hg2, sl2, sg2, vl2 = interpolate_1d(P_low,m)

    return hl2, hg2, sl2, sg2, vl2

# --- Main Program Logic ---

def rankine_cycle_calculator():
    print("Starting Rankine Cycle Calculation")
    # 1. Start and Input [cite: 3, 4, 5, 6]
    try:
        P_high = float(input("Input P_high (Turbine Inlet Pressure): "))
        P_low = float(input("Input P_low (Condenser Pressure): "))
        T_boil = float(input("Input T_boil (Boiler Temperature): "))
    except ValueError:
        print("Invalid input. Please enter numeric values.")
        return

    # Initialize n=0 and m=0 are implicit in lookups
    # P1 and T1 are the high pressure/temperature points for h1, s1 [cite: 14]
    P1 = P_high
    T1 = T_boil

    result_high_pt = lookup_properties_pt(P_high, T_boil)

    h1, s1 = result_high_pt


    # 3. Look up/Interpolate for Saturated Properties (Condenser Outlet/Inlet) [cite: 79]
    # P2 is the low pressure point for saturated properties [cite: 20]
    P2 = P_low

    result_low_p = lookup_saturated_properties_p(P_low)

    hl2, hg2, sl2, sg2, vl2 = result_low_p

    # 4. Calculation Block
    print("Performing Cycle Calculations...")
    #print("h1=",h1)

    # Pump Work (Wp)
    Wp = vl2 * (P1 - P2)
    #print("Wp=",Wp)

    # Steam Quality (x)
    try:
        x = (s1 - sl2) / (sg2 - sl2)
    except ZeroDivisionError:
        print("Error: sg2 - sl2 is zero. Cannot calculate quality.")
        return
    #print("x=",x)

    # Enthalpy at Turbine Outlet (h2)
    h2 = x * hg2 + (1 - x) * hl2
    #print("h2=",h2)

    # Heat Input (Qin) [cite: 33, 85]
    Qin = h1 - hl2 - Wp
    #print("Qin=",Qin)

    # Turbine Work (Wt) [cite: 34, 86]
    Wt = h1 - h2
    #print("Wt=",Wt)

    # Heat Output (Qout) [cite: 34, 87]
    Qout = h2 - hl2
    #print("hl2=",hl2)
    #print("Qout=",Qout)

    # Net Cycle Work (Wcycle) [cite: 36, 88]
    Wcycle = Wt - Wp
    #print("Wcycle=",Wcycle)

    # Cycle Efficiency (eta/η) [cite: 36, 89]
    # η = (Wt - Wp) / Qin
    try:
        eta = Wcycle / Qin
    except ZeroDivisionError:
        print("Error: Qin is zero. Cannot calculate efficiency.")
        return
    #print("eta=",eta)

    # 5. Output [cite: 38]
    print("--- RESULTS ---")
    print(f"Kerja yang dihasilkan (W_cycle): {Wcycle:.4f}")
    print(f"Energi yang terbuang (Q_out): {Qout:.4f}")
    print(f"Efisiensi Rankine Cycle (eta/η): {eta:.4f} ({eta*100:.2f}%)")
    print("-----------------")
    print(" Finish ")

if __name__ == "__main__":
    rankine_cycle_calculator()