/**
* Methode um die Endvorgaenge des Netzplanes zu finden fuer die Berechnung der spaetesten
* Start/End-Zeiten.
*
* @param vorgang -> LinkedListe mit den Vorgaengen
* @return backInit
* @throws SQLException
*/
public LinkedList<Vorgang> defineOrdersLast(LinkedList<Vorgang> vorgang) throws SQLException {
if (vorgang.size() != 0) {
for (int i = 0; i < vorgang.size(); ++i) {
if (con.ladeAlleNachf(vorgang.get(i).getVorgangId()).size() == 0) {
vorgang.get(i).setSaz(netz.getEnde());
this.backInit.add(vorgang.get(i));
}
}
}
return backInit;
}
/**
* Berechnung der Netzplanes (Faz, Fez, Saz, Sez) und der Durchfuehrbarkeit.
*
* @return netzDurabilityCheck -> true ==> durchfuehrbar; false ==> nicht durchfuehrbar
* @throws SQLException
*/
public boolean netzPlanBerechnung() throws SQLException {
if (this.netz.getFreierPuffer() > -1) {
// Abhängigkeiten setzen
this.defineOrdersFirst(vorgangList);
this.refInitSize = initVorgang.size();
for (int i = 0; i < this.initVorgang.size(); ++i) {
if (this.listIdCheck(initVorgang.get(i).getVorgangId()) == false) {
sortierteVorgaenge.add(initVorgang.get(i));
}
}
for (int j = 0; j < sortierteVorgaenge.size(); ++j) {
sortierteVorgaenge
.get(j)
.setNachf(con.ladeAlleNachf(sortierteVorgaenge.get(j).getVorgangId()));
for (int k = 0; k < sortierteVorgaenge.get(j).getNachf().size(); ++k) {
if (this.listIdCheck(sortierteVorgaenge.get(j).getNachf().get(k).getVorgangId())
== false) {
sortierteVorgaenge.add(sortierteVorgaenge.get(j).getNachf().get(k));
}
}
}
for (int l = 0; l < sortierteVorgaenge.size(); ++l) {
if (l < this.refInitSize) {
sortierteVorgaenge.get(l).setFez(sortierteVorgaenge.get(l).getDauer());
}
if (l >= refInitSize) {
vorgaengerCash = con.ladeAlleVorg(sortierteVorgaenge.get(l).getVorgangId());
for (int z = 0; z < vorgaengerCash.size(); ++z) {
for (int y = 0; y < sortierteVorgaenge.size(); ++y) {
if (vorgaengerCash.get(z).getVorgangId()
== sortierteVorgaenge.get(y).getVorgangId()) {
vorgaengerCash.get(z).setFez(sortierteVorgaenge.get(y).getFez());
}
}
}
this.minSt = vorgaengerCash.get(0).getFez();
for (int p = 0; p < vorgaengerCash.size(); ++p) {
double minRef = vorgaengerCash.get(p).getFez();
if (minRef < minSt) {
minSt = minRef;
}
sortierteVorgaenge.get(l).setFaz(minSt);
sortierteVorgaenge
.get(l)
.setFez(sortierteVorgaenge.get(l).getFaz() + sortierteVorgaenge.get(l).getDauer());
vorgaengerCash.clear();
}
}
}
System.out.println("===============================================================");
System.out.println("START DER BERECHNUNG DER SPAETESTEN ANFANGSZEITEN UND ENDZEITEN");
System.out.println("===============================================================");
this.sortierteVorgaengeRef = sortierteVorgaenge;
this.defineOrdersLast(sortierteVorgaenge);
this.refBackInitSize = backInit.size();
for (int n = 0; n < backInit.size(); ++n) {
for (int o = 0; o < sortierteVorgaenge.size(); ++o) {
if (backInit.get(n).getVorgangId() == sortierteVorgaenge.get(o).getVorgangId()) {
sortierteVorgaenge.get(o).setSez(netz.getEnde());
sortierteVorgaenge.get(o).setSaz(netz.getEnde() - sortierteVorgaenge.get(o).getDauer());
for (int x = 0; x < sortierteVorgaengeRef.size(); ++x) {
if (sortierteVorgaengeRef.get(x).getVorgangId() == backInit.get(n).getVorgangId()) {}
}
}
}
}
for (int u = sortierteVorgaengeRef.size() - 1; u > -1; --u) {
vorgaengerCash = con.ladeAlleVorg(sortierteVorgaengeRef.get(u).getVorgangId());
if (vorgaengerCash.size() != 0) {
for (int y = 0; y < vorgaengerCash.size(); ++y) {
for (int c = 0; c < sortierteVorgaenge.size(); ++c) {
if (vorgaengerCash.get(y).getVorgangId()
== sortierteVorgaenge.get(c).getVorgangId()) {
for (int v = 0; v < sortierteVorgaenge.size(); ++v) {
if (sortierteVorgaengeRef.get(u).getVorgangId()
== sortierteVorgaenge.get(v).getVorgangId()) {
if (this.refSaz
> sortierteVorgaenge.get(c).getSez()
- sortierteVorgaenge.get(c).getDauer()
|| sortierteVorgaenge.get(c).getSaz() == 0) {
sortierteVorgaenge.get(c).setSez(sortierteVorgaenge.get(v).getSaz());
sortierteVorgaenge
.get(c)
.setSaz(
sortierteVorgaenge.get(c).getSez()
- sortierteVorgaenge.get(c).getDauer());
this.refSaz = sortierteVorgaenge.get(c).getSez();
}
}
}
}
}
}
}
}
vorgaengerCash.clear();
}
if (this.checkBetriebsmittelStatus(sortierteVorgaenge) == false) {
this.netzDurabilityCheck = false;
System.out.println(
"=================================================================================================");
System.out.println(
"Es ist nicht möglich den Netzplan mit den vorhandenen Betriebsmittelkapazitäten auszufuehren!!!\n");
System.out.println(
"=================================================================================================");
for (int n = 0; n < bmgOutOfKapa.size(); ++n) {
System.out.println(
"Dies liegt an dem Betriebsmittel mit der Id: "
+ bmgOutOfKapa.get(n).getBetrMittelGrId());
System.out.println("Betriebsmittelname: " + bmgOutOfKapa.get(n).getNameBetrMittelGr());
System.out.println(
"Der Vorgang, der die Kapazitaet der Betriebsmittelgruppe ueberschritten hat: "
+ bmgOutOfKapa.get(n).getVorgangId());
}
} else {
this.netzDurabilityCheck = true;
System.out.println(
"=================================================================================================");
System.out.println(
"Die Betriebsmittelkapazitaeten reichen aus um den Netzplan auszufuehren!!!\n");
System.out.println(
"=================================================================================================");
for (int d = 0; d < sortierteVorgaenge.size(); ++d) {
System.out.println("VorgangId: " + sortierteVorgaenge.get(d).getVorgangId());
System.out.println("VorgangsName: " + sortierteVorgaenge.get(d).getName());
System.out.println("VorgangsDauer: " + sortierteVorgaenge.get(d).getDauer());
System.out.println("VorgangsFaz: " + sortierteVorgaenge.get(d).getFaz());
System.out.println("VogangsFez:" + sortierteVorgaenge.get(d).getFez());
System.out.println("VorgangsSaz: " + sortierteVorgaenge.get(d).getSaz());
System.out.println("VorgangsSez: " + sortierteVorgaenge.get(d).getSez() + "\n\n\n");
}
}
return this.netzDurabilityCheck;
}