Adriaan's Blog

Create a fuel file in Ricardo WAVE

2020-12-29T00:00:00+00:00

How to create a fuel file in Ricardo WAVE.

The following instructions can be used to create a fuel file for Ricardo WAVE. You can use this to either create a .fue file consisting of one blend component, or a blend with more than one:

Ensure you have downloaded the .dat files of the fuels you want to blend.
Open up the command prompt window (Start button->Search->”cmd”-> click on cmd.exe)
Ensure the command prompt is opened in the folder where the .dat files are saved. To change to the correct folder path:
1. Copy the file path in your Windows Explorer window. First open the folder where the files are.
2. Click on the little folder icon on the left of the file path and copy the file path.
3. Use command cd followed by the file path and press enter.
4. The new line in the command prompt will now show that it is open in the folder where the .dat files are.
Now enter the following command:

buildfuel -d diesel.dat ethanol.dat FAME.dat -f 0.89 0.09 0.02 -p Blended_Fuel

The above command is to create a B2E9 blend. First the .dat files of all the fuels that will be used in the blend are listed, then the percentage of each fuel in the blend and then the name you want to call the fuel file. For binary blends the command line will be:

buildfuel -d diesel.dat ethanol.dat -f 0.80 0.20 -p E20

The above command is to create a binary blend of E20 blend.

Ideal Rankine Cycle with feedwater heater calculations

2020-05-05T00:00:00+00:00

How to calculate the thernal efficiency of an Ideal Rankine Cycle with feedwater heaters using Python and PYroMat

The problem

Consider a regenerative cycle using steam as the working fluid. Steam leaves the boiler and enters the turbine at 4 MPa, $\text{400}^\circ\text{C}$. After expansion to 400 kPa, some of the steam is extracted from the turbine to heat the feedwater in an open FWH. The pressure in the FWH is 400 kPa, and the water leaving it is saturated liquid at 400 kPa. The steam not extracted expands to 10 kPa. Determine the cycle efficiency.

Looking at the mass flow of steam entering and exiting the turbine:

\[y = \dot{m}_6/\dot{m}_5\]

and thus $dot{m}_6$ can be written as a function of $\dot{m}_5$:

\[\dot{m}_6 = y\dot{m}_5\]

Similarly $\dot{m}_7$ can be written as:

\[\dot{m}_7=(1-y)\dot{m}_5\]

and

\[\dot{m}_7=(1-y)\dot{m}_5=\dot{m}_1=\dot{m}_2\]

Initiate PYroMat

import pyromat as pm
import numpy as np

pm.config["unit_pressure"] = "kPa"
pm.config["def_p"] = 100

mp_water = pm.get("mp.H2O") # <-- for multi-phase water properties

To solve this problem we consider a control surface around the pump, the boiler, the turbine, and the condenser.

The low pressure pump

First, let us consider the low pressure pump:

p1 = 10 # <-- given
p2 = 400 # <-- given

v1 = 1/mp_water.ds(p=p1)[0]

w_pump1 = v1*(p2-p1)
h2 = h1+w_pump1
print(f"Work required by pump 1: {round(float(w_pump1),1)} kJ/kg")

Work required by pump 1: 0.4 kJ/kg

The turbine

Next, let’s consider the turbine:

p5 = 4000 # <-- given
T5 = 400+273.15 # K <-- given
h5 = mp_water.h(p=p5, T=T5)
s5 = mp_water.s(p=p5, T=T5)

s6 =s5
p6 = 400 # <-- given
T6, x6 = mp_water.T_s(s=s6, p=p6, quality=True)
h6 = mp_water.h(x=x6, p=p6)

print(f"Quality of bled steam: {round(float(x6),4)}")

Quality of bled steam: 0.9757

The feedwater heater

Now, let’s consider the feedwater heater:

p3 = 400 # <-- given
h3 = mp_water.hs(p=p3)[0]

The energy conservation equation for the FWH is:

\[y(h_6)+(1-y)h_2 = h_3\]

This can be re-arranged to solve $y$ explicitly:

\[y = \frac{h_2 - h_3}{h_2 - h_6}\]

y = (h2-h3)/(h2-h6)
print(f"y = {round(float(y),4)}")

y = 0.1654

Work done by turbine

We can now calculate the work extracted by the turbine:

p7 = p1
s7 = s5
T7, x7 = mp_water.T_s(s=s7, p=p7, quality=True)
h7 = mp_water.h(x=x7, p=p7)
w_t = h5 - y*h6 - (1-y)*h7
print(f"Work generated by turbine: {round(float(w_t),1)} kJ/kg")

Work generated by turbine: 980.4 kJ/kg

The high pressure pump

Next, let’s consider the high pressure pump:

p4 = 4000 # <-- given
v3 = 1/mp_water.ds(p=p3)[0]
w_pump2 = v3*(p4-p3)
print(f"Work required by pump 2: {round(float(w_pump2),1)} kJ/kg")

Work required by pump 2: 3.9 kJ/kg

The boiler

Finally, we can consider the boiler:

h4 = h3 + w_pump2
q_H = h5-h4
print(f"Heat input by boiler: {round(float(q_H),1)} kJ/kg")

Heat input by boiler: 2605.9 kJ/kg

Thermal efficiency

We can now calculate the thermal efficiency with

\[\eta_{th}=\frac{w_{net}}{q_H}\]

eta_th = (w_t - w_pump1*(1-y) - w_pump2)/q_H*100
print(f"Thermal efficiency is: {round(float(eta_th),2)}%")

Thermal efficiency is: 37.46%

Ideal Rankine Cycle with reheat calculations

2020-04-28T00:00:00+00:00

How to calculate the thernal efficiency of an Ideal Rankine Cycle with reheat using Python and PYroMat

The problem

Consider a reheat cycle utilizing steam. Steam leaves the boiler and enters the turbine at 4 MPa, $\text{400}^\circ\text{C}$. After expansion in the turbine to 400 kPa, the steam is reheated to $\text{400}^\circ\text{C}$ and then expanded in the low-pressure turbine to 10 kPa. Determine the cycle efficiency.

Initiate PYroMat

import pyromat as pm

pm.config["unit_pressure"] = "kPa"
pm.config["def_p"] = 100

mp_water = pm.get("mp.H2O") # <-- for multi-phase water properties

To solve this problem we consider a control surface around the pump, the boiler, the turbine, and the condenser.

The pump

First, consider the pump:

#saturated liquid, thus x = 0
p1 = 10
s1 = mp_water.ss(p=p1)[0]
T1 = mp_water.Ts(p=p1)[0]

p2 = 4000
s2 = s1
T2 = mp_water.T_h(h=h2,p=p2)

h2dash = mp_water.hs(p=p2)[0]
s2dash = mp_water.ss(p=p2)[0]
T2dash = mp_water.Ts(p=p2)[0]

h3dash = mp_water.hs(p=p2)[1]
s3dash = mp_water.ss(p=p2)[1]
T3dash = T2dash

v = 1/mp_water.ds(p=p1)[0]

w_p = v*(p2-p1)

print(f"Specific volume: {round(float(v),5)} m^3/kg")
print(f"Work required by pump: {round(float(w_p),1)} kJ/kg")

Specific volume: 0.00101 m^3/kg
Work required by pump: 4.0 kJ/kg

h1 = mp_water.hs(p=p1)[0]
h2 = h1+w_p
print(f"h2 = {round(float(h2),1)} kJ/kg")

h2 = 195.8 kJ/kg

The HP turbine

Next, let’s consider the high pressure turbine:

p3 = p2
T3 = 400 + 273.15
h3 = mp_water.h(p=p3, T=T3)
s3 = mp_water.s(p=p3, T=T3)

p4 = 400
s4 = s3
T4, x4 = mp_water.T_s(s=s4, p=p4, quality=True)
h4 = mp_water.h(x=x4, p=p4)

w_HPt = h3-h4

print(f"Quality of intermediate pressure steam: {round(float(x4),4)}")
print(f"Work generated by HP turbine: {round(float(w_HPt),1)} kJ/kg")

Quality of intermediate pressure steam: 0.9757
Work generated by HP turbine: 528.2 kJ/kg

The LP turbine

Now, we consider the low pressure turbine:

p5 = p4
T5 = 400 + 273.15
h5 = mp_water.h(p=p5, T=T5)
s5 = mp_water.s(p=p5, T=T5)

p6 = p1
s6 = s5

T6, x6 = mp_water.T_s(s=s6, p=p6, quality=True)
h6 = mp_water.h(x=x6, p=p6)

w_LPt = h5-h6

print(f"Quality of low pressure steam: {round(float(x6),4)}")
print(f"Work generated by LP turbine: {round(float(w_LPt),1)} kJ/kg")
print(f"Total work output by turbine: {round(float(w_HPt+w_LPt),1)} kJ/kg")

Quality of low pressure steam: 0.9669
Work generated by LP turbine: 769.3 kJ/kg
Total work output by turbine: 1297.5 kJ/kg

The boiler

Next, let’s consider the boiler:

q_H = (h3-h2)+(h5-h4)
print(f"Heat input by boiler: {round(float(q_H),1)} kJ/kg")

Heat input by boiler: 3606.2 kJ/kg

The condenser

Finally, we consider the condenser:

q_L = h6-h1
print(f"Heat rejected by the condenser: {round(float(q_L),1)} kJ/kg")

Heat rejected by the condenser: 2312.8 kJ/kg

Calculating the thermal efficiency

We can now calculate the thermal efficiency with

\[\eta_{th}=\frac{w_{net}}{q_H}\]

eta_th = (w_HPt+w_LPt-w_p)/q_H*100
print(f"Thermal efficiency is: {round(float(eta_th),1)}%")

Thermal efficiency is: 35.9%

The Rankine cycle on a graph

Once all the values have been calculated, the ideal Rankine Cycle can be shown visually with the use of a graph.

import numpy as np
import matplotlib.pyplot as plt

p = np.linspace(1,22063,1000)
T = mp_water.Ts(p=p)
s = mp_water.ss(p=p)


font = {'family' : 'Times New Roman',
    'size'   : 22}


plt.figure(figsize=(15,10))
plt.title('Ideal Rankine Cycle T-s Diagram')
plt.rc('font', **font)
plt.plot(s[0],T, 'b--')
plt.plot(s[1],T,'r--')
plt.ylabel('Temperature (K)')
plt.xlabel('Entropy (s)')
plt.xlim(-2,10)
#plt.ylim(200,800)
plt.plot([s1, s2, s2dash, s3dash, s3, s4, s5, s6, s1],[T1, T2, T2dash, T3dash, T3, T4, T5, T6, T1], 'black')

plt.text(s1-.1,T1,f'(1)\nT = {round(float(T1),2)} K\nh = {round(float(h1),1)} kJ/kg\n s = {round(float(s1),3)} kJ/kgK',
    ha='right',backgroundcolor='white')
plt.text(1.6,330,f'(2)\nT = {round(float(T2),2)} K\nh = {round(float(h2),1)} kJ/kg',
    ha='left',backgroundcolor='white')
plt.text(s2dash-.15,T2dash,f"(2')\nT = {round(float(T2dash),2)} K\nh = {round(float(h2dash),1)} kJ/kg \ns = {round(float(s2dash),3)} kJ/kgK",
    ha='right',backgroundcolor='white')
plt.text(s3dash-.1,T3dash-60,f"(3')\nh = {round(float(h3dash),1)} kJ/kg \ns = {round(float(s3dash),3)} kJ/kgK",
    ha='right',backgroundcolor='white')
plt.text(6.3,T3-50,f'(3)\nT = {round(float(T3),2)} K\nh = {round(float(h3),1)} kJ/kg',
    ha='right',backgroundcolor='white')
plt.text(s4-.1,T4-80,f'(4)\nT = {round(float(T4),2)} K\nh = {round(float(h4),1)} kJ/kg \ns = {round(float(s4),3)} kJ/kgK\nx = {round(float(x4),3)}',
    ha='right',backgroundcolor='white')
plt.text(s5+.1,T5-70,f'(5)\nT = {round(float(T4),2)} K\nh = {round(float(h4),1)} kJ/kg \ns = {round(float(s4),3)} kJ/kgK',
    ha='left',backgroundcolor='white')
plt.text(s6+.1,T6,f'(6)\nT = {round(float(T4),2)} K\nh = {round(float(h4),1)} kJ/kg \nx = {round(float(x6),3)}',
    ha='left',backgroundcolor='white')

Ideal Rankine Cycle

2020-04-21T00:00:00+00:00

How to calculate the thernal efficiency of an Ideal Rankine Cycle using Python and PYroMat

The Problem

Consider the following question:

Determine the efficiency of a Rankine cycle using steam as the working fluid in which the condenser pressure is 10 kPa. The boiler pressure is 2 MPa. The steam leaves the boiler as saturated vapor.

Initiate PYroMat and configure its units

The first thing that we need to do before we start with solving the problem, is to import the necessary packages and configure PYroMat to use the correct units:

import pyromat as pm

pm.config["unit_pressure"] = "kPa"
pm.config["def_p"] = 100

mp_water = pm.get("mp.H2O")

To determine the cycle efficiency, we must calculate the turbine work, the pump work, and the heat transfer to the steam in the boiler. We do this by considering a control surface around each of these components in turn. In each case the thermodynamic model is the steam tables, and the process is steady state with negligible changes in kinetic and potential energies.

The Pump

First, consider the pump:

#saturated liquid, thus x = 0
p1 = 10 # <--given
T1 = mp_water.Ts(p=p1)[0]
s1 = mp_water.ss(p=p1)[0]
p2 = 2000 # <--given and converted to kPa
s2= s1
v = 1/mp_water.ds(p=p1)[0]

w_p = v*(p2-p1)
print(f"Work required by pump: {round(float(w_p),1)} kJ/kg")

Work required by pump: 2.0 kJ/kg

After the work required by the pump is calculated, the enthalpy value after the pump (point 2) can be calculated:

h1 = mp_water.hs(p=p1)[0]
h2 = h1+w_p
T2 = mp_water.T_h(p=p2,h=h2)

print(f"h2 = {round(float(h2),1)} kJ/kg")

h2 = 193.8 kJ/kg

The Boiler

Next, lets consider the boiler:

# steam leaves the boiler as saturated vapor, thus x = 1
p3 = p2
T3 = mp_water.Ts(p=p3)

h3 = mp_water.hs(p=p3)[1]
s3dash = mp_water.ss(p=p3)[0]
T3dash = T3
s3 = mp_water.ss(p=p3)[1]
q_H = h3-h2

print(f"Heat input by boiler: {round(float(q_H),1)} kJ/kg")

Heat input by boiler: 2604.5 kJ/kg

The Turbine

Now, we consider the turbine:

p4 = p1
s4 = s3
T4, x = mp_water.T_s(s=s4,p=p4, quality=True)
h4 = mp_water.h(p=p4,x=x)
w_t = h3-h4
print(f"Quality of low pressure steam: {round(float(x),4)}")
print(f"Work generated by turbine: {round(float(w_t),1)} kJ/kg")

Quality of low pressure steam: 0.7587
Work generated by turbine: 791.7 kJ/kg

The Condenser

Finally, we consider the condenser:

q_L = h4-h1
print(f"Heat rejected by the condenser: {round(float(q_L),1)} kJ/kg")

Heat rejected by the condenser: 1814.8 kJ/kg

Thermal Efficiency

We can now calculate the thermal efficiency with $\eta_{th}=\frac{w_{net}}{q_H}$

eta_th = (w_t-w_p)/q_H*100
print(f"Thermal efficiency is: {round(float(eta_th),1)}%")

Thermal efficiency is: 30.3%

Plotting the Ideal Rankine Cycle

After all the points have been calculated, the Rankine Cycle can be shown visually on a graph.

import numpy as np
import matplotlib.pyplot as plt

p = np.linspace(1,22063,1000)
T = mp_water.Ts(p=p)
s = mp_water.ss(p=p)


font = {'family' : 'Times New Roman',
     'size'   : 22}


plt.figure(figsize=(15,10))
plt.title('Ideal Rankine Cycle T-s Diagram')
plt.rc('font', **font)
plt.plot(s[0],T, 'b--')
plt.plot(s[1],T,'r--')
plt.ylabel('Temperature (K)')
plt.xlabel('Entropy (s)')
plt.plot([s1, s2, s3dash, s3, s4, s1],[T1, T2, T3dash, T3, T4, T1], 'black')

plt.text(s1-.1,T1,f'(1)\nT = {round(float(T1),2)} K\nh = {round(float(h1),1)} kJ/kg\n s = {round(float(s1),3)} kJ/kgK',
 ha='right',backgroundcolor='white')
plt.text(1.6,330,f'(2)\nT = {round(float(T2),2)} K\nh = {round(float(h2),1)} kJ/kg \ns = {round(float(s2),3)} kJ/kgK',
 ha='left',backgroundcolor='white')
plt.text(s3+.1,T3,f'(3)\nT = {round(float(T3),2)} K\nh = {round(float(h3),1)} kJ/kg \ns = {round(float(s3),3)} kJ/kgK',
 ha='left',backgroundcolor='white')
plt.text(s4+.1,T4,f'(4)\nT = {round(float(T4),2)} K\nh = {round(float(h4),1)} kJ/kg \ns = {round(float(s4),3)} kJ/kgK\nx = {round(float(x),3)}',
 ha='left',backgroundcolor='white')

How to webscrape Facebook with Python

2020-04-04T00:00:00+00:00

The problem

I am sure you have seen posts from a company’s or small business’s Facebook page where they ask you to like, share and follow in order to win a prize. But, how do these businesses then determine who have won? They will have to go and compare the names of all the people who:

liked the post,
shared the post and
followed their page

and then randomly select a winner from that group of people. If there are about 10 people who engaged with that promotional post, then it won’t take too long, but imagine if hundreds of people participated? It will take quite a lot of time to determine the winner then…

To help save a bit of time, we are going to construct a program that will scrape all the names of the people who engaged with the promotion post and randomly select a winner from the eligible participants.

Right! Let’s get started!

The data page_source

We are interested in the names of people who follow the business’s page and who liked and shared the post in question. All of this information is available on Facebook. In the end we will have three lists:

a list containing the names of people who follow the business’s Facebook page,
a list of people who have liked the promotional post and
a list of people who have shared the post.

The names that appear in all three lists, will be put in a final list and a random winner will be selected from the list of eligible names.

Coding the web scraper

Requirements

For this program to work, you will need to install:

Python 3.x
Requests library
Beautifulsoup library
Selenium library

Get the HTML data

First thing we need to do is to get the HTML data of the Facebook post we are interested in, into our Python script. We can do this using the Python library, requests.

Web scraping Facebook is a bit different, as the content is behind a login page. We will need to first have a look at the HTML code of the login page. For this project, we are going to log into https://mbasic.facebook.com:

start working your way through the HTML until you find the <form> HTML tag.
within the <form> tag look for the method="post" argument.
go down further into the form tag and look for the <input> tags. There should be at least two (username and password). The username input tag is generally of type=email and the password, type=password.
look within these input tags for a name argument. This is the name of this input field. This is also how requests is going to know where to “enter” your credentials. For this it is name="email" and name="pass".

Log into Facebook

The following code can be used to log into your Facebook account in order to scrape the necessary data that we need:

LOGIN_URL = 'https://www.facebook.com/login'

payload = {
  'email': 'your username',
  'pass': 'your password'
}

with requests.Session() as session:
  post = session.post(LOGIN_URL, data=payload)

Scrape the data

The URL is standard for most posts. You will need the following:

ID of post
amount of people who engaged with the post

With the two variables known, the URL where we will scrape the data is:

REQUEST_URL = f'https://mbasic.facebook.com/ufi/reaction/profile/
  browser/fetch/limit={limit}&total_count=17&ft_ent_identifier={post_ID}'

Now we can scrape the data by adding the following line:

with requests.Session() as session:
  post = session.post(POST_LOGIN_URL, data=payload)

  r = session.get(REQUEST_URL) #Add this line
  #^^^ Add this line... ^^^

Zooming in

With the HTML data stored in the variable r we can get the names of the people who liked the post with the following:

soup = BeautifulSoup(r.content, "html.parser")
names = soup.find_all('h3', class_='be')
people_who_liked = []
for name in names:
  people_who_liked.append(name.text)

The list people_who_liked has been created can will be used later.

People who shared

The same can be done for getting the list of people who shared the post, with a few changes to the code for BeautifulSoup:

with requests.Session() as session:
  post = session.post(POST_LOGIN_URL, data=payload)
  r = session.get(REQUEST_URL)

soup = BeautifulSoup(r.content, "html.parser")
names = soup.find_all('span')

people_who_shared = []
for name in names:
  people_who_shared.append(name.text)

People who follows your page

This one is a bit more tricky. We can only access the list of people who follows a page, if you have administrator rights to that pages. Also, the list is not shown when you access it through the website address https://mbasic.facebook.com and https://m.facebook.com and we will thus need another approach to get the HTML data through the use of the Selenium library:

Log in to Facebook
Navigate to page settings listing the people who liked our page
Scroll down until all the names are displayed on the screen
Scrape the list of names

Load the page of names

Selenium can take control of the browser and log in:

from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.chrome.options import Options

webdriver.driver.get("https://www.facebook.com/login")

sleep(2)

email_in = webdriver.driver.find_element_by_xpath('//*[@id="email"]')
email_in.send_keys(username)

password_in = webdriver.driver.find_element_by_xpath('//*[@id="pass"]')
password_in.send_keys(password)

login_btn = webdriver.driver.find_element_by_xpath('//*[@id="loginbutton"]')
login_btn.click()

The sleep() command gives the page time to load before entering the login details. Next we navigate to the page settings listing all the names:

page_name = your-page-name
REQUEST_URL = f'https://www.facebook.com/{page_name}/settings/
tab=people_and_other_pages&ref=page_edit'

webdriver.driver.get(REQUEST_URL)

sleep(2)
scrolls = 15

for i in range(1,scrolls):
  webdriver.driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
  sleep(3)

  page = webdriver.driver.page_source
  soup = BeautifulSoup(page, "html.parser")
  names = soup.find_all('a', class_='_3cb8')
  people_who_liked_page = []
  for name in names:
    people_who_liked_page.append(name.text)

For the above code we assume that 15 page scrolls will show all the names of the people who follow the page, but you can increase it depending on the amount of people who follow your page.

Determine the winner

We now have three lists:

People who liked the page
People who liked the post
People who shared the post

We need to create a new list that has all the names of the people who appear in all three of the above lists:

eligible_to_win = []
for name in list_A:
  if name in list_B and name in list_C:
    eligible_to_win.append(name)

The last thing to do is to select a winner randomly:

winner = random.choice(eligible)

You can also select more than one winner:

winners = random.sample(items, n)

where n is the amount of winners you want to select.

Conclusion

This code will ensure that you can select a winner to the promotional post in only a few minutes, rather than doing it manually.

JSAE/SAE conference in Kyoto, Japan

2019-08-26T00:00:00+00:00

NO_x emissions have become a health concern in cities with calls to reduce and ban vehicles with CI engines from entering the city.

As such, our aim is to reduce NO_x emissions being produced by the CI engine, and Low Temperature Combustion (LTC) is seen as a viable option. LTC is a broad term used generally for combustion techniques where the overall peak combustion temperature is reduced. This is beneficial as it reduces the formation of NO_x exhaust gasses. LTC techniques include HCCI, PCCI and RCCI. Although NO_x emissions is reduced as a result of lower temperatures, other emissions such as CO emissions and HC emissions can increase due to incomplete combustion.

There is thus a balance that needs to be optimised to ensure an overall reduction of all emissions. This research focussed on achieving emissions reduction by optimising EGR and the engine’s fuel delivery.

For this research we looked at four parameters that can be used to achieve LTC and ultimately reduce NO_x and CO emissions. NO_x emissions is reduced by reducing the combustion temperature and CO emissions are reduced by increasing the homogeneity of the air fuel mixture. The table shown in the slide shows the effects on the combustion temperature and the homogeneity of the air fuel mixture as reported in the literature. If we increase pilot injection duration, then the homogeneity of the charge increases as more fuel is being introduced in the pilot injection and thus more of the fuel can mix with the air before combustion occurs. Premixed combustion also increases as a result of this, ultimately increasing the combustion temperature. If we advance the pilot injection start of injection (SOI), then the homogeneity of the charge is increased, as there is more time for the fuel to mix with the air before combustion occurs. Increased homogeneity also increases the premixed combustion, which increases the combustion temperature. If we advance the main injection SOI, then the time for the fuel to mix with the air is decreased, which reduces the homogeneity of the charge as well as the combustion temperature. If we increase the Exhaust gas recirculation (EGR) percentage, then the homogeneity of the charge is increased, as more EGR increases the ignition delay and gives the fuel more time to mix with the air. It also reduces the combustion temperature as more inert gasses are introduced into the inlet charge, which absorbs a lot of the heat.

From this table, it can be seen that the four parameters have different effects on combustion temperature and charge homogeneity. It is thus necessary to determine which parameter has a significant effect on emissions formation and which parameter has a lesser effect. The Design of Experiment (DoE) statistical tool was used to determine the effect of each parameter on the formation of engine emissions and if it is significant or not. A DoE was also used to determine the impact of each parameter as well as determine an optimised point that resulted in overall reduced emissions.

Next we need to consider the drive cycle that will be used in the simulation. When we look at how past research has generated experimental emissions data, the majority of research found have used steady state engine operating points in their test methodology. The results from steady state experimentation cannot accurately represent real life scenarios. A transient drive cycle is needed to generate results that are comparable to real life. The WLTP was used in this research. It replaced the NEDC that has been used in the past to test the new vehicle entering the market.

I have created this figure to further illustrate the benefits of using the WLTP for real world emissions investigation. The graph shows the WLTP, in grey circles, as a function of engine speed and BMEP. The red crosses indicate the steady state points used by past research to investigate engine emissions. When looking at the graph, clear gaps are evident in the engine operating map that is not covered by the research considered. The use of a transient drive cycle is thus appropriate if the results needed to be comparable to a real world scenario.

Methodology

An engine simulation was used to investigate the effects of varying the different engine operating parameters on engine emissions. A 2.4 L turbocharged CI engine was simulated. The simulation’s combustion model was validated using in-cylinder pressure data and emissions data was used to validate its emissions models.

The Wiebe combustion model was used in this research. Linear regression models was generated for the start of combustion crank angle degree (CAD), premixed fuel mass fraction burned and Wiebe exponent by using the cylinder pressure data. This is necessary as we are simulating a transient drive cycle as well as changing engine parameters that influence combustion. The emission models were validated using exhaust gas analyser experimental data. The engine simulation can only simulate CO emissions and NO_x emissions.

After the models were calibrated, it was compared to experimental data to check its accuracy. Here two cylinder pressure graphs are shown; one at 25% load and 1500rpm and the other at 75% load and 3000rpm. The experimental data is shown in a solid line and the simulated model is shown in dashed lines. As can be seen, the simulated results correlate well with the experimental data.

Same can be said of the simulated emissions. The simulated emission results for the CO emissions and NO_x emissions correlate well with the experimental data. We thus have confidence in our simulation and can now move on to setting up the DoE.

When setting up the factorial design, a 2^4 factorial design was chosen as there are 4 parameters that will be investigated. These are EGR percentage, pilot injection duration and main and pilot injection SOI. The test engine is using an aftermarket ECU, which have operating maps loaded onto it by default. These operating maps are used as the starting point for the DoE. The EGR percentage map is in the form of an island with maximum EGR at approximately 2500 rpm and 10 % throttle position. Here is an example of an EGR map with 47% as the maximum percentage. The value as given by the DoE will always be the maximum value and the maps will be scaled according to the maximum value.

Shown here is a table with the low and high values of the first factorial design. The EGR percentage has a low and high value of 0 % and 10 %, pilot injection and main injection SOI is advanced by one CAD and retarded by 1 CAD. The pilot injection duration is decreased by 100 μs and increased by 100 μs. Similar tables were created for the second and third factorial designs based on the results from the previous factorial design.

In order to determine the configuration that will reduce emissions the most, we opted to follow the path of greatest emission reduction using multiple factorial designs. After each factorial design, The desirability function was used to determine the best configuration of the parameters under investigation. This then was used to set up the next factorial design. This can be explained in the figure shown.

The figure shows the three factorial designs for two parameters, pilot injection SOI and EGR percentage. As can be seen for the first factorial design, the EGR is varied from 0 % to 10 % and the pilot injection SOI is advanced and retarded by 1 CAD. Once the first factorial design is completed, the desirability function is used to determine which configuration reduces the emissions the most. In this case it is an EGR percentage of 10 % and by retarding the pilot injection SOI by 1 CAD. The low and high values of the second factorial design can now be determined with the use of the two equations shown on the slide.

As a maximum desirability (D<sub>i</sub>) is achieved at 10 % EGR, the second factorial design’s low value becomes 10 % and the high level value for the second factorial design becomes 25 %. For the pilot injection SOI, the second factorial design’s low value is set to retard the map by 1 CAD and the high values is set to retard the operating map by 4 CADs.

Once the second factorial design is finished, the desirability function is used again to determine which configuration results in the reducing the emissions the most. This results in a EGR percentage of 25 % and retarding the pilot injection SOI by 2 CADs. As such the low and high values for the EGR percentage for the third factorial design is calculated as 25 % and 47.5%. The pilot injection SOI low and high values for the third factorial design stays at retarding the maps with 1 CAD and 4 CADs.

Results and discussion

Shown on this slide is the desirability function plot for the third factorial design that was simulated. As can be seen, by the third factorial design, the start of injection for the pilot and main injection and the injection duration of the pilot injection does not significantly influence the emissions. This can be seen by the almost horizontal lines of the graph.

The EGR percentage has a significant effect on the NO_x emissions and CO emissions as the graph lines have a steep gradient. The desirability function plot at the top in the form of a half circle indicate that the maximum desirability value will be reached for an EGR percentage at approximately 36 %.

When we put all the factorial designs’ results on one graph, we can get a better overall picture. For the second factorial design, we optimised towards a maximum of CO emissions as per the Euro 4 limits. This resulted in a reduction of approximately 20% of NO_x when we use a maximum of 12% EGR.

To further investigate LTC, for the third factorial design, we opted to continue to increase the EGR percentage to 47.5%. This resulted in a reduction in NO_x of 85% to 0.55g/km where the Euro 4 limit is 0.25g/km. The CO emissions greatly increased as a result of the EGR percentage increasing, to 22.58g/km.

Next we wanted to see if we achieved LTC. This graph shows the peak temperature for combustion with no LTC techniques used as well as for the combustion temperature for the third factorial design. The difference in peak temperature between the two graphs is approximately 100 °K.

Conclusions

NO_x emissions were reduced by approximately 85% with an EGR percentage of 47.5 %, retarding the pilot injection and main injection SOI by 1 CAD and increasing the pilot injection duration by 200 μs.
NO_x emissions reduced by approximately 20 % with the use of 12 % EGR without exceeding the Euro 4 CO emissions limit.
Low temperature combustion was achieved
The method of using DoE to minimise engine out emissions was successful

Limitations

The sample size of the experimental data is modest. By using more experimental data, more robust regression models can be constructed.
A blind transient comparison between simulation and experimental results would be beneficial and increase our confidence in our engine simulation.
Following the path of greatest emission reduction, was successful, but it can result in finding a local minimum, where we want to determine the global minimum.
The DoE can be improved by investigate the whole operating map of the engine to ensure that we will be able to determine the global minimum.