Newer
Older
import java.util.List;
import java.util.ArrayList;
public static final int MIN_TIMEDIFF = 6;
private List<Channel> chanlist;
private List<Droplet> dropletList;
public Nloc (List<Channel> chanlist) {
this.chanlist = chanlist;
this.dropletList = new ArrayList<Droplet>();
}
public void addChannel(Channel chan) {
chanlist.add(chan);
}
public Pump getPump() {
Pump pump = null;
for (Channel chan : chanlist) {
if (chan instanceof Pump) pump = (Pump)chan;
}
return pump;
}
public boolean simulate() {
boolean works = true;
while (!allDropletsInSink()) {
try {
this.moveDroplets();
} catch (CoalescedDropletException e) {
works = false;
System.out.println(e.getDroplet());
break;
}
}
return works;
}
public List<Droplet> getDropletList() {
return dropletList;
}
public void moveDroplets() throws CoalescedDropletException {
for (Droplet dr : dropletList) {
dr.move();
}
for (Droplet dr: dropletList) {
if (dr.coalesce()) throw new CoalescedDropletException(dr);
public Pump generateDropletSequence(List<String> modules)
throws BifurcationTooShortException {
Pump pump = this.getPump();
int timediff = MIN_TIMEDIFF + 1;
List<Channel> modPath = this.getModulesByName(modules);
List<List<Channel>> pathlist = this.getAllPaths();
List<Channel> desiredPath = getDesiredPath(modPath, pathlist);
int noOfDroplets = this.getNumberOfDroplets(desiredPath);
pump.setSteps(noOfDroplets + (noOfDroplets - 1) * timediff);
for (int i = 0; i < noOfDroplets; i++){
if (!pump.containsDroplets()) {
dropletList.add(new Droplet(DropletType.PAYLOAD,
new Position(pump,1)));
dropletList.add(new Droplet(DropletType.HEADER,
new Position(pump,i + i * timediff + 1)));
}
}
return pump;
}
public boolean allDropletsInSink() {
boolean allInSink = true;
for (Droplet dr : dropletList) {
allInSink &= dr.isInSink();
}
return allInSink;
}
public int getNumberOfDroplets(List<Channel> desiredPath)
throws BifurcationTooShortException {
int numOfDroplets = 1;
ListIterator<Channel> iter = desiredPath.listIterator();
while(iter.hasNext()) {
Channel current = iter.next();
if (current.isBifurcation()) {
Channel following = iter.next();
int neededMinLength = numOfDroplets * Nloc.MIN_TIMEDIFF +
numOfDroplets - 1;
int prio = current.getChildrenList().indexOf(following) + 1;
for (int i = 1; i < prio; i++) {
int bifurcChildHSteps = current.getChildrenList().get(i).getHSteps();
if (bifurcChildHSteps < neededMinLength) {
throw new BifurcationTooShortException(current, neededMinLength);
}
}
numOfDroplets *= (current.getChildrenList().indexOf(following) + 1);
}
}
return numOfDroplets;
}
public List<Channel> getDesiredPath(List<Channel> modules,
List<List<Channel>> pathlist) {
List<Channel> found = new ArrayList<Channel>();
for (List<Channel> path : pathlist) {
if (path.containsAll(modules)) {
found = path;
}
}
return found;
}
private List<Channel> getModulesByName(List<String> names) {
List<Channel> ret = new ArrayList<Channel>();
for (String name : names) {
for (Channel ch : chanlist) {
if (ch instanceof Module && ch.getName().equals(name)) {
ret.add(ch);
}
}
}
return ret;
}
public List<List<Channel>> getAllPaths() {
List<List<Channel>> pl = new ArrayList<List<Channel>>();
List<Channel> path = new ArrayList<Channel>();
getAllPathsRecursive(this.getPump(), path, pl);
private void getAllPathsRecursive(Channel chan, List<Channel> path, List<List<Channel>> pathlist) {
if (chan.getChildrenList().isEmpty()) {
pathlist.add(path);
} else {
for (Channel ch : chan.getChildrenList()) {
getAllPathsRecursive(ch, new ArrayList<Channel>(path), pathlist);
}
}
}