/**
* The constructor for TL controllers
*
* @param The model being used.
*/
public SL1TLC(Infrastructure infra) throws InfraException {
super(infra);
Node[] nodes =
infra.getAllNodes(); // Moet Edge zijn eigenlijk, alleen testSimModel knalt er dan op
int num_nodes = nodes.length;
count = new Vector();
int numSigns = infra.getAllInboundLanes().size();
q_table = new float[numSigns + 1][][][];
int num_specialnodes = infra.getNumSpecialNodes();
for (int i = 0; i < nodes.length; i++) {
Node n = nodes[i];
Drivelane[] dls = n.getInboundLanes();
for (int j = 0; j < dls.length; j++) {
Drivelane d = dls[j];
Sign s = d.getSign();
int id = s.getId();
int num_pos_on_dl = d.getCompleteLength();
q_table[id] = new float[num_pos_on_dl][][];
for (int k = 0; k < num_pos_on_dl; k++) {
q_table[id][k] = new float[num_specialnodes][];
for (int l = 0; l < q_table[id][k].length; l++) {
q_table[id][k][l] = new float[2];
q_table[id][k][l][0] = 0.0f;
q_table[id][k][l][1] = 0.0f;
}
}
}
}
System.out.println("Startet med Alpha = " + alpha);
random_number = new Random();
}
/**
* Calculates how every traffic light should be switched Per node, per sign the waiting roadusers
* are passed and per each roaduser the gain is calculated.
*
* @param The TLDecision is a tuple consisting of a traffic light and a reward (Q) value, for it
* to be green
* @see gld.algo.tlc.TLDecision
*/
public TLDecision[][] decideTLs() {
int num_dec;
int num_tld = tld.length;
// Determine wheter it should be random or not
boolean do_this_random = false;
if (random_number.nextFloat() < random_chance) do_this_random = true;
for (int i = 0; i < num_tld; i++) {
num_dec = tld[i].length;
for (int j = 0; j < num_dec; j++) {
Sign currenttl = tld[i][j].getTL();
float gain = 0;
Drivelane currentlane = currenttl.getLane();
int waitingsize = currentlane.getNumRoadusersWaiting();
ListIterator queue = currentlane.getQueue().listIterator();
if (!do_this_random) {
for (; waitingsize > 0; waitingsize--) {
Roaduser ru = (Roaduser) queue.next();
int pos = ru.getPosition();
Node destination = ru.getDestNode();
gain +=
q_table[currenttl.getId()][pos][destination.getId()][1]
- q_table[currenttl.getId()][pos][destination.getId()][0]; // red - green
}
float q = gain;
} else gain = random_number.nextFloat();
tld[i][j].setGain(gain);
}
}
return tld;
}
protected Sign getSign(Dictionary laneDictionary, int id) {
Drivelane tmp = (Drivelane) (laneDictionary.get(new Integer(id)));
if (tmp == null) {
return null;
} else {
return tmp.getSign();
}
}
/* Returns whether or not the tails of the lanes not being accesible by the given array of Signs are free */
public boolean areOtherTailsFree(Sign[] mayUse) {
boolean[] pos = new boolean[4];
Road[] roads = getAllRoads();
Drivelane lane;
int thisRoad;
boolean[] targets;
for (int i = 0; i < 4; i++) pos[i] = true;
int num_mayuse = mayUse.length;
for (int i = 0; i < num_mayuse; i++) {
lane = mayUse[i].getLane();
try {
thisRoad = isConnectedAt(lane.getRoad());
} catch (InfraException e) {
thisRoad = 0;
System.out.println("Something went wrong in areOtherTailsFree()");
}
targets = lane.getTargets();
if (targets[0]) {
pos[(thisRoad + 1) % 4] = false;
} else if (targets[1]) {
pos[(thisRoad + 2) % 4] = false;
} else if (targets[2]) {
pos[(thisRoad + 3) % 4] = false;
}
}
int num_check = 0;
for (int i = 0; i < 4; i++) {
if (pos[i] && roads[i] != null) {
Drivelane[] check = new Drivelane[0];
try {
check = roads[i].getOutboundLanes(this);
} catch (Exception e) {
check = new Drivelane[0];
System.out.println("Something went wrong in areOtherTailsFree() 2");
}
num_check = check.length;
for (int j = 0; j < num_check; j++) {
if (!check[j].isTailFree()) {
return false;
}
}
}
}
return true;
}
/* Needs Testing! */
public Drivelane[] getLanesLeadingFrom(Drivelane lane, int ruType) throws InfraException {
Road road = lane.getRoad();
// Road[] which will contain the Roads of this Node in a sorted fashion:
// [0] == the drivelanes on this Road will have to turn left to get to 'road', ..
Road[] srt_rarr = new Road[3];
if (allRoads[0] == road) {
srt_rarr[0] = allRoads[1]; // Must turn left
srt_rarr[1] = allRoads[2]; // Must go straight on
srt_rarr[2] = allRoads[3]; // Must turn right
} else if (allRoads[1] == road) {
srt_rarr[0] = allRoads[2];
srt_rarr[1] = allRoads[3];
srt_rarr[2] = allRoads[0];
} else if (allRoads[2] == road) {
srt_rarr[0] = allRoads[3];
srt_rarr[1] = allRoads[0];
srt_rarr[2] = allRoads[1];
} else {
srt_rarr[0] = allRoads[0];
srt_rarr[1] = allRoads[1];
srt_rarr[2] = allRoads[2];
}
// System.out.println("Junction getLanesLeadingFrom "+nodeId);
Vector v = new Vector();
Drivelane[] lanes;
int num_lanes;
int cnt_lanes = 0;
boolean[] targets = lane.getTargets();
for (int i = 0; i < 3; i++) {
if (srt_rarr[i] != null && targets[i] == true) {
// System.out.println("Road at target:"+i+" isnt null, getting Outboundlanes");
lanes = srt_rarr[i].getOutboundLanes(this);
num_lanes = lanes.length;
// System.out.println("Num lanes :"+num_lanes);
for (int j = 0; j < num_lanes; j++) {
Drivelane l = lanes[j];
// System.out.println("Lane"+j+" being checked now. Has type:"+l.getType());
if (l.mayUse(ruType)) {
v.addElement(l);
cnt_lanes++;
}
}
}
}
return (Drivelane[]) v.toArray(new Drivelane[cnt_lanes]);
}
/**
* Calculates how every traffic light should be switched
* Per node, per sign the waiting roadusers are passed and per each roaduser the gain is calculated.
* @param The TLDecision is a tuple consisting of a traffic light and a reward (Q) value, for it to be green
* @see gld.algo.tlc.TLDecision
*/
public TLDecision[][] decideTLs()
{
int num_dec, currenttlID, waitingsize, pos, destID;
float gain =0, passenger_factor;
Sign currenttl;
Drivelane currentlane;
ListIterator queue;
Roaduser ru;
//Determine wheter it should be random or not
boolean randomrun = false;
if (random_number.nextFloat() < random_chance) randomrun = true;
for (int i=0;i<num_nodes;i++) {
num_dec = tld[i].length;
for(int j=0;j<num_dec;j++) {
currenttl = tld[i][j].getTL();
currenttlID = currenttl.getId();
currentlane = currenttl.getLane();
waitingsize = currentlane.getNumRoadusersWaiting();
queue = currentlane.getCompleteQueue().listIterator();
gain = 0;
for(; waitingsize>0; waitingsize--) {
ru = (Roaduser) queue.next();
pos = ru.getPosition();
destID = ru.getDestNode().getId();
passenger_factor = ru.getNumPassengers();
gain += passenger_factor * (q_table[currenttlID][pos][destID][red_index] - q_table[currenttlID][pos][destID][green_index]); //red - green
}
if(trackNode!=-1 && i==trackNode) {
Drivelane currentlane2 = tld[i][j].getTL().getLane();
boolean[] targets = currentlane2.getTargets();
System.out.println("node: "+i+" light: "+j+" gain: "+gain+" "+targets[0]+" "+targets[1]+" "+targets[2]+" "+currentlane2.getNumRoadusersWaiting());
}
if(randomrun)
gain = random_number.nextFloat();
tld[i][j].setGain(gain);
}
}
return tld;
}
public Drivelane[] getLanesLeadingTo(Drivelane lane, int ruType) throws InfraException {
Road road = lane.getRoad();
// Road[] which will contain the Roads of this Node in a sorted fashion:
// [0] == the drivelanes on this Road will have to turn left to get to 'road', ..
Road[] srt_rarr = new Road[3];
if (allRoads[0] == road) {
srt_rarr[0] = allRoads[3]; // Must turn left
srt_rarr[1] = allRoads[2]; // Must go straight on
srt_rarr[2] = allRoads[1]; // Must turn right
} else if (allRoads[1] == road) {
srt_rarr[0] = allRoads[0];
srt_rarr[1] = allRoads[3];
srt_rarr[2] = allRoads[2];
} else if (allRoads[2] == road) {
srt_rarr[0] = allRoads[1];
srt_rarr[1] = allRoads[0];
srt_rarr[2] = allRoads[3];
} else {
srt_rarr[0] = allRoads[2];
srt_rarr[1] = allRoads[1];
srt_rarr[2] = allRoads[0];
}
Vector v = new Vector();
Drivelane[] lanes;
int num_lanes;
int cnt_lanes = 0;
boolean[] targets;
for (int i = 0; i < 3; i++) {
if (srt_rarr[i] != null) {
lanes = srt_rarr[i].getInboundLanes(this);
num_lanes = lanes.length;
for (int j = 0; j < num_lanes; j++) {
Drivelane l = lanes[j];
targets = l.getTargets();
if (targets[i] == true && l.mayUse(ruType)) {
v.addElement(l);
cnt_lanes++;
}
}
}
}
return (Drivelane[]) v.toArray(new Drivelane[cnt_lanes]);
}
public void updateRoaduserMove(Roaduser ru, Drivelane prevlane, Sign prevsign, int prevpos, Drivelane dlanenow, Sign signnow, int posnow, PosMov[] posMovs, Drivelane desired)
{
// Roaduser has just left the building
if(dlanenow == null || signnow == null) {
return;
}
//This ordening is important for the execution of the algorithm!
int Ktl = dlanenow.getNumRoadusersWaiting();
if(prevsign.getType()==Sign.TRAFFICLIGHT && (signnow.getType()==Sign.TRAFFICLIGHT || signnow.getType()==Sign.NO_SIGN)) {
boolean light = prevsign.mayDrive();
Node dest = ru.getDestNode();
recalcP(prevsign, prevpos, dest, light, signnow, posnow, Ktl);
recalcVa(prevsign, prevpos, dest);
recalcV(prevsign, prevpos, dest, light, Ktl);
recalcQa(prevsign, prevpos, dest, light, signnow, posnow, posMovs);
recalcQ(prevsign, prevpos, dest, light, signnow, posnow, posMovs, Ktl);
}
}
public void setInfrastructure( Infrastructure infra )
{ super.setInfrastructure(infra);
Node[] nodes = infra.getAllNodes();
num_nodes = nodes.length;
try{
int numSigns = infra.getAllInboundLanes().size();
q_table = new float [numSigns][][][];
qa_table = new float [numSigns][][][];
v_table = new float [numSigns][][];
va_table = new float [numSigns][][];
count = new Vector[numSigns][][];
p_table = new Vector[numSigns][][];
pKtl_table = new Vector[numSigns][][];
int num_specialnodes = infra.getNumSpecialNodes();
for (int i=0; i<num_nodes; i++) {
Node n = nodes[i];
Drivelane[] dls = dls = n.getInboundLanes();
int num_dls = num_dls = dls.length;
// huh?
Drivelane [] lanes = new Drivelane[numSigns];
infra.getAllInboundLanes().copyInto(lanes);
for (int j=0; j<num_dls; j++) {
Drivelane d = dls[j];
Sign s = d.getSign();
int id = d.getId();
int num_pos_on_dl = d.getCompleteLength();
q_table[id] = new float [num_pos_on_dl][][];
qa_table[id] = new float [num_pos_on_dl][][];
v_table[id] = new float [num_pos_on_dl][];
va_table[id] = new float [num_pos_on_dl][];
count[id] = new Vector[num_pos_on_dl][];
p_table[id] = new Vector[num_pos_on_dl][];
pKtl_table[id] = new Vector[num_pos_on_dl][];
for (int k=0; k<num_pos_on_dl; k++) {
q_table[id][k] = new float[num_specialnodes][2];
qa_table[id][k] = new float[num_specialnodes][2];
v_table[id][k] = new float[num_specialnodes];
va_table[id][k] = new float[num_specialnodes];
count[id][k] = new Vector[num_specialnodes];
p_table[id][k] = new Vector[num_specialnodes];
pKtl_table[id][k] = new Vector[num_specialnodes];
for (int l=0; l<num_specialnodes;l++) {
q_table[id][k][l][0] = 0.0f;
q_table[id][k][l][1] = 0.0f;
qa_table[id][k][l][0] = 0.0f;
qa_table[id][k][l][1] = 0.0f;
v_table[id][k][l] = 0.0f;
va_table[id][k][l] = 0.0f;
count[id][k][l] = new Vector();
p_table[id][k][l] = new Vector();
pKtl_table[id][k][l] = new Vector();
}
}
}
}
random_number = new Random();
}
catch(Exception e) { System.out.println("Error."); }
}