source: DCWoRMS/branches/coolemall/src/test/fips/models/i5/TangHeatCoolingDeviceEnergyEstimationPlugin.java @ 1600

package test.fips.models.i5;

import schedframe.resources.StandardResourceType;
import schedframe.resources.computing.ComputingResource;
import schedframe.resources.computing.Node;
import schedframe.resources.computing.Processor;
import schedframe.resources.computing.Rack;
import schedframe.resources.computing.profiles.energy.ResourceEvent;
import schedframe.resources.computing.profiles.energy.power.StandardPowerStateName;
import schedframe.resources.devices.Device;
import schedframe.resources.devices.Fan;
import schedframe.resources.devices.PhysicalResource;
import schedframe.scheduling.manager.tasks.JobRegistry;
import simulator.ConfigurationOptions;
import example.energy.BaseEnergyEstimationPlugin;
import example.energy.coolemall.CoolEmAllTestbedMeasurements;
import test.fips.EnvironmentConditions;

public class TangHeatCoolingDeviceEnergyEstimationPlugin extends BaseEnergyEstimationPlugin {

        public double estimateAirflow(ResourceEvent event, JobRegistry jobRegistry, PhysicalResource resource) {
                double airflow = 0;
                return airflow;
        }

        public double estimatePowerConsumption(ResourceEvent event, JobRegistry jobRegistry,
                        PhysicalResource resource) {
                
                double powerConsumption = 0;
                
                Device coolingDevice = (Device) resource;
                ComputingResource room = (ComputingResource) coolingDevice.getComputingResource();
                
                double Pload_dc = calculatePit(room);
                double Q = calculateQ( 0.02*Pload_dc, room);
                double airTemp = EnvironmentConditions.ROOM_TEMPERATURE;
                double CoP = 0.0068 * Math.pow(airTemp, 2) + 0.0008 * airTemp + 0.458;
                
                powerConsumption = Q/CoP;
                return powerConsumption;
        }
        
        private double calculatePit(ComputingResource room){
                double Pload_dc = 0;
                for(ComputingResource cr: room.getChildren()){
                        Rack rack = (Rack)cr;
                        Pload_dc = Pload_dc + rack.getPowerInterface().getRecentPowerUsage().getValue();
                }
                return Pload_dc;
        }

        
        private double calculateQ(double Pothers, ComputingResource room){

                double Qdc = 0;


                /**************** HEAT ****************/
                
                double Qload_dc = 0;
                double Qothers = 0;

                double delta_2; //DEBB - currently not present;
                delta_2 = 0.4;
                
                for(ComputingResource cr: room.getChildren()){
                        Rack rack = (Rack)cr;
                        double QnodeGroup = 0;
                        for(ComputingResource nodeGroup: rack.getChildren()){
                                double Qnodes = 0;
                                for(ComputingResource node: nodeGroup.getChildren()){
                                        double Qcpu = 0;
                                        Node n = (Node)node;
                                        for(Processor proc: n.getProcessors()){
                                                Qcpu = Qcpu + proc.getPowerInterface().getRecentPowerUsage().getValue();
                                        }
                                        Qnodes = Qnodes + n.getPowerInterface().getRecentPowerUsage().getValue();;
                                }
                                double Qfans = 0;
                                for(Device device: nodeGroup.getResourceCharacteristic().getDevices()){
                                        Fan fan = (Fan) device;
                                        if(fan.getPowerInterface().getRecentPowerUsage().getValue() == -1){
                                                try {
                                                        Qfans = Qfans + (1 - delta_2) * fan.getAirflowInterface().getPowerConsumption(fan.getAirflowInterface().getAirflowState());
                                                } catch (NoSuchFieldException e) {
                                                        // TODO Auto-generated catch block
                                                        e.printStackTrace();
                                                }
                                        }else
                                                Qfans = Qfans + (1 - delta_2) * fan.getPowerInterface().getRecentPowerUsage().getValue();
                                }
                                QnodeGroup = QnodeGroup + Qnodes + Qfans;
                        }
                        int nrOfPoweredOffNodes = 0;
                        for(Node node: rack.getNodes()){
                                if(node.getPowerInterface().getPowerState().equals(StandardPowerStateName.OFF)){
                                        nrOfPoweredOffNodes++;
                                }
                        }
                        if(nrOfPoweredOffNodes != rack.getNodes().size()){
                                Qload_dc  = Qload_dc + QnodeGroup + CoolEmAllTestbedMeasurements.OTHER_DEVICES_POWER_CONSUMPTION;
                        } else {
                                Qload_dc  = Qload_dc + QnodeGroup;
                        }
                }
                
                Qothers = Pothers;
                
                Qdc = Qload_dc + Qothers;

                
                return Qdc;
        }
        
}