Adds KillSwitch & SwitchObjectiveFunction

src/addOns/JSON/HolonElementSketch.java

@@ -4,6 +4,7 @@ import classes.Constrain;
 import classes.Flexibility;
 import classes.HolonElement;
 import classes.HolonElement.Priority;
+import classes.HolonObject;
 import ui.model.Model;
 
 public class HolonElementSketch {
@@ -24,11 +25,11 @@ public class HolonElementSketch {
 		this.maxAmount = maxAmount;
 		this.energy = energy;
 	}
-	public HolonElement createHolonElement(Model model, boolean active, String nameOfHolonObject) {
-		HolonElement ele = new HolonElement(name, Random.nextIntegerInRange(minAmount, maxAmount + 1), energy , model);
+	public HolonElement createHolonElement(HolonObject parentObject, boolean active) {
+		HolonElement ele = new HolonElement(parentObject, name, Random.nextIntegerInRange(minAmount, maxAmount + 1), energy);
 		ele.setActive(active);
-		if(onFlex != null && Random.nextDouble() < onFlex.flexChance)addFlex(ele, nameOfHolonObject, true);
-		if(offFlex != null && Random.nextDouble() < offFlex.flexChance)addFlex(ele, nameOfHolonObject, false);
+		if(onFlex != null && Random.nextDouble() < onFlex.flexChance)addFlex(ele, parentObject.getName(), true);
+		if(offFlex != null && Random.nextDouble() < offFlex.flexChance)addFlex(ele, parentObject.getName(), false);
 		ele.setPriority(Priority.valueOf(priority));
 		return ele;
 	}

src/addOns/Randomizer.java

@@ -234,7 +234,7 @@ public class Randomizer implements AddOn {
 			hObject.getElements().clear();
 			int randomAmountOfElementsToAdd = Random.nextIntegerInRange(minAmountOfElements, maxAmountOfElements + 1);
 			for(int i = 0; i < randomAmountOfElementsToAdd; i++) {
-				HolonElement ele = holonElementCatalog.get(Random.nextIntegerInRange(0, holonElementCatalog.size())).createHolonElement(control.getModel(), Random.nextDouble() < randomChance , hObject.getName());
+				HolonElement ele = holonElementCatalog.get(Random.nextIntegerInRange(0, holonElementCatalog.size())).createHolonElement(hObject, Random.nextDouble() < randomChance );
 				if(this.useRandomPriority) ele.setPriority(prioPanel.getPriority());
 				hObject.getElements().add(ele);				
 			}

src/algorithm/binary/AcoAlgorithm.java

@@ -49,12 +49,6 @@ public class AcoAlgorithm extends AlgorithmFrameworkFlex{
 	}
 
 	
-	
-	
-	@Override
-	protected double evaluateState(DecoratedState actualstate) {
-		return ObjectiveFunctionByCarlos.getFitnessValueForState(actualstate);
-	}
 
 
 	@Override

src/algorithm/binary/GaAlgorithm.java

@@ -54,11 +54,6 @@ public class GaAlgorithm extends AlgorithmFrameworkFlex{
 	      newFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 	}
 	
-	@Override
-	protected double evaluateState(DecoratedState actualstate) {
-		return ObjectiveFunctionByCarlos.getFitnessValueForState(actualstate);
-	}
-
 
 	@Override
 	protected int getProgressBarMaxCount() {

src/algorithm/binary/PsoAlgorithm.java

@@ -53,11 +53,6 @@ public class PsoAlgorithm extends AlgorithmFrameworkFlex{
 		addBooleanParameter("moreInformation", moreInformation , booleanValue -> moreInformation = booleanValue);
 	}
 	
-	@Override
-	protected double evaluateState(DecoratedState actualstate) {
-		return ObjectiveFunctionByCarlos.getFitnessValueForState(actualstate);
-	}
-
 
 	@Override
 	protected int getProgressBarMaxCount() {

src/algorithm/objectiveFunction/ObjectiveFunctionByCarlos.java

@@ -13,6 +13,8 @@ public class ObjectiveFunctionByCarlos {
 	
 	//weight for f_g(H)
 	static double w_eb = .3, w_state = .3, w_pro = .2, w_perf = .1, w_holon=.1;
+	//killswitch weights
+	//static double w_eb = 0.5, w_state = 0.5, w_pro = 0.0f, w_perf = .0, w_holon=.0;
 	
 	//kappas for squashing function
 //	
@@ -91,7 +93,7 @@ public class ObjectiveFunctionByCarlos {
 	 * @param state
 	 * @return f_g value between 0 and 100
 	 */
-	static public float getFitnessValueForState(DecoratedState state) {
+	static public double getFitnessValueForState(DecoratedState state) {
 		
 		//Calculate f_eb the penalty for unbalenced energy in the network
 		double f_eb = 0;
@@ -183,7 +185,7 @@ public class ObjectiveFunctionByCarlos {
 //		System.out.println( " f_perf=" + q4);
 //		System.out.println( " f_holon=" + q5);
 //		
-		return (float) (w_eb * q1 + w_state * q2 + w_pro * q3 + w_perf * q4 + w_holon * q5);
+		return  w_eb * q1 + w_state * q2 + w_pro * q3 + w_perf * q4 + w_holon * q5;
 		//return (float) (f_eb + f_state + f_pro + f_perf + f_holon);
 	}
 	

src/algorithm/objectiveFunction/SwitchObjectiveFunction.java

@@ -0,0 +1,60 @@
+package algorithm.objectiveFunction;
+
+import ui.model.DecoratedNetwork;
+import ui.model.DecoratedState;
+public class SwitchObjectiveFunction {
+	
+	//weights
+	static double w_eb = .5, w_state = .5;
+	static double k_eb = 1050000.f, k_state = 10000;
+	
+	static double squash_subtract = 1.0f / (1.f + (float) Math.exp(5.0));
+	
+	
+	
+	static public float getFitnessValueForState(DecoratedState state) {
+		double f_eb = 0;
+		double f_state = 0;
+		double elementCountInNetwork = state.getNetworkList().stream().map(net -> net.getAmountOfElements()).reduce(0, Integer::sum);
+		//sum over all objects
+		for(DecoratedNetwork net : state.getNetworkList()) {
+			
+			//weigt
+			double w_network = net.getAmountOfElements()/elementCountInNetwork;
+			
+			//f_eb
+			double netEnergyDifference = 0;
+			netEnergyDifference += net.getConsumerList().stream().map(con -> con.getEnergySelfSupplied() - con.getEnergyFromConsumingElemnets()).reduce(0.f, Float::sum);
+			netEnergyDifference += net.getConsumerSelfSuppliedList().stream().map(con -> con.getEnergySelfSupplied() - con.getEnergyFromConsumingElemnets()).reduce(0.f, Float::sum);
+			netEnergyDifference += net.getSupplierList().stream().map(sup -> sup.getEnergyProducing() - sup.getEnergySelfConsuming()).reduce(0.f, Float::sum);
+			//abs
+			f_eb += w_network * Math.abs(netEnergyDifference);
+			
+			
+			//f_state
+			f_state += w_network * net.getConsumerList().stream().map(con -> supplyPenalty(con.getSupplyBarPercentage())).reduce(0., Double::sum);
+		}
+		return (float) (w_eb*squash(f_eb, k_eb) + w_state*squash(f_state, k_state));
+	}
+	
+	
+	/**
+	 * f_sup in paper
+	 * @param supply from 0 to 1
+	 * @return
+	 */
+	static public double supplyPenalty(double supply) {
+		double supplyPercentage = 100 * supply;
+		return (supplyPercentage < 100) ? -0.5 * supplyPercentage + 50: supplyPercentage - 100;
+	}
+	
+	/**
+	 * The squashing function in paper
+	 * @param x the input
+	 * @param kappa the corresponding kappa
+	 * @return
+	 */
+	static public double squash(double x, double kappa) {
+		return 100.f/(1.0f + Math.exp(-(10.f * (x - kappa/2.f))/ kappa)) - squash_subtract;
+	}
+}

src/api/AlgorithmFrameworkFlex.java

@@ -15,6 +15,7 @@ import java.text.NumberFormat;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.DoubleSummaryStatistics;
+import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Locale;
@@ -29,6 +30,7 @@ import javax.swing.BoxLayout;
 import javax.swing.ImageIcon;
 import javax.swing.JButton;
 import javax.swing.JCheckBox;
+import javax.swing.JComboBox;
 import javax.swing.JFileChooser;
 import javax.swing.JFormattedTextField;
 import javax.swing.JLabel;
@@ -39,6 +41,8 @@ import javax.swing.JScrollPane;
 import javax.swing.JSplitPane;
 import javax.swing.text.NumberFormatter;
 
+import algorithm.objectiveFunction.ObjectiveFunctionByCarlos;
+import algorithm.objectiveFunction.SwitchObjectiveFunction;
 import classes.AbstractCanvasObject;
 import classes.GroupNode;
 import classes.Flexibility;
@@ -76,8 +80,9 @@ public abstract class AlgorithmFrameworkFlex implements AddOn{
 	
 	//access
 	private ArrayList<AccessWrapper> access;
+	private HashMap<HolonObject, AccessWrapper> accessKillSwitch = new HashMap<HolonObject, AccessWrapper>();
 	LinkedList<List<Boolean>> resetChain = new LinkedList<List<Boolean>>();
-	boolean algoUseElements = false, algoUseSwitches = true, algoUseFlexes = true;
+	boolean algoUseElements = false, algoUseSwitches = true, algoUseFlexes = true, algoUseKillSwitch = true;
 	
 	//time
 	private long startTime;
@@ -108,6 +113,10 @@ public abstract class AlgorithmFrameworkFlex implements AddOn{
 	private boolean useEmailNotification = false;
 	
 	
+	//ObjectiveFunction
+	enum ObjectiveFunction {Normal, Switch};
+	ObjectiveFunction evaluationFunction = ObjectiveFunction.Normal;
+	
 	public AlgorithmFrameworkFlex(){
 		content.setLayout(new BorderLayout());
 		JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT,
@@ -115,9 +124,6 @@ public abstract class AlgorithmFrameworkFlex implements AddOn{
 		splitPane.setResizeWeight(0.0);
 		content.add(splitPane, BorderLayout.CENTER);
 		content.setPreferredSize(new Dimension(1200,800));
-		
-		//Add rounds
-	
 	}
 	
 	
@@ -174,6 +180,33 @@ public abstract class AlgorithmFrameworkFlex implements AddOn{
 		useFlexes.addActionListener(actionEvent -> algoUseFlexes = useFlexes.isSelected());
 		parameterPanel.add(useFlexes);
 		
+		JCheckBox useKillSwitches = new JCheckBox("KillSwitch");
+		useKillSwitches.setSelected(algoUseFlexes);
+		useKillSwitches.setBounds(900, 130, 185, 20);
+		useKillSwitches.addActionListener(actionEvent -> 
+				{
+					cancel();
+					reset();
+					algoUseKillSwitch = useKillSwitches.isSelected();
+				});
+		parameterPanel.add(useKillSwitches);
+		
+		String[] objectiveFunctionStrings = { "Normal", "Switch"};
+		JLabel fitnessLabel = new JLabel("FitnessFunction:");
+		fitnessLabel.setBounds(910, 160, 90, 20);
+		parameterPanel.add(fitnessLabel);
+		JComboBox<String> ofBox = new JComboBox<String>(objectiveFunctionStrings);
+		ofBox.addActionListener(actionEvent -> 
+		{
+			boolean pickNormal = ((String)ofBox.getSelectedItem()).equals("Normal");
+			evaluationFunction = pickNormal?ObjectiveFunction.Normal:ObjectiveFunction.Switch;
+		});
+		ofBox.setBounds(1000, 160, 70, 20);
+		parameterPanel.add(ofBox);
+		
+		
+		
+		
 		JCheckBox emailNotificationCheckbox = new JCheckBox("EmailNotification");
 		emailNotificationCheckbox.setSelected(this.useEmailNotification);
 		emailNotificationCheckbox.setBounds(900, 200, 130, 20);
@@ -475,7 +508,16 @@ public abstract class AlgorithmFrameworkFlex implements AddOn{
 		return result;
 	}
 
-	protected abstract double evaluateState(DecoratedState actualstate);
+	private double evaluateState(DecoratedState actualstate) {
+		switch(this.evaluationFunction) {
+		case Switch:
+			return SwitchObjectiveFunction.getFitnessValueForState(actualstate);
+		case Normal:
+		default:
+			return ObjectiveFunctionByCarlos.getFitnessValueForState(actualstate);
+		}
+		
+	}
 
 	
 	private void run() {
@@ -714,17 +756,21 @@ public abstract class AlgorithmFrameworkFlex implements AddOn{
 	 */
 	protected List<Boolean> extractPositionAndAccess() {
 		Model model = control.getModel();
+		this.accessKillSwitch = new HashMap<HolonObject, AccessWrapper>();
 		access= new ArrayList<AccessWrapper>();
 		List<Boolean> initialState = new ArrayList<Boolean>();
 		rollOutNodes((dGroupNode != null)? dGroupNode.getModel().getNodes() :model.getObjectsOnCanvas(), initialState, model.getCurIteration());			
 		resetChain.add(initialState);
 		if(algoUseFlexes) {			
 			for(FlexWrapper flex :control.getSimManager().getActualFlexManager().getAllFlexWrapperWithState(FlexState.OFFERED)){
-				access.add(new AccessWrapper(flex.getFlex()));
+				//flex.getFlex().getElement().parentObject;
+				AccessWrapper killSwitchAccess = this.algoUseKillSwitch ? this.accessKillSwitch.get(flex.getFlex().getElement().parentObject): null;;
+				access.add(new AccessWrapper(flex.getFlex(), killSwitchAccess));
 				initialState.add(false);
 			}
 			for(FlexWrapper flex :control.getSimManager().getActualFlexManager().getAllFlexWrapperWithState(FlexState.IN_USE)){
-				access.add(new AccessWrapper(flex.getFlex()));
+				AccessWrapper killSwitchAccess = this.algoUseKillSwitch ? this.accessKillSwitch.get(flex.getFlex().getElement().parentObject): null;
+				access.add(new AccessWrapper(flex.getFlex(), killSwitchAccess));
 				initialState.add(true);
 			}
 		}
@@ -743,10 +789,19 @@ public abstract class AlgorithmFrameworkFlex implements AddOn{
 	 */
 	private void rollOutNodes(List<AbstractCanvasObject> nodes, List<Boolean> positionToInit, int timeStep) {
 		for(AbstractCanvasObject aCps : nodes) {
-			if (aCps instanceof HolonObject && algoUseElements) {
-				for (HolonElement hE : ((HolonObject) aCps).getElements()) {
-					positionToInit.add(hE.isActive());
-					access.add(new AccessWrapper(hE));
+			if (aCps instanceof HolonObject) {
+				HolonObject hObject = (HolonObject) aCps;
+				AccessWrapper killSwitchAccess = new AccessWrapper(hObject);
+				if(this.algoUseKillSwitch) {
+					positionToInit.add(false);
+					access.add(killSwitchAccess);
+					accessKillSwitch.put(hObject, killSwitchAccess);					
+				}
+				if(this.algoUseElements) {
+					for (HolonElement hE : hObject.getElements()) {
+						positionToInit.add(hE.isActive());
+						access.add(new AccessWrapper(hE, killSwitchAccess));
+					}					
 				}
 			}
 			else if (aCps instanceof HolonSwitch&& algoUseSwitches) {
@@ -951,59 +1006,96 @@ public abstract class AlgorithmFrameworkFlex implements AddOn{
 		}
 	}
 		
-	
+	private enum AccessType {None, HolonElement, Switch, Flexibility, KillSwitch};
 	/**
 	 * A Wrapper Class for Access HolonElement and HolonSwitch in one Element and not have to split the List.
 	 */
 	private class AccessWrapper {
-		public static final int HOLONELEMENT = 0;
-		public static final int SWITCH = 1;
-		public static final int FLEXIBILITY = 2;
-		private int type;
+		private AccessType type;
+		private List<Boolean> intialStatesOfElementForKilllSwitch;
+		
+		private HolonObject hObject;
 		private HolonSwitch hSwitch;
+		
 		private HolonElement hElement;
 		private Flexibility flex;
+		private AccessWrapper correspondingKillSwitch;
+		
+		private boolean lastState;
+		
+		
+		public AccessWrapper(HolonObject hObject){
+			type = AccessType.KillSwitch;
+			this.hObject = hObject;
+			intialStatesOfElementForKilllSwitch = new ArrayList<Boolean>();
+			for(HolonElement hE: hObject.getElements()) {
+				intialStatesOfElementForKilllSwitch.add(hE.isActive());
+			}
+		}
 		public AccessWrapper(HolonSwitch hSwitch){
-			type = SWITCH;
+			type = AccessType.Switch;
 			this.hSwitch = hSwitch;
 		}
-		public AccessWrapper(HolonElement hElement){
-			type = HOLONELEMENT;
+		public AccessWrapper(HolonElement hElement, AccessWrapper correspondingKillSwitch){
+			type = AccessType.HolonElement;
 			this.hElement = hElement;
+			this.correspondingKillSwitch = correspondingKillSwitch;
 		}
 		
-		public AccessWrapper(Flexibility flex){
-			type = FLEXIBILITY;
+		public AccessWrapper(Flexibility flex, AccessWrapper correspondingKillSwitch){
+			type = AccessType.Flexibility;
 			this.flex = flex;
+			this.correspondingKillSwitch = correspondingKillSwitch;
 		}
 		
 		public void setState(boolean state) {
+			lastState = state;
 			switch(type) {
-				case HOLONELEMENT:
-					hElement.setActive(state);
+				case  HolonElement:
+					if(!algoUseKillSwitch || (algoUseKillSwitch && !correspondingKillSwitch.getLastState())) {
+						hElement.setActive(state);
+					}
 					break;
-				case SWITCH:
+				case Switch:
 					hSwitch.setManualMode(true);
 					hSwitch.setManualState(state);
 					break;
-				case FLEXIBILITY:
-					if(state) {
+				case Flexibility:
+					if(state && (!algoUseKillSwitch || (algoUseKillSwitch && !correspondingKillSwitch.getLastState()))) {
 						control.getSimManager().getActualFlexManager().orderFlex(flex);
 					}
 					break;
+				case KillSwitch:
+					if(state) {
+						for (HolonElement hE : hObject.getElements()) {
+							hE.setActive(false);
+						}						
+					}else {
+						for(int i = 0; i < hObject.getElements().size(); i++) {
+							hObject.getElements().get(i).setActive(intialStatesOfElementForKilllSwitch.get(i));
+						}
+					}
+					break;
 				default:
+					break;
 				
 			}
 		}
 		
+		public boolean getLastState() {
+			return lastState;
+		}
+		
 		public String typeString() {
 			switch(type) {
-				case HOLONELEMENT:
-					return "HOLONELEMENT";
-				case SWITCH:
-					return "SWITCH";
-				case FLEXIBILITY:
-					return "FLEXIBILITY";
+				case HolonElement:
+					return "HolonElement";
+				case Switch:
+					return "Switch";
+				case Flexibility:
+					return "Flexibility";
+				case KillSwitch:
+					return "KillSwitch";
 				default:
 					return "unknown";
 			}

src/classes/HolonElement.java

@@ -46,7 +46,11 @@ public class HolonElement implements LocalMode, GraphEditable{
     @Expose
     private boolean active;
     /** Gives us whether this element is flexible and can flexibly use any part of the energy in flexibleEnergyAvailable */
-
+    
+    public HolonObject parentObject;
+    
+    
+    
     
     @Expose
     private Priority priority;
@@ -87,16 +91,17 @@ public class HolonElement implements LocalMode, GraphEditable{
      * @param energy  float
      * @param model Model
      */
-    public HolonElement(String eleName, int amount, float energy, Model model) {
+    public HolonElement(HolonObject parentObject, String eleName, int amount, float energy) {
     	
-    	this(eleName, amount, energy, IdCounterElem.nextId(),model);
+    	this(parentObject, eleName, amount, energy, IdCounterElem.nextId());
     }
     
 
     /**
      * same as standard constructor, but with already given id (so the counter is not increased twice)
      */
-    public HolonElement(String eleName, int amount, float energy, int id, Model model){
+    public HolonElement(HolonObject parentObject, String eleName, int amount, float energy, int id){
+    	this.parentObject = parentObject;
     	setUseLocalPeriod(false);
     	setEleName(eleName);
         setAmount(amount);
@@ -115,6 +120,7 @@ public class HolonElement implements LocalMode, GraphEditable{
      * @param element element to copy
      */
     public HolonElement(HolonElement element) {
+    	this.parentObject = element.parentObject;
     	this.priority = element.getPriority();
     	setLocalPeriod(element.getLocalPeriod());
     	setUseLocalPeriod(element.isUsingLocalPeriod());
@@ -195,6 +201,9 @@ public class HolonElement implements LocalMode, GraphEditable{
     public void setPriority(Priority priority) {
     	this.priority = priority;
     }    
+    
+    
+    
     /**
      *  Check the HolonElemnet is a Producer
      * 	@return true when the energy used be each element is higher then 0
@@ -315,6 +324,7 @@ public class HolonElement implements LocalMode, GraphEditable{
         sb.append("[HolonElement: ");
         sb.append("id=").append(id)
                 .append(", eleName=").append(eleName)
+                .append(", parentName=").append(parentObject.getName())
                 .append(", amount=").append(amount)
                 .append(", active=").append(active)
                 .append(", energyPerElement used=").append(energyPerElement);

src/classes/HolonSwitch.java

@@ -314,4 +314,10 @@ public class HolonSwitch extends AbstractCanvasObject implements LocalMode, Grap
 	public HolonSwitch makeCopy(){
 		return new HolonSwitch(this);
 	}
+	
+		
+	public String toString() {
+		return name + "[ID:" + id + "]";
+		
+	}
 }

src/ui/controller/LoadController.java

@@ -303,13 +303,13 @@ public class LoadController {
                                     HashMap<Integer, HolonElement> eleDispatch) {
 
         JsonObject object = jsonElement.getAsJsonObject();
-        HolonElement temp = model.getGson().fromJson(object.get("properties"), HolonElement.class);
-        initElements(temp);
-        temp.flexList = model.getGson().fromJson(object.get("FlexList"), new TypeToken<List<Flexibility>>() {}.getType());
+        HolonElement ele = model.getGson().fromJson(object.get("properties"), HolonElement.class);
+        initElements(ele);
+        ele.flexList = model.getGson().fromJson(object.get("FlexList"), new TypeToken<List<Flexibility>>() {}.getType());
         //object.get("FlexList").getAsJsonArray().forEach(jo -> System.out.println("Hallo"));
         //object.get("FlexList").getAsJsonArray().forEach(flexJson -> flexJson.getAsJsonObject().get("constrainList").getAsJsonArray().forEach(constrainJson -> System.out.println("Constrain:" + constrainJson.getAsJsonObject().get("name").getAsString())));
-        temp.flexList.stream().forEach(flex -> {
-        	flex.setElement(temp);
+        ele.flexList.stream().forEach(flex -> {
+        	flex.setElement(ele);
         	flex.constrainList.forEach(con -> con.fixJson());
         	
         });
@@ -318,11 +318,12 @@ public class LoadController {
         // id which Object it was stored before
         int stored = object.get("ID").getAsInt();
         // lookup that object
-        HolonObject temp2 = (HolonObject) objDispatch.get(stored);
+        HolonObject hObject = (HolonObject) objDispatch.get(stored);
         // add it
-        objC.addElement(temp2, temp);
+        objC.addElement(hObject, ele);
+        ele.parentObject = hObject;
         // store element also inside a table
-        eleDispatch.put(temp.getId(), temp);
+        eleDispatch.put(ele.getId(), ele);
     }
 
     /**

src/ui/controller/ObjectController.java

@@ -71,12 +71,14 @@ public class ObjectController {
      * @param elementId the Element ID
      */
     public void addNewElementIntoCanvasObject(int objectId, String element, int amount, float energy, int elementId) {
-        HolonElement ele = new HolonElement(element, amount, energy, elementId, model);
-        if (mpC.searchByID(objectId) == null) {
-            addElementIntoCanvasObject((HolonObject) model.getSelectedCpsObjects().get(0), ele);
+    	HolonObject hObject;
+    	if (mpC.searchByID(objectId) == null) {
+        	hObject = (HolonObject) model.getSelectedCpsObjects().get(0);
         } else {
-            addElementIntoCanvasObject((HolonObject) mpC.searchByID(objectId), ele);
+        	hObject = ((HolonObject) mpC.searchByID(objectId));
         }
+        HolonElement ele = new HolonElement(hObject, element, amount, energy, elementId);
+        addElementIntoCanvasObject(hObject, ele);
     }
 
     /**
@@ -103,7 +105,7 @@ public class ObjectController {
     public void addNewElementIntoCategoryObject(String category, String object, String element, int amount,
                                                 float energy) {
 
-        HolonElement ele = new HolonElement(element, amount, energy, model);//TODO: I added model
+        HolonElement ele = new HolonElement((HolonObject) mpC.searchCatObj(mpC.searchCat(category), object),element, amount, energy);
         addElementIntoCategoryObject(category, object, ele);
     }
 

src/ui/view/AddElementPopUp.java

@@ -197,13 +197,15 @@ public class AddElementPopUp extends JDialog {
 				float energy = Float.parseFloat(providedEnergy.getText());
 				int elementAmount = Integer.parseInt(amount.getText());
 				if(hl == null){
-					hl = new HolonElement(elementName.getText(), elementAmount, energy, model);
+					//hl = new HolonElement(elementName.getText(), elementAmount, energy);
+					//should not happen
+					System.err.println("Undefined Element in 'AddElementPopUp'-class.");
 				} else {
 					hl.setEleName(elementName.getText());
 					hl.setAmount(elementAmount);
 					hl.setEnergyPerElement(energy);
+					hl.setActive(checkBoxActive.isSelected());
 				}
-				hl.setActive(checkBoxActive.isSelected());
 				dispose();
 			} catch (NumberFormatException e) {
 				JOptionPane.showMessageDialog(new JFrame(), Languages.getLanguage()[68]);

tests/tests/PraktikumHolonsAdapter.java

@@ -43,7 +43,7 @@ public class PraktikumHolonsAdapter {
 	 */
 	public void generateElements(ArrayList<HolonElement> arr) {
 		for (int i = 1; i < 18279; i++) {
-			arr.add(new HolonElement(generate(i), 1, 10, IdCounterElem.nextId(),null));
+			arr.add(new HolonElement(null, generate(i), 1, 10, IdCounterElem.nextId()));
 		}
 	}
 	

tests/tests/PraktikumHolonsTestClasses.java

@@ -52,7 +52,7 @@ public class PraktikumHolonsTestClasses {
 		HolonObject test1 = new HolonObject("Test1");
 		HolonObject test2 = new HolonObject("Test2");
 		HolonObject test3 = new HolonObject(test1);
-		HolonElement ele = new HolonElement("Element", 1, 10, IdCounterElem.nextId(),null);
+		HolonElement ele = new HolonElement(test1, "Element", 1, 10, IdCounterElem.nextId());
 		ArrayList<HolonElement> arr = new ArrayList<>();
 		assertTrue("Should be Empty", test1.getElements().isEmpty());
 		test1.setElements(arr);
@@ -135,8 +135,8 @@ public class PraktikumHolonsTestClasses {
 	 */
 	@Test
 	public void testHolonElement() {
-		HolonElement ele1 = new HolonElement("TV", 2, -20f, IdCounterElem.nextId(),null);
-		HolonElement ele2 = new HolonElement("Fridge", 1, -50f, IdCounterElem.nextId(),null);
+		HolonElement ele1 = new HolonElement(null, "TV", 2, -20f, IdCounterElem.nextId());
+		HolonElement ele2 = new HolonElement(null, "Fridge", 1, -50f, IdCounterElem.nextId());
         assertTrue("Array not empty",  ele1.getEnergyAtTimeStep(0) == -40);
         assertTrue("Array not empty", ele1.getEnergyAtTimeStep(2) == -40);
         assertTrue("Name not correct", ele1.getEleName().equals("TV"));