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 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 __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 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 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 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 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 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 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 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 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 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 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 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 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 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 CalculateRegionalTransportationExpenses(self, distanceToRoad, roadTransportationDistance, \
distanceToRail, railTransportationDistance, \
coverMap,concentrateCapacityFunc,discountedTotalConcentrateMassFunc):
AUD2010 = 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") # length prices are $1000 per km - AUD is AUD/km as regional lengths given in km
thousandAUDPerMtkmPerYear = 1000. * 1e-6 * theUnitManager.ConvertToBaseUnits("AUD/tonne") # in AUD/km/tonne - regional lengths given in km
# fleet costs are per 1000 AuD per Mt km/ year
# road/rail capex
roadNPVMap = distanceToRoad * 1750. *AUD2010* thousandAUDPerkm
railNPVMap = distanceToRail * 4500. *AUD2010* thousandAUDPerkm
# fleet capex
fleetCapacityMap = concentrateCapacityFunc(coverMap)
roadNPVMap += fleetCapacityMap * roadTransportationDistance * 40. *AUD2010* thousandAUDPerMtkmPerYear
railNPVMap += fleetCapacityMap * railTransportationDistance * 100. *AUD2010 * thousandAUDPerMtkmPerYear
# discounted continuing costs
discountedTotalConcentrateMassMap = discountedTotalConcentrateMassFunc(coverMap)
centsPerTonnePerKm = 0.01*theUnitManager.ConvertToBaseUnits("AUD/tonne") # actually in AUD/tonne/Km but regional lengths given in km
roadNPVMap += roadTransportationDistance* discountedTotalConcentrateMassMap * \
8.5*AUD2010* centsPerTonnePerKm# 5-12 cents/t/km
railNPVMap += railTransportationDistance* discountedTotalConcentrateMassMap * \
1.75*AUD2010*centsPerTonnePerKm # 1-2.5 cents/t/km
transportationCostNPV = np.minimum(roadNPVMap,railNPVMap)
return transportationCostNPV
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 CalculateRegionalCoalTransportationExpenses(self,problemManager,coalTransportationDistance,massCoalPerMassHydrogen, \
capacityMap,hydrogenPlantCapacity,discountedTotalConcentrateMassFunc):
"""Calculate regional transporation costs for coal transportation."""
AUD2010 = 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"
) # length prices are $1000 per km - AUD is AUD/km as regional lengths given in km
thousandAUDPerMtkmPerYear = 1000. * 1e-6 * theUnitManager.ConvertToBaseUnits(
"AUD/tonne") # in AUD/km/tonne - regional lengths given in km
# fleet costs are per 1000 AuD per Mt km/ year
# road/rail capex
transportationCostNPV = 0.0 # assumed already paid for (for hydrogen export)
# transportation costs
# fleet capex
transportationCostNPV += massCoalPerMassHydrogen * hydrogenPlantCapacity * coalTransportationDistance * 40. * AUD2010 * thousandAUDPerMtkmPerYear
# discounted continuing costs
discountedTotalCoalMassMap = massCoalPerMassHydrogen * discountedTotalConcentrateMassFunc(
capacityMap)
centsPerTonnePerKm = 0.01 * theUnitManager.ConvertToBaseUnits(
"AUD/tonne"
) # actually in AUD/tonne/Km but regional lengths given in km
transportationCostNPV += coalTransportationDistance* discountedTotalCoalMassMap * \
8.5*AUD2010* centsPerTonnePerKm# 5-12 cents/t/km
return transportationCostNPV
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 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 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 CalculateWaterExpenses(self, problemManager, hydrogenDataManager):
"""
Calculate water startup infrastructure costs - ongoing costs are assumed included in the mine and processing cost models.
"""
numYears = hydrogenDataManager.GetProjectDuration()
theUnitManager = UnitManager()
self.totalWaterUse = hydrogenDataManager.theHydrogenPlant.waterUse + hydrogenDataManager.thePowerPlant.waterUse
maxWaterRequirement = np.max(self.totalWaterUse)
AUD2018 = MiningEquipmentPriceIndex.IndexedPrice(1.0, 2018, 2018)
v = 2.0 # 2 m/s flow rate
q = maxWaterRequirement # in kL in kL/year (i.e. m^3/year)
sPerYear = 365 * 24 * 3600
diam = np.sqrt(4 * q / (np.pi * sPerYear * v))
if diam < 150e-3: # capped to prevent -ve pipeline costs (approximate diameter of "small" pipes in AUSIMM cost est)
diam = 150e-3
distanceScale = (
2.6229e6 * diam - 125528
) * AUD2018 # 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
waterCost = hydrogenDataManager.theEconomicDataManager.commodityPrices[
"H2O"] # cost per L/Kg
waterCost *= 1.0 / theUnitManager.ConvertToBaseUnits("L")
#self.waterOpex = np.zeros(numYears)
self.waterOpex = waterCost * self.totalWaterUse
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 CalculateRegionalCO2Expenses(self, problemManager, distanceToCO2,
flowRate):
""" Calculate CO2 pipeline transmission costs to hydrogen plant."""
# distanceToCO2 is assumed given in km
theUnitManager = UnitManager()
co2Costs = np.zeros(distanceToCO2.shape)
flowRateInMtYr = flowRate * theUnitManager.ConvertTo(
"Mt") # covert to Mt/a
#AUD2010 = MiningEquipmentPriceIndex.IndexedPrice(1.0,2010,2018) * theUnitManager.ConvertToBaseUnits("AUD") #in 2018 dollars
#AUD2016 = MiningEquipmentPriceIndex.IndexedPrice(1.0,2016,2018) * theUnitManager.ConvertToBaseUnits("AUD")
AUD2015 = MiningEquipmentPriceIndex.IndexedPrice(
1.0, 2015, 2018) * theUnitManager.ConvertToBaseUnits("AUD")
#powerCosts[distanceToPower > 190] = 925000*AUD2014
# piplelineCostPerKM = 0.315e6*AUD2014 # from core gas production and transmission costs 8 inch class 600 5.6mm wall.
# CCS pipeline cost model from
# AUSTRALIAN POWER GENERATION TECHNOLOGY REPORT
# Predicts pipeline costs in the form of a powerlaw a(l)^b where l is in km
flowRates = np.array([1, 3, 5, 10, 15, 20, 25, 30, 35,
40]) # flow rate Mt/a
aValues = np.array([
0.144, 0.243, 0.333, 0.417, 0.466, 0.568, 0.617, 0.693, 0.799,
0.875
]) # a
bValues = np.array(
[1.25, 1.25, 1.24, 1.27, 1.29, 1.28, 1.29, 1.29, 1.28, 1.27]) # b
if (flowRateInMtYr < 1.0):
flowRateInMtYr = 1.0
a_interp = interpolate.interp1d(flowRates, aValues)
b_interp = interpolate.interp1d(flowRates, bValues)
aActual = AUD2015 * a_interp(flowRateInMtYr) * 1e6
bActual = b_interp(flowRateInMtYr)
co2Costs = aActual * distanceToCO2**bActual
return co2Costs
def DetermineDistanceToInfrastructure(self, problemManager, mineDataManager):
"""
Use available data to determine the most likely processing method/capacity/opex etc.
"""
theUnitManager = UnitManager()
theFunctionManager = FunctionManager()
oneKm = theUnitManager.ConvertToBaseUnits("km") # assumed that distances are given in km
self.distanceToRoad = theFunctionManager.GetFunction("DistanceToRoad").f( mineDataManager.mineLatLong ) *oneKm
self.distanceToRail = theFunctionManager.GetFunction("DistanceToRail").f( mineDataManager.mineLatLong ) *oneKm
self.distanceToWater = theFunctionManager.GetFunction("DistanceToWater").f( mineDataManager.mineLatLong ) *oneKm
self.distanceToPower = theFunctionManager.GetFunction("DistanceToPower").f( mineDataManager.mineLatLong ) *oneKm
self.roadTransportationDistance = theFunctionManager.GetFunction("RoadTransportationDistance").f( mineDataManager.mineLatLong ) *oneKm
self.railTransportationDistance = theFunctionManager.GetFunction("RailTransportationDistance").f( mineDataManager.mineLatLong ) *oneKm
if(self.calculateGas):
self.distanceToGas = theFunctionManager.GetFunction("DistanceToGas").f( mineDataManager.mineLatLong ) *oneKm
def CalculatePlantCapacity(self, problemManager, hydrogenManager):
"""
Determine the maximum production rate, water use and energy requirements
"""
if ((self.type == "BrownCoalGasification")
or (self.type == "BlackCoalGasification")
or (self.type == "SteamMethane")):
self.hydrogenPlantCapacity = self.hydrogenProductionCapacity
else:
self.hydrogenPlantCapacity = self.hydrogenProductionCapacity / self.capacityFactor
# energy use assumes 120 MJ/kg stored in hydrogen (equivalent to 33.33 kWh/kg)
# and efficiency is measured relative to the 120 MJ/kg
theUnitManager = UnitManager()
hydrogenEnergyDensity = theUnitManager.ConvertToBaseUnits("120 MJ/kg")
self.energyPerKgH2 = hydrogenEnergyDensity / (self.energyEfficiency +
1e-64)
self.waterCapacity = self.hydrogenProductionCapacity * self.waterPerKgH2
if (self.co2PerKgH2 == 0.0): # i.e. has not been set manually
if self.type == "BrownCoalGasification":
self.co2PerKgH2 = 22.0 # 22 kg CO2 per kg H - approx based on NREL conversion rates estimates (22-25 kg/kg)
elif self.type == "BlackCoalGasification":
self.co2PerKgH2 = 22.0 # 22 kg CO2 per kg H - approx based on NREL conversion rates estimates (22-25 kg/kg)
elif self.type == "SteamMethane":
self.co2PerKgH2 = 10.26 # 10-11 kg CO2 per kg H
# Approx based on CSIRO conversion rates estimates (3.73 kg CH4/ kg H2 -> 3.73 x 44.01 /16 = 10.26 kg CO2 per kg H2)
if self.type == "BrownCoalGasification":
if (self.coalPerKgH2 == 0.0): # i.e. has not been set manually
self.coalPerKgH2 = self.co2PerKgH2 * 12.01 / 44.01 # mass of carbon required based off amount of CO2 emitted - next we estimate the coal mass
self.coalPerKgH2 /= 0.65 # assumes typical carbon content for brown coal in Australia (65%)
if self.type == "BlackCoalGasification":
if (self.coalPerKgH2 == 0.0): # i.e. has not been set manually
self.coalPerKgH2 = self.co2PerKgH2 * 12.01 / 44.01 # mass of carbon required based off amount of CO2 emitted - next we estimate the coal mass
self.coalPerKgH2 /= 0.80 # assumes typical carbon content for black coal in Australia (80%)
return self.hydrogenProductionCapacity
def CalculateTransportCosts(self,problemManager,mineDataManager):
discountRate = mineDataManager.theEconomicDataManager.discountRate
self.mineLife = mineDataManager.theMiningSystem.mineLife
# discountedOreMass must be in base units
discountFactors = (1.0+discountRate)**np.array(range( int( np.ceil(self.mineLife) ) ) )
discountedOreMass = np.sum(mineDataManager.theMiningSystem.oreMined/discountFactors)
theUnitManager = UnitManager()
oneKm = theUnitManager.ConvertToBaseUnits("1 km")
self.roadTransportCostPerKm = mineDataManager.theInfrastructureManager.RoadTransportOpex(oneKm,discountedOreMass)
self.roadCapitalCostPerKm = mineDataManager.theInfrastructureManager.RoadConstructionCapex(oneKm)
# discount for late start date
startDiscountFactor = 1.0/((1.0+ discountRate)**self.startTime)
self.roadTransportCostPerKm *= startDiscountFactor
self.roadCapitalCostPerKm *= startDiscountFactor
return self