def CalculateRegionalGasExpenses(self, problemManager, distanceToGas): """ Calculate gas pipeline transmission costs to hydrogen plant.""" # distanceToGas is assumed given in km theUnitManager = UnitManager() gasCosts = np.zeros(distanceToGas.shape) #AUD2010 = MiningEquipmentPriceIndex.IndexedPrice(1.0,2010,2018) * theUnitManager.ConvertToBaseUnits("AUD") #in 2018 dollars AUD2016 = MiningEquipmentPriceIndex.IndexedPrice( 1.0, 2016, 2018) * theUnitManager.ConvertToBaseUnits("AUD") AUD2014 = MiningEquipmentPriceIndex.IndexedPrice( 1.0, 2014, 2018) * theUnitManager.ConvertToBaseUnits("AUD") piplelineCostPerKM = 0.315e6 * AUD2014 # from core gas production and transmission costs 8 inch class 600 5.6mm wall. gasCosts = piplelineCostPerKM * distanceToGas # The following are excluded as we are using gas lines for transmission - not power (gas costs are included in plant opex). #AUD2018 = MiningEquipmentPriceIndex.IndexedPrice(1.0,2018,2018) * theUnitManager.ConvertToBaseUnits("AUD") #gasLCOE = 120*AUD2016 # LCOE per Mwh #retailCOE = 100*AUD2018 # LCOE per Mwh #gasPowerCosts = problemManager.theMineDataManager.theProcessingSystem.processingPower*( gasLCOE - retailCOE) #gasNPC = problemManager.theMineDataManager.theEconomicDataManager.CalculateNPV(gasPowerCosts) #gasCosts+= gasNPC return gasCosts
def ParseXMLNode(self, miningSystemNode): """ Generate mining system data from xml tree node. - Note this may not be needed in many cases as the mining system is derived from the orebody shape """ theUnitManager = UnitManager() if (HasAttribute(miningSystemNode, "alpha")): self.alpha = GetAttributeValue(miningSystemNode, "alpha") if (HasAttribute(miningSystemNode, "orebody")): self.orebodyName = GetAttributeString(miningSystemNode, "orebody") # for K2SO4 (brine mining) only - bit ugly - might be able to use orebody instead if (HasAttribute(miningSystemNode, "method")): self.miningMethod = GetAttributeString(miningSystemNode, "method") # for proving well costs if (HasAttribute(miningSystemNode, "boreholeSpacing")): spacing = theUnitManager.ConvertToBaseUnits( GetAttributeString(miningSystemNode, "boreholeSpacing")) self.boreholeDensity = 1.0 / (spacing**2) if (HasAttribute(miningSystemNode, "drillingCost")): self.drillingCostPerMeter = theUnitManager.ConvertToBaseUnits( GetAttributeString(miningSystemNode, "drillingCost")) if (HasAttribute(miningSystemNode, "includeProvingCosts")): self.doProvingCostCalculation = GetAttributeValue( miningSystemNode, "includeProvingCosts") return miningSystemNode
def CalculateRegionalGasExpenses(self,problemManager, distanceToGas): # distanceToGas is assumed given in km theUnitManager = UnitManager() gasCosts = np.zeros(distanceToGas.shape) AUD2016 = MiningEquipmentPriceIndex.IndexedPrice(1.0,2016,2018) * theUnitManager.ConvertToBaseUnits("AUD") AUD2014 = MiningEquipmentPriceIndex.IndexedPrice(1.0,2014,2018) * theUnitManager.ConvertToBaseUnits("AUD") piplelineCostPerKM = 0.315e6*AUD2014 # from core gas production and transmission costs 8 inch class 600 5.6mm wall. gasCosts = piplelineCostPerKM*distanceToGas AUD2018 = MiningEquipmentPriceIndex.IndexedPrice(1.0,2018,2018) * theUnitManager.ConvertToBaseUnits("AUD") gasLCOE = 120*AUD2016 # LCOE per Mwh retailCOE = 100*AUD2018 # LCOE per Mwh gasPowerCosts = problemManager.theMineDataManager.theProcessingSystem.processingPower*( gasLCOE - retailCOE) gasNPC = problemManager.theMineDataManager.theEconomicDataManager.CalculateNPV(gasPowerCosts) gasCosts+= gasNPC return gasCosts
def DetermineDistanceToInfrastructure(self, problemManager, mineDataManager): """ Use available data to determine the distance to infrastructure (single site calculation only). """ theUnitManager = UnitManager() theFunctionManager = FunctionManager() oneKm = theUnitManager.ConvertToBaseUnits( "km") # assumed that distances are given in km self.distanceToRoad = theFunctionManager.GetFunction( "DistanceToRoad").f(mineDataManager.mineLatLong[::-1]) * oneKm self.distanceToRail = theFunctionManager.GetFunction( "DistanceToRail").f(mineDataManager.mineLatLong[::-1]) * oneKm self.distanceToWater = theFunctionManager.GetFunction( "DistanceToWater").f(mineDataManager.mineLatLong[::-1]) * oneKm self.distanceToPower = theFunctionManager.GetFunction( "DistanceToPower").f(mineDataManager.mineLatLong[::-1]) * oneKm self.roadTransportationDistance = theFunctionManager.GetFunction( "RoadTransportationDistance").f( mineDataManager.mineLatLong[::-1]) * oneKm self.railTransportationDistance = theFunctionManager.GetFunction( "RailTransportationDistance").f( mineDataManager.mineLatLong[::-1]) * oneKm if (self.calculateGas): self.distanceToGas = theFunctionManager.GetFunction( "DistanceToGas").f(mineDataManager.mineLatLong[::-1]) * oneKm
def CalculateOpex(self, hydrogenManager): """Calculate the ongoing costs for the power plant""" # no distinction between opex and sustaining capital (adjust tax calculation) theFunctionManager = FunctionManager() theUnitManager = UnitManager() opexFunc = theFunctionManager.GetFunction("EnergyOpex_" + self.type) opexPerAnnumPerMW = opexFunc.f( [self.plantCapacity * theUnitManager.ConvertTo("MW")]) #print "Power plant type: ", self.type #print "Power plant capacity (MW)", self.plantCapacity * theUnitManager.ConvertTo("MW") #print "Capacity factor", self.capacityFactor #print "Power plant Opex Per Annum", opexPerAnnum self.opex = np.zeros(self.projectLife) self.opex[ self. startupTime:] = opexPerAnnumPerMW * self.capacityFactor * self.plantCapacity * theUnitManager.ConvertTo( "MW") #print "self.plantCapacity",self.plantCapacity #print "power opex", self.opex rv = np.array(self.opex) if (self.secondaryPowerSource): rv += self.secondaryPowerSource.CalculateOpex(hydrogenManager) return rv
def CalculatePowerExpenses(self, problemManager, mineDataManager): numYears = mineDataManager.theMiningSystem.mineLife requiredVoltage = 220 theUnitManager = UnitManager() oneKm = theUnitManager.ConvertToBaseUnits("km") if(self.distanceToPower < 190*oneKm): requiredVoltage = 132 if(self.distanceToPower < 150*oneKm): # this could also be 100 km requiredVoltage = 33 if(self.distanceToPower <= oneKm): requiredVoltage = 11 # power capex self.powerCapex = np.zeros(numYears) distanceScale = theUnitManager.ConvertToBaseUnits("AUD/km") AUD2010 = MiningEquipmentPriceIndex.IndexedPrice(1.0,2010,2018) AUD2014 = MiningEquipmentPriceIndex.IndexedPrice(1.0,2014,2018) if( requiredVoltage == 220): distanceScale *= 925000*AUD2014 elif(requiredVoltage == 132): distanceScale *= 650000*AUD2014 elif(requiredVoltage == 33): distanceScale *= 300000*AUD2010 else: distanceScale *= 75000*AUD2010 self.powerCapex[0] = distanceScale*self.distanceToPower self.powerOpex = np.zeros(numYears)
def CalculatePowerExpenses(self, problemManager, hydrogenManager): """Calculate power infrastructure expenses (local calculation).""" numYears = hydrogenManager.GetProjectDuration() self.powerCapex = np.zeros(numYears) if (self.includePowerInfrastructureCosts): requiredVoltage = 220 theUnitManager = UnitManager() oneKm = theUnitManager.ConvertToBaseUnits("km") if (self.distanceToPower < 190 * oneKm): requiredVoltage = 132 if (self.distanceToPower < 150 * oneKm): # this could also be 100 km requiredVoltage = 33 if (self.distanceToPower <= oneKm): requiredVoltage = 11 # power capex distanceScale = theUnitManager.ConvertToBaseUnits("AUD/km") AUD2010 = MiningEquipmentPriceIndex.IndexedPrice(1.0, 2010, 2018) AUD2014 = MiningEquipmentPriceIndex.IndexedPrice(1.0, 2014, 2018) if (requiredVoltage == 220): distanceScale *= 925000 * AUD2014 elif (requiredVoltage == 132): distanceScale *= 650000 * AUD2014 elif (requiredVoltage == 33): distanceScale *= 300000 * AUD2010 else: distanceScale *= 75000 * AUD2010 self.powerCapex[0] = distanceScale * self.distanceToPower self.powerOpex = np.zeros(numYears)
def CalculateMineCapacity(self, problemManager, mineManager): """ Determine the maximum annual extraction for the mine using Taylor's rule """ theUnitManager = UnitManager() orebodyMass = mineManager.theOreBody.CalculateDepositMass( ) * theUnitManager.ConvertTo("tonne") theFunctionManager = FunctionManager() if (self.miningMethod == "OCUG"): taylorsRuleFunc = theFunctionManager.GetFunction( "TaylorsRule_" + self.miningMethod[:2]) else: taylorsRuleFunc = theFunctionManager.GetFunction("TaylorsRule_" + self.miningMethod) daysPerYear = 350 # operating days per year - assuming 350 days self.mineCapacity = daysPerYear * taylorsRuleFunc.f( [orebodyMass]) * theUnitManager.ConvertToBaseUnits("tonne") self.mineOreProductionCapacity = self.mineCapacity print("Mine ore capacity from Taylor's rule in Mt/year", self.mineCapacity * theUnitManager.ConvertTo("1e6 tonne")) return self.mineCapacity
def CalculateTransportationExpenses(self, problemManager, mineDataManager): numYears = mineDataManager.theMiningSystem.mineLife CovertToTodaysPrice = MiningEquipmentPriceIndex.IndexedPrice(1.0,2010,2018) # System # Road Rail # Capital costs 1000AUD/km # 500-3000 2000-7000 # Fleet Costs 1000AUD /(km.Mt/a) # 40 100 # Operating Costs cents/t/km # 5-12 1-1.25 # Table 5: Transportation costs in 2010 AUD [1] theUnitManager = UnitManager() thousandAUDPerkm = 1000. * theUnitManager.ConvertToBaseUnits("AUD/km") # length prices are $1000 per km thousandAUDPerMtkmPerYear = 1000. * 1e-6 * theUnitManager.ConvertToBaseUnits("AUD/km/tonne") # fleet costs are per 1000 AuD per Mt km/ year fleetCapacity = np.max(mineDataManager.theProcessingSystem.concentrateProduced) self.roadCapex = self.distanceToRoad * 1750. * CovertToTodaysPrice * thousandAUDPerkm \ + 40 * CovertToTodaysPrice * fleetCapacity * self.roadTransportationDistance * thousandAUDPerMtkmPerYear self.railCapex = self.distanceToRail * 4500. * CovertToTodaysPrice * thousandAUDPerkm \ + 100 * CovertToTodaysPrice * fleetCapacity * self.railTransportationDistance * thousandAUDPerMtkmPerYear self.roadOpex = np.zeros(numYears) self.railOpex = np.zeros(numYears) centsPerTonnePerKm = 0.01*theUnitManager.ConvertToBaseUnits("AUD/tonne/km") self.roadOpex = self.roadTransportationDistance* \ mineDataManager.theProcessingSystem.concentrateProduced * \ 8.5* CovertToTodaysPrice* centsPerTonnePerKm# 5-12 cents/t/km self.railOpex = self.railTransportationDistance* \ mineDataManager.theProcessingSystem.concentrateProduced * \ 1.75* CovertToTodaysPrice*centsPerTonnePerKm # 1-2.5 cents/t/km # choose between road and rail based on which has lowest NPV (costs are +ve) roadNPV = mineDataManager.theEconomicDataManager.CalculateNPV(self.roadOpex) \ + mineDataManager.theEconomicDataManager.CalculateNPV([self.roadCapex] ) railNPV = mineDataManager.theEconomicDataManager.CalculateNPV(self.railOpex) \ + mineDataManager.theEconomicDataManager.CalculateNPV([self.railCapex] ) self.transportationCapex = np.zeros(numYears) self.transportationOpex = np.zeros(numYears) useRoads = roadNPV < railNPV if(useRoads): self.transportationCapex[0] = self.roadCapex self.transportationOpex = self.roadOpex else: self.transportationCapex[0] = self.railCapex self.transportationOpex = self.railOpex
def CalculateProcessingOpex(self, problemManager, mineDataManager): self.processingOpex = np.zeros( mineDataManager.theMiningSystem.mineLife) theFunctionManager = FunctionManager() theUnitManager = UnitManager() self.processingOpex = self.oreProcessed * theUnitManager.ConvertTo( "tonne") # tonnes processed per year processingOpexFunc = theFunctionManager.GetFunction( "ProcessingOpex_" + self.processingMethod) opexPerTonne = processingOpexFunc.f( [self.processingCapacity * theUnitManager.ConvertTo("1e6 tonne")]) print("Processing method: ", self.processingMethod) #print "Processing capacity (kg ore)", self.processingCapacity print("Processing capacity (Mt ore)", self.processingCapacity * theUnitManager.ConvertTo("1e6 tonne")) print("Processing Opex Per Tonne ", opexPerTonne) self.processingOpex *= opexPerTonne if (self.secondaryProcessingSystem): secondaryOpex = self.secondaryProcessingSystem.CalculateProcessingOpex( problemManager, mineDataManager) self.processingOpex += secondaryOpex return self.processingOpex
def CalculateRehabilitationExpenses(self, problemManager, mineDataManager): """ Calculate rehabilitation costs. """ self.rehabilitationCosts = np.zeros( mineDataManager.theMiningSystem.mineLife) theFunctionManager = FunctionManager() theUnitManager = UnitManager() processingCapacity = mineDataManager.theProcessingSystem.processingCapacity * theUnitManager.ConvertTo( "1e6 tonne") rehabSecurityFunc = theFunctionManager.GetFunction( "RehabilitationSecurity_" + mineDataManager.theProcessingSystem.processingMethod) self.rehabSecurityCost = rehabSecurityFunc.f([processingCapacity]) # NT model: 1% of rehabSecurity paid each year of operation self.rehabilitationCosts = np.ones( mineDataManager.theMiningSystem.mineLife ) * self.rehabSecurityCost * 0.01 self.rehabilitationCosts[0] = self.rehabSecurityCost self.rehabilitationNPC = self.CalculateRehabilitationBondNPC( problemManager, mineDataManager) return self.rehabilitationCosts
def __init__(self, orebodyName=""): """ Create an empty mining system data manager and default variables. """ self.orebodyName = orebodyName self.mineLife = 0 self.mineCapacity = 0.0 self.mineOreProductionCapacity = 0.0 self.orebodyMass = 0.0 self.oreMined = np.array([0.0]) self.dilution = 0.05 self.wasteMined = np.array([0.0]) self.miningCapex = np.array([0.0]) self.miningOpex = np.array([0.0]) self.depths = np.array([0.0]) self.rampGrade = 0.1 self.alpha = 40 * np.pi / 180 # pit slope angle self.mineStartupTime = 0 # in years self.actualMineStartupTime = 0.0 self.miningMethod = "OC" theUnitManager = UnitManager() self.ugHaulCostPerDepth = theUnitManager.ConvertToBaseUnits( "0.0073 AUD/tonne/m") # proving costs self.doProvingCostCalculation = False self.boreholeDensity = 1.0 / theUnitManager.ConvertToBaseUnits( "50 m")**2 # 50m x 50m grid self.drillingCostPerMeter = theUnitManager.ConvertToBaseUnits( "100 AUD/m")
def CalculateRegionalPowerExpenses(self, problemManager, distanceToPower): # distanceToPower is assumed given in km theUnitManager = UnitManager() powerCosts = np.zeros(distanceToPower.shape) AUD2010 = MiningEquipmentPriceIndex.IndexedPrice(1.0,2010,2018) * theUnitManager.ConvertToBaseUnits("AUD") #in today's dollars AUD2014 = MiningEquipmentPriceIndex.IndexedPrice(1.0,2014,2018) * theUnitManager.ConvertToBaseUnits("AUD") AUD2016 = MiningEquipmentPriceIndex.IndexedPrice(1.0,2016,2018) * theUnitManager.ConvertToBaseUnits("AUD") powerCosts[distanceToPower > 190] = 925000*AUD2014 powerCosts[ np.logical_and(distanceToPower <= 190,distanceToPower > 150) ] = 300000*AUD2014 powerCosts[ np.logical_and(distanceToPower <= 150,distanceToPower > 1) ] = 300000*AUD2010 powerCosts[distanceToPower <= 1] = 75000*AUD2010 powerCosts *= distanceToPower if(self.calculateDiesel): AUD2018 = MiningEquipmentPriceIndex.IndexedPrice(1.0,2018,2018) * theUnitManager.ConvertToBaseUnits("AUD") dieselLCOE = 350*AUD2016 # Renewable energy in Australian mining sector estimate retailCOE = 100*AUD2018 dieselCosts = problemManager.theMineDataManager.theProcessingSystem.processingPower*( dieselLCOE - retailCOE) dieselNPC = problemManager.theMineDataManager.theEconomicDataManager.CalculateNPV(dieselCosts) powerCosts[ powerCosts > dieselNPC ] = dieselNPC return powerCosts
def CalculateMineCapacityFromMass(self, orebodyMass): """ Determine the maximum annual extraction for the mine using Taylor's rule from orebodyMass given in tonnes. """ theUnitManager = UnitManager() #orebodyMass = mineManager.theOreBody.CalculateDepositMass()*theUnitManager.ConvertTo("tonne") theFunctionManager = FunctionManager() if (self.miningMethod == "OCUG"): taylorsRuleFunc = theFunctionManager.GetFunction( "TaylorsRule_" + self.miningMethod[:2]) else: taylorsRuleFunc = theFunctionManager.GetFunction("TaylorsRule_" + self.miningMethod) daysPerYear = 350 #Todo("Check operating days per year - assuming 350 days") mineProductionCapacity = daysPerYear * taylorsRuleFunc.f( [orebodyMass]) * theUnitManager.ConvertToBaseUnits("tonne") #self.mineOreProductionCapacity = self.mineCapacity #print "Mine ore capacity from Taylor's rule in Mt/year", self.mineCapacity* theUnitManager.ConvertTo("1e6 tonne") #print "Mine ore capacity from Taylor's rule in Mt/day", self.mineCapacity* theUnitManager.ConvertTo("1e6 tonne")/350. return mineProductionCapacity
def CalculateWaterExpenses(self, problemManager, mineDataManager): """ Calculate water startup infrastructure costs - ongoing costs are assumed included in the mine and processing cost models """ numYears = mineDataManager.theMiningSystem.mineLife theUnitManager = UnitManager() processingCapacity = mineDataManager.theProcessingSystem.processingCapacity* theUnitManager.ConvertTo("tonne") # tonnes per year v = 2.0 # 2 m/s flow rate q = 2.35* processingCapacity # in kL/year assumes 2.35 kL water per tonne sPerYear = 365*24*3600 diam = np.sqrt( 4* q/ ( np.pi * sPerYear * v) ) distanceScale= 2.6229e6*diam - 125528 # empirical fit to cost of pipeline data per km in 2018 AUD oneKm = theUnitManager.ConvertToBaseUnits("km") self.waterCapex = np.zeros(numYears) self.waterCapex[0] = distanceScale*self.distanceToWater/oneKm #Water Opex not explicitly accounted for as included in mine and processing opex self.waterOpex = np.zeros(numYears)
def CalculateRegionalPowerExpenses(self, problemManager, distanceToPower): """ Calculate power transmission infrastructure costs.""" # distanceToPower is assumed given in km theUnitManager = UnitManager() powerCosts = np.zeros(distanceToPower.shape) if (self.includePowerInfrastructureCosts): AUD2010 = MiningEquipmentPriceIndex.IndexedPrice( 1.0, 2010, 2018) * theUnitManager.ConvertToBaseUnits( "AUD") #in today's dollars AUD2014 = MiningEquipmentPriceIndex.IndexedPrice( 1.0, 2014, 2018) * theUnitManager.ConvertToBaseUnits("AUD") AUD2016 = MiningEquipmentPriceIndex.IndexedPrice( 1.0, 2016, 2018) * theUnitManager.ConvertToBaseUnits("AUD") powerCosts[distanceToPower > 190] = 925000 * AUD2014 powerCosts[np.logical_and( distanceToPower <= 190, distanceToPower > 150)] = 650000 * AUD2014 powerCosts[np.logical_and(distanceToPower <= 150, distanceToPower > 1)] = 300000 * AUD2010 powerCosts[distanceToPower <= 1] = 75000 * AUD2010 powerCosts *= distanceToPower return powerCosts
def CalculateMineLife(self, mineManager): """ Determine the life of the mine """ # NB - Taylor's rule may need to be tweaked for open cut # - original tracks amount of ore produced (based on processing cost) # - therefore assume that mine material moved is sufficient to meet this on average # Current calculation - calculate break even SR based on Open cut capacity # - determine depth where break even SR is reached # - mine to depth at open cut capacity based on average SR to reach that depth # - continue ug mining at processing capacity self.orebodyMass = mineManager.theOreBody.CalculateDepositMass() self.mineLife = self.orebodyMass / ( self.mineOreProductionCapacity + 1e-64 ) # rampup/rampdown are not accounted for self.mineLife = int(np.ceil(self.mineLife)) # round up to years theUnitManager = UnitManager() orebodyMass = mineManager.theOreBody.CalculateDepositMass( ) * theUnitManager.ConvertTo("tonne") print("orebodyMass in 1e6 tonne", orebodyMass / 1e6) # undergound rampLength = mineManager.theOreBody.cover * ( 1. + 1. / self.rampGrade**2)**0.5 rampVolume = 25 * theUnitManager.ConvertToBaseUnits("m^2") * rampLength # opencut if (self.miningMethod[:2] == "OC"): w = mineManager.theOreBody.width l = mineManager.theOreBody.length d = mineManager.theOreBody.cover rampVolume = self.OpenPitExcavatedVolume(w, l, 0, d, self.alpha) overburdenDensity = mineManager.theOreBody.specificDensity * 1000 * theUnitManager.ConvertToBaseUnits( "kg/m^3") self.actualMineStartupTime = (overburdenDensity * rampVolume) / (self.mineCapacity + 1e-64) if (self.miningMethod == "K2SO4"): self.actualMineStartupTime = 1 # assume 1 year startup for brine self.mineStartupTime = np.max( [int(np.ceil(self.actualMineStartupTime)), 1]) # round up to years self.mineLife += self.mineStartupTime self.miningCapex = np.zeros(self.mineLife) self.miningOpex = np.zeros(self.mineLife) self.depths = np.zeros(self.mineLife) #print "mineLife", self.mineLife #print "mineStartupTime", self.mineStartupTime return self.mineLife
def CalculateDepositVolume(self): """ Calculate volume of ore given the mass """ theUnitManager = UnitManager() waterDensity = theUnitManager.ConvertToBaseUnits( "1000 kg/m^3") # water density in base units self.orebodyVolume = self.orebodyMass / (self.specificDensity * waterDensity)
def RoadConstructionCapex(self, distance): # nb fleet costs are also required CovertTo2018Price = MiningEquipmentPriceIndex.IndexedPrice( 1.0, 2010, 2018) theUnitManager = UnitManager() thousandAUDPerkm = 1000. * theUnitManager.ConvertToBaseUnits("AUD/km") cost = distance * 1750. * CovertTo2018Price * thousandAUDPerkm return cost
def CalculateWaterUsePerYear(self, problemManager): """Calculate average water use.""" theUnitManager = UnitManager() processingCapacityInTonne = problemManager.theMineDataManager.theProcessingSystem.processingCapacity * theUnitManager.ConvertTo( "tonne") # tonnes per year q = 2.35 * processingCapacityInTonne # in kL/year assumes 2.35 kL water per tonne q *= theUnitManager.ConvertToBaseUnits( "kL") # should be 1:1 in most cases return q
def CalculateDepositMass(self): """ Calculate mass of ore """ theUnitManager = UnitManager() waterDensity = theUnitManager.ConvertToBaseUnits( "1000 kg/m^3") # water density in base units self.orebodyVolume = self.shapeFactor * self.length * self.width * self.height self.orebodyMass = self.orebodyVolume * self.specificDensity * waterDensity # print "orebody mass in kg", self.orebodyMass # in kg return self.orebodyMass
def DetermineMiningSystem(self, problemManager, mineManager): """ Use available data to determine the most likely mining method/capacity/opex etc. """ flatPlunge = 20 * np.pi / 180. steepPlunge = 55 * np.pi / 180. theUnitManager = UnitManager() narrowWidth = theUnitManager.ConvertToBaseUnits("10m") thickWidth = theUnitManager.ConvertToBaseUnits("30m") # Thick > 30 m # Intermediate 10-30m # Narrow < 10 m # Plunge # Flat < 20 degrees # Intermediate 20-55 degrees # Steep > 55 degrees doUnderground = self.miningMethod == "UG" print("doUnderground", doUnderground) print("mineManager.theOreBody.dip", mineManager.theOreBody.dip) if (doUnderground): if (mineManager.theOreBody.dip < flatPlunge ): # see selection process for hard rock mining by Carter self.miningMethod = "UG_RP" # Room and pilar # "Typically flat and tabular" elif (mineManager.theOreBody.width < narrowWidth): # Cut and fill self.miningMethod = "UG_CF" elif (mineManager.theOreBody.dip > steepPlunge and mineManager.theOreBody.width > thickWidth and mineManager.theOreBody.height > mineManager.theOreBody.width): # Block cave self.miningMethod = "UG_BC" else: # Stoping self.miningMethod = "UG_ST" self.CalculateMineCapacity(problemManager, mineManager) self.CalculateMineLife(mineManager) self.CalculateOreMined(mineManager) self.CalculateMiningCapex(mineManager) self.CalculateMiningOpex(mineManager) return self
def RoadTransportOpex(self, distance, mass): CovertTo2018Price = MiningEquipmentPriceIndex.IndexedPrice( 1.0, 2010, 2018) theUnitManager = UnitManager() # 8.5 cents per km centsPerTonnePerKm = 0.01 * theUnitManager.ConvertToBaseUnits( "AUD/tonne/km") cost = distance* mass * \ 8.5* CovertTo2018Price* centsPerTonnePerKm return cost
def FindOPMarginalOreCostAtDepth(self, oreProductionRate, w, l, d, newD, alpha, materialCostFunc): """ Find marginal cost at depth per unit ore from a material cost function based on the mine capacity in terms of total material mined """ totalCapacity = self.RequiredTotalCapacity(oreProductionRate, w, l, d, newD, alpha) theUnitManager = UnitManager() costAtDepthPerUnitMaterial = materialCostFunc.f( [totalCapacity * theUnitManager.ConvertTo("1e6 tonne")]) marginalcostAtDepth = self.MarginalCostAtDepthPerUnitOre( costAtDepthPerUnitMaterial, w, l, newD, alpha) return marginalcostAtDepth
def GetAttributeVector(node,attribute): """ Returns vector valued attribute (containing comma separated values).""" theString = GetAttributeString(node,attribute) theUnitManager = UnitManager() rv = [] for x in theString.split(","): # Allow paths to be passed to sensitivity calculations if ('.npy' in x) or ('.txt' in x): rv.append(x) else: rv.append(theUnitManager.ConvertToBaseUnits(x)) # rv = [theUnitManager.ConvertToBaseUnits(x) for x in theString.split(",")] return rv
def CalculateOpex(self, hydrogenManager): """Calculate opex costs for energy storage facility.""" theFunctionManager = FunctionManager() theUnitManager = UnitManager() opexFunc = theFunctionManager.GetFunction("StorageOpex_" + self.type) # opex Per MWh stored as a function of output capacity in MW opexPerMWh = opexFunc.f( [self.storageOutputCapacity *theUnitManager.ConvertTo("MW")] ) self.opex = opexPerMWh*self.energyStored*theUnitManager.ConvertTo("MWh") return self.opex
def CalculateMineLife(self, mineManager): """ Determine the life of the mine """ self.orebodyMass = mineManager.theOreBody.CalculateDepositMass() self.mineLife = self.orebodyMass / ( self.mineOreProductionCapacity + 1e-64 ) # rampup/rampdown are not accounted for self.mineLife = int(np.ceil(self.mineLife)) # round up to years theUnitManager = UnitManager() orebodyMass = mineManager.theOreBody.CalculateDepositMass( ) * theUnitManager.ConvertTo("tonne") print("orebodyMass in 1e6 tonne", orebodyMass / 1e6) # undergound rampLength = mineManager.theOreBody.cover * ( 1. + 1. / self.rampGrade**2)**0.5 rampVolume = 25 * theUnitManager.ConvertToBaseUnits("m^2") * rampLength # opencut if (self.miningMethod[:2] == "OC"): w = mineManager.theOreBody.width l = mineManager.theOreBody.length d = mineManager.theOreBody.cover rampVolume = self.OpenPitExcavatedVolume(w, l, 0, d, self.alpha) overburdenDensity = mineManager.theOreBody.specificDensity * 1000 * theUnitManager.ConvertToBaseUnits( "kg/m^3") self.actualMineStartupTime = (overburdenDensity * rampVolume) / (self.mineCapacity + 1e-64) self.mineStartupTime = np.max( [int(np.ceil(self.actualMineStartupTime)), 1]) # round up to years self.mineLife += self.mineStartupTime self.miningCapex = np.zeros(self.mineLife) self.miningOpex = np.zeros(self.mineLife) self.depths = np.zeros(self.mineLife) print("mineLife", self.mineLife) print("mineStartupTime", self.mineStartupTime) return self.mineLife
def CalculateCapex(self, hydrogenManager): """ Calculate hydrogen plant startup costs. NB all costs are assumed capitalized.""" self.capex = np.zeros(self.projectLife) theFunctionManager = FunctionManager() theUnitManager = UnitManager() capexFunc = theFunctionManager.GetFunction("HydrogenCapex_" + self.type) self.capex[0] = capexFunc.f([ self.hydrogenPlantCapacity * theUnitManager.ConvertTo("1e6 tonne") ]) return self.capex
def CalculateHydrogenProduced(self, hydrogenManager): """ Calculate hydrogen production over plant lifetime and estimate associated water and energy requirements.""" self.hydrogenProduced = np.zeros(self.projectLife) theUnitManager = UnitManager() liters = theUnitManager.ConvertToBaseUnits( "L") # will convert water to kL (m^3) self.hydrogenProduced[ int(self.startupTime ):] = self.hydrogenProductionCapacity #constant in all years self.energyUse = self.hydrogenProduced * self.energyPerKgH2 self.waterUse = self.hydrogenProduced * liters * self.waterPerKgH2 return self.hydrogenProduced
def CalculateProcessingCapex(self, problemManager, mineDataManager): self.processingCapex = np.zeros( mineDataManager.theMiningSystem.mineLife) theFunctionManager = FunctionManager() processingCapexFunc = theFunctionManager.GetFunction( "ProcessingCapex_" + self.processingMethod) theUnitManager = UnitManager() self.processingCapex[0] = processingCapexFunc.f( [self.processingCapacity * theUnitManager.ConvertTo("1e6 tonne")]) print "Processing Capex ", self.processingCapex[0] return self.processingCapex