Mission Explore

"Exploration is really the essence of the human

spirit." - Frank Borman
INTRODUCTION :
Mission Explore is a programming event based on the MATLAB Platform. This is an open
problem and doesn't require any prior knowledge of Earth Science. However, it deals with
something central to modern Geophysics and Exploration Techniques, namely algorithms
and optimization. The Challenge is to optimize the process of Oil Exploration by Automated
Robots (referred to as Bots). There are three types of Bots each capable of determining a
certain type of data that indicates the presence of Oil. When a Bot reaches a certain position
it finds the value of that data, which it is capable of determining, at that position. One needs
to know all the three types of data to accurately predict the presence of Oil. One can
however, correctly predict no Oil with less data.
The winner will be decided on basis of Maximum Area covered and Correctly Explored Oil. A
Wrong Exploration would entail heavy penalty.

Prize Money :
Prize of Rs 8000 and also a separate prize for the best Geo-science Team.

Problem Statement:
Start in an unknown Map world with Bots, Explore and Find Oil Deposits in the Map. You will
have to write a code that reads information from the environment of each Bot and produces
outputs that will determine how the Bots will move around in the Map world. You will also
have to give your verdict on the presence or absence of Oil in the region that you are
Exploring.

Description of the Map World :

Map World :
The map consists of a grid of dimensions 250 x 250. There are obstacles in the map as
indicated by the color green, corresponding to inaccessible regions. At some locations in the
map there are hydrocarbon Oil reserves. These hydrocarbon reserves produce gravity,
magnetic and seismic values over the entire map, the values being the highest near the
deposits and decaying as one moves farther away from the deposits. Hence, at each grid on
the map which does not contain an obstacle, there is one each of gravity, magnetic and
seismic values. The color map illustrates this effect with the darkest regions in the map
(black) containing Oil, while the lightest regions in the map (white) contain no Oil. The
transition from Oil to no Oil is smooth, and is determined by threshold values for the three
kinds of data.
During the actual contest the code will be tested on other maps.
Obstacles :
There are obstacles in the map. These obstacles will be generated randomly during the
contest. A sample obstacle map has been supplied to you for developing your code.

Bots :
At your disposal, you have three kinds of Bots and three of every kind : 3 Gravity Bots, 3
Magnetic Bots and 3 Seismic Bots. The Bots can explore everywhere in the map except in
the regions with obstacles. Each value at a particular grid can only be accessed by the
corresponding type of Bot. For eg. a Gravity Bot will only be able to determine the Gravity
Value at the grid it is exploring. To determine the Magnetic Value at the same grid, a
Magnetic Bot must visit the grid. Similarly, a Seismic Bot can only determine the Seismic
Value at the grid it is exploring. In addition to this, every Bot can see its surrounding
environment, i.e, whether or not there is an obstacle in any of the 8 grids surrounding it.
The three kinds of Bots have different speeds. The Gravity Bots can move once every
iteration. The Magnetic Bots can move at most once every 3 iterations. The Seismic Bots
can move at most once every 5 iterations.
In the maps Gravity Bots are represented by Red *, Magnetic Bots by Blue * and Seismic
Bots by Green *.

Technical Details :
Folder :
All participants will be supplied with a folder named 'Mission_Explore' that contains all the
necessary files for the program to run. There is one file in the folder named
'Mission_Explore_Client.m' . This file can be opened and edited on any computer with
MATLAB installed. No attempt should be made to edit, rename or delete any of the other
files, as it will cause the program to run incorrectly.
List of files in the folder 'Mission_Explore' :
gui.p
gui.fig
run_Mission_Explore.p
initialise_maps.p
Mission_Explore_Server.p
Mission_Explore_Client.m
map1.bmp
Oilguess.txt

Working of the Program :

To run the program, type: 'gui' (without quotes) in the command window of MATLAB (All
files must be in current directory). You will get a GUI interface. In this interface you can
give the starting position of BOTs.X start position and Y start Position (1-250), and
iterations (500-5000).
once you hit "Explore" button, the execution and exploration will start.
In case of compatibility issues and GUI gives error to run the code type
run_Mission_Explore(X_start,Y_start,iterations). where X_start,Y_start are numbers
between 1-250 and Iteration is no of iteration (500-5000).

The file run_Mission_Explore.p uses all the other files and function files. In particular it calls
the function Mission_Explore_Server which in turn calls the function Mission_Explore_Client.
The file Mission_Explore_Server.p hosts a Server function that calls the Client function once
every iteration. At every iteration it passes the required variables to the Client function and
accepts the output variables of the Client function. It processes the outputs, updates the
new information and performs the next iteration. The total number of iterations is fixed.

map1.bmp is a simple map provided so that you can test your code. This map will change
during the contest. The file is used internally by the file run_Mission_Explore.p/gui.p

Working of the File 'Mission_Explore_Client.m' :

The file 'Mission_Explore_Client.m' looks like this :

function [movement,verdict] =
Mission_Explore_Client(posn,env,g_val,m_val,s_val,t_next)

s = size(g_val); /
g_bot = s(1,1); /
s = size(m_val); /
m_bot = s(1,1); / Write your code here
s = size(s_val); /
s_bot = s(1,1); /
/
total_bot = g_bot + m_bot + s_bot; /
movement = floor(9*rand(total_bot,1)); /
verdict = floor(3*rand(total_bot,1)-ones(total_bot,1)); /

end
This is a typical function file (Refer to MATLAB Help for more information on function files)
routinely used in Matlab Programming. The function takes as inputs the
variables posn,env,g_val,m_val,s_val,t_next and returns as outputs the
variables movement,verdict. The outputs of this function make the Bots move around in
the Mapworld (through movement), and decide on the presence/absence/no decision of Oil
at the grids at which the Bots are situated(through verdict). Documentation of the
variables are provided in the next section.

The portion in italics is a random code that makes the Bots move around randomly and also
generates random verdicts. This code is just for illustration purposes. It makes all the Bots
move around in the Map world randomly and also decide randomly on the
presence/absence/no decision of Oil. The participants can run this code to see that the
entire program is working correctly.

The participants will be required to write their own code in the region indicated above after
deleting the code already provided for illustration purposes. It should return the
variables movement and verdict in the format specified in the next section.

Do not edit the first line of the file : function [movement,verdict] =

Mission_Explore_Client(posn,env,g_val,m_val,s_val,t_next) , and the last line of the
file : end

You can add extra functions to this file, to be used by the function 'Mission_Explore_Client'
as and when necessary to write your code. (Refer to MATLAB Help for details of writing
more than one function in a function file).

Function Variable Documentation :

Input Variables:
Position :
(posn)
It is an array of dimensions 9 x 2 which gives the position coordinates of every Bot, at the
beginning of an iteration. The first column contains the 'y' coordinate and the second
column contains the 'x' coordinate of a Bot. Remember that the origin of the Mapworld is
the top-left corner of the map being displayed. Y increases from top to bottom and X
increases from left to right. All Bots start from the same position in the Map.

The first 3 rows gives the position coordinates of the 3 Gravity Bots, the next 3 rows gives
the position coordinates of the 3 Magnetic bots and the last 3 rows gives the position
coordinates of the 3 Seismic Bots. Since the Mapworld is 250 x 250, all coordinate values lie
between the range 1 to 250.
At any instance the 'posn' array may look something like this :

Coordinate Y X
Gr Bot1 15 20
Gr Bot2 24 134
Gr Bot3 200 100
Mg Bot1 150 200
Mg Bot2 100 100
Mg Bot3 180 210
Si Bot1 90 110
Si Bot2 30 30
Si Bot3 45 125

Note :1. Shaded part is the array (9 x 2). 2. This is just an example, this array will change
every iteration.
Environment :
(env)
It is a binary map for every Bot with 0 corresponding to no obstacle and 1 corresponding to
the presence of an obstacle. The range of view of each Bot is same : 1 grid in each
direction. So at each iteration for each Bot the Server gives the Client an environment array
'env'. If Bot is at (Y1,X1) position, it gives 8 values for each Bot corresponding to each grid
around it as shown.

1 2 3
Bot
4 5
(Y1,X1)
6 7 8

Since in total there are 9 Bots (3 of each kind), the actual array passed at each instance is
9x8. First 3 for the 3 Gravity Bots, second 3 for the 3 Magentic Bots and last 3 for the 3
Seismic Bots. At any instant the environment may look like this.

Env -> 1 2 3 4 5 6 7 8
Gr Bot1 0 1 0 0 0 1 1 1
Gr Bot2 1 0 0 0 0 0 1 1
Gr Bot3 1 0 0 0 0 0 0 1
Mg Bot1 0 1 1 0 0 0 0 1
Mg Bot2 0 1 0 0 0 1 0 1
Mg Bot3 1 1 0 0 0 0 0 1
Si Bot1 1 0 0 0 0 1 1 0
Si Bot2 1 1 0 0 0 1 1 0
Si Bot3 0 1 1 1 0 0 0 0

Note :1. Shaded part is the array (9x8). 2. This is just an example, this array will change
every iteration.
Also there is an obstacle surrounding the MAP so bots can't go beyond it, i.e obstacle value
for (x, 251) or (251,y) is always 1.

Types of Data:

(g_val, m_val, s_val )

There are three types of Data : Gravity, Magnetic and Seismic, and hence correspondingly,
there are three types of Bots, viz Gravity Bot, Magnetic Bot and Seismic Bot. These data
here are just dimensionless numbers, which are computed to directly correlate with the
presence of Oil. In real field Exploration, certain features are associated with Hydrocarbon
such as a reservoir rock to host the Hydrocarbon, trap to prevent its escape etc. There can
be different types of traps and resevoir rocks, each associated with Hydrocarbon, and each
having signature gravity, magnetic and seismic values, determined by various exploration
techniques from which actual interpretation is carried out.

The scenario considered here is a simplified version where we assume that when a Gravity
Bot reaches a certain grid it automtically does gravity prospecting and gets the gravity
value corresponding to that grid. Similar is the case with Magnetic and Seismic Bots. When
they reach a certain grid say (x1,y1), they get their respective values at the grid (x1,y1).

The variable 'g_val' is an array of dimensions 3 x 1, containing the Gravity values at the
grids where Gravity Bots 1,2,3 are located at the end of the current iteration.
The variable 'm_val' is an array of dimensions 3 x 1, containing the Magnetic values at the
grids where Magnetic Bots 1,2,3 are located at the end of the current iteration.
The variable 's_val' is an array of dimensions 3 x 1, containing the Seismic values at the
grids where Seismic Bots 1,2,3 are located at the end of the current iteration.

g_val

Bot val
Gr Bot1 90
Gr Bot2 111
Gr Bot3 50
*here the values are 90,111,50 respectively for Gravity Bots 1,2,3.
m_val

Bot val
Mg Bot1 45
Mg Bot2 11
Mg Bot3 82
*here the values are 45,11,82 respectively for Magnetic Bots 1,2,3.

s_val
Bot val
Si Bot1 32
Si Bot2 87
Si Bot3 1
*here the values are 32,87,1 respectively for Seismic Bots 1,2,3.

Note :1. Shaded part is the array. 2. This is just an example, this array will change every
iteration.

Time Till Next Move :

(t_nxt)

This is an array of dimensions 9 x 1 which indicates the number of iterations after

which each Bot can move again(including the current iteration). A Bot can move
only when its corresponding 't_nxt' value is 0. Since, Gravity Bots can move every iteration,
this number is 0 for all Gravity Bots during all iterations. Since Magnetic Bots can move
once at most every 3 iterations, this number is either 0, 1 or 2 for the Magnetic Bots.
Similarly, the number is either 0, 1, 2, 3 or 4 for a Seismic Bot, which is allowed to move
once at most every 5 iterations.
The 't_nxt' value for each Bot decreases by 1 once every iteration, if it is not 0. When a Bot
moves, the 't_nxt' value for it is set to 0, 2 or 4 corresponding to if it is a Gravity Bot,
Magnetic Bot or a Seismic Bot respectively.
The first 3 values are for the 3 Gravity Bots, the next 3 values are for the 3 Magnetic Bots
while the last 3 values are for the 3 Seismic Bots. For e.g, at some instance the t_nxt array
may look something like this:

Bots Move
Gr Bot1 0
Gr Bot2 0
Gr Bot3 0
Mg Bot1 0
Mg Bot2 2
Mg Bot3 1
Si Bot1 2
Si Bot2 4
Si Bot3 0

Note :1. Shaded part is the array. 2. This is just an example, this array will change every
iteration.

Output Variables :

Movemnent :

(movement)

At each iteration you must give the direction of movement for each Bot at the next iteration.
A bot can move in any of the 8 grids surrounding it. However, it cannot move if there is an
obstacle in a grid that you are trying to move it to, or if 't_nxt' for the corresponding bot is
not 0. For each Bot it must be a number between 0 to 8. If you pass any other value
then it will be considered as 0 by default, and the Bot will not move.

1 2 3
Bot (0)
4 5
(Y1,X1)
6 7 8

0 corresponds to no movement, 1 corresponds to diagonally upwards to left (Y1 - 1 and X1

- 1) (origin is at top left corner). 5 means one grid right.
i.e. (Y1,X1 + 1) and so on.

Since there are 9 Bots so this will be array of 9 x 1 dimensions. The first 3 values are for the
3 Gravity Bots, the next 3 values are for the 3 Magnetic Bots while the last 3 values are for
the 3 Seismic Bots. For e.g, at some instance the 'movement' array may look something like
this:

Bots Move
Gr Bot1 8
Gr Bot2 1
Gr Bot3 3
 Mg Bot1 6
Mg Bot2 0
Mg Bot3 4
Si Bot1 2
Si Bot2 5
Si Bot3 0

Note :1. Shaded part is the array. 2. This is just an example, this array will change every
iteration.

In all passes it(this array) must be in agreement with enviroment (env) variable. If you give
movement in the direction where there is a obstacle, the Bot will not move and remain
stationary.

Verdict (Oil find):

(verdict)

There is some threshold value attached with all the three types of data (Gravity, Magnetic
and Seismic) for detecting the presence of Oil. For assured Hydrocarbon presence,
Gravity value (g_val) must be > 60 ; Magnetic Value (m_val) must be>70 ;
Seismic Value (s_val)must be >80. The aim of the Bots is to explore for Oil and give
prediction for Oil presence at maximum grids and cover maximum area. To accurately say
that there is Oil one must determine all the three values. However, you may say that there
is no Oil even on the basis of a single value determined. Say Gravity value is <60, you can
safely predict no Oil but if its > 60 you need other values for correct prediction.

Also, it must be noted that even though these values may decrease sharply, they vary
continuously.

'verdict' is a 9 x 1 array which contains your decision about the presence/absence/no

decision of oil at all the grids where the Bots are located at the current iteration. The first 3
contain the verdict for the grids at which the 3 Gravity Bots are located, the next 3 are for
the grids at which the 3 Magnetic Bots are located, while the last 3 are for the grids at
which the 3 Seismic Bots are located. The codes for the decision are as follows :

Confirm Oil : 1
No Decision : 0
Confirm No Oil : -1
Passing any other value than -1, 0 or 1 will be considered to be 0 as default for the
corresponding grid.

Remember that you can change your verdict about a particular grid at a later iteration
(provided you visit it at a later stage with some Bot), and the points will be calculated at
every iteration depending on your cumulative correct and wrong prediction counts at that
iteration ONLY. You will not get extra points for predicting a grid with oil correctly more
than once, nor will you be penalized repeatedly for wrongly predicting a grid with oil, for
example.
 At any iteration the 'verdict' array may look something like this :
Bots Verdict
Gr Bot1 0
Gr Bot2 1
Gr Bot3 -1
Mg Bot1 -1
Mg Bot2 -1
Mg Bot3 0
Si Bot1 1
Si Bot2 1
Si Bot3 0

Note :1. Shaded part is the array. 2. This is just an example, this array will change every
iteration.
Note that in the DISCOVERED WORLD Plot (output map): your verdicts are represented as
Oil Present (1) : black , No Decision (only explored) (0): yellow, Oil Not Present (-1) :
green, irrespective of whether or not your verdicts are correct or incorrect.

Points System:
3 Different runs will be considered for 3 different Oil maps and Corresponding Obstacle
maps of varying level of difficulty. All the participant programs will run for the same number
of iterations for a particular map and will start at the same position in the map.

The points are calculated as following :

1. +1 Point for each grid covered / Explored (EX). That is 1 point * Grids Explored.
(1*EX). (shown as Ex in GUI)
2. +2 Points for correctly identifying "No Oil" present in each grid. That is 2 * CSN
.Correctly identified No Oil. (Showed CSN in GUI)
3. +10 Points for correctly identifying "Oil" Presence. (10* CS), (Showed CS in GUI)
4. -10 Points for missing existing Oil and predicting "No Oil" where there is Oil. (-
10*WSN). (WSN in GUI)(Huge loss to company !!)
5. -15 Points for predicting "Oil' where there is no Oil. (-15*WS) (WS in GUI) (Company
drills where there is no Oil and Boom. Bankrupt !!!)
6. Points RUN1 = { (1*EX) + (2 * CSN) + (10* CS) - (10*WSN) - (15*WS) }
7. Total points = ( RUN1 + RUN2 + RUN3 )
File Submission Format:
You need to write your code in the file 'Mission_Explore_Client.m' . Delete the sample test
code given and write your own code (functions) in it (as has been discussed previously in
the section 'Technical Details').

When you register, you will be mailed a Registration ID. Put all downloaded files
along with your edited Mission_Explore_Client.m file in a folder whose name
should be same as your Registration ID and zipped and e-mailed
to [email protected].
You must include a file named 'info.txt' which must contain the names, email address,
phone numbers of all the group members and Colleges / Institutes of the group.
Important Constraint :
Each calling instance of the client program Mission_Explore_Client.m(your code) must not
take more than 350 msec to run. That is 1000 iterations must not take more than 10
minutes in any case. if so you will be disqualified. (Use efficient algorithms / avoid
conditionals).
Useful Information and Tips:
1. Maps will be of same dimensions 250X250, but Obstacle Map and Oil Map may
change with varying levels.
2. Iterations will be according to maps but will never exceed 5000 and will never be
less than 500. You can expect an average of 2500-3000 iterations for most maps.
3. The program must be submitted in asked format.
4. You are encouraged to store all the data that you are receiving at every iteration
with the calling of the Client Program in some suitable format in a file. You can use
this data at subsequent iterations to improve and speed up your Oil search. (Refer to
MATLAB Help for creating files and reading data from files in MATLAB)
5. Avoid using statements like if and else as much as possible to speed up the runtime
of your algorithm.
6. Use Shortest Path Optimization algorithms to move around in the map.
7. Download server client at : http://www.prithvionline.in/Mission_Explore_7.1.rar
8. To register mail details to [email protected] or
visit http://www.prithvionline.in/participantregister.html

©Bhaskar and Rahul Sarkar

SEG Student Chapter IIT Kharagpur,
This is created by Bhaskar and Rahul Sarkar For Prithvi, G-wave, online programming event
of Prithvi.
For queries / bugs contact :
[email protected]
[email protected]

www.prithvionline.in