def testCalculateGasDispersionModel():
gasExitTemprature = 350 #K
stackDiameter = 1 #m
stackHeight = 5 #m
exitGasSpeed = 4 #m/s
sourceEmissionRate = 2000 #kg/s
day = False
terrain = 'rural'
windRefHeight = WeatherInfo.windRefHeight()
intervalOfObservations = 100 #m
y = 0
z = 2 #m height of human
gas = 'CH4'
gravity = GasChemicalConstantsUtilityFunction.getGravity()
airDensity = GasChemicalConstantsUtilityFunction.getAirDensity()
gasLeakLat = 19.43000031
gasLeakLong = -99.09999847
temprature, windBearing, windDirection, windVelocity, weather, pressure, cloudCoverage, hour, day = WeatherInfo.weatherInfo(
gasLeakLat, gasLeakLong)
dispersionModel = ToxicLightGasDispersionPlumeModel()
concentrationData = dispersionModel.calculateConcentrationForPlumeGas(
cloudCoverage, windVelocity, windBearing, weather, day, terrain,
gravity, windRefHeight, temprature, gasExitTemprature,
intervalOfObservations, stackDiameter, stackHeight, exitGasSpeed,
sourceEmissionRate, y, z, gas, gasLeakLat, gasLeakLong)
visual_on_maps.drawForLightPlume(concentrationData, 15)
print("Final outcome " + str(concentrationData.head(500)))
concentrationData.to_csv("testOutComeLightGasPlume.csv")
def testCaseOutFlowOfMassForholeInAVessel():
vesselVolume = 50 #m3
initialVesselPressure = 5 * (10**6) #pa
ambientPressure = 1 * (10**5) #mpa
initialVesselTemprature = 288.15 #K
holeDiameter = 0.1 #m
molecularWeightOfHydrogen = 0.002 #kg/mol
# mw = GasChemicalConstantsUtilityFunction.getGasMolecularWeight("H2")
specificHeat = 10.24
poissonRatio = 1.4
dischargeCoeff = 0.62
R = GasChemicalConstantsUtilityFunction.getUniversalGasConstant()
timeStep = 1
massFlowRate, initialDensity = outflowMassFlowRateForholeInVesselWall(
initialVesselPressure, initialVesselTemprature, ambientPressure,
holeDiameter, dischargeCoeff, molecularWeightOfHydrogen, poissonRatio,
R)
newDensity, newTemprature, newPressure = outflowMassFlowRateForWholeInVesselWallNextState(
vesselVolume, massFlowRate, timeStep, molecularWeightOfHydrogen,
initialDensity, specificHeat, initialVesselPressure,
initialVesselTemprature, R)
print(massFlowRate)
print(initialDensity)
print(newDensity)
print(newTemprature)
print(newPressure)
def __init__(self, gasName, windSpeed, windBearing, weather,
initial_concentration, dispersion_volume, source_radius,
gasLeakLat, gasLeakLong):
self.gasName = gasName
self.gas_density = GasChemicalConstantsUtilityFunction.getGasDensity(
gasName)
self.wind_speed = windSpeed
self.dispersion_volume = dispersion_volume
self.initial_concentration = initial_concentration
self.source_radius = source_radius
self.gravity = GasChemicalConstantsUtilityFunction.getGravity()
self.air_density = GasChemicalConstantsUtilityFunction.getAirDensity()
self.windBearing = windBearing
self.gasLeakLat = gasLeakLat
self.gasLeakLong = gasLeakLong
self.weather = weather
self.lc50, self.ldhl, self.loc = GasChemicalConstantsUtilityFunction.getGasLethalConcentration(
gasName, GasChemicalConstantsUtilityFunction.KG)
def enumerateAllPossibleValuesforSetOfGivenToxicCompressedGasVolumes(gasName):
type = 'CG'
initialVesselPressure = GasChemicalConstantsUtilityFunction.typicalStoragePresure[
gasName]
ambientPressure = 101325 # pa
initialVesselTemprature = GasChemicalConstantsUtilityFunction.typicalStorageTemp[
gasName]
holeDiameters = [0.025, 0.075, 0.11, 0.15] # m
columnName = [
'gasName', 'holeDiameter', 'initialOutFlowMass',
'initialOutflowVolume', 'initialDensity'
]
volumeOfGas = pandas.DataFrame(columns=columnName)
#Get Chemical properties
gasName, molecularWeight, poissonRatio, R, airDensity, gravity, gasDensity, specificHeat, lc50, ldhl, loc = \
GasChemicalConstantsUtilityFunction.getChemicalPropertiseofGivenGas(gasName)
liquidHeatCapacity, Hvap, boilingTemprature, liquidDensity, gasDensity, criticalTemprature, criticalPressure = \
GasChemicalConstantsUtilityFunction.getChemicalPropertiesForAGivenGasAtGivenTempandPressure(gasName, initialVesselTemprature, initialVesselPressure)
molecularWeightOfGivenGas = molecularWeight / 1000 # kg/mol
dischargeCoeff = 0.62
maxoutflow = 0
corespondingRadius = 0
for holeDiameter in holeDiameters:
initialOutflowMass, initialOutflowVolume, initialDensity = outflowMassFlowRateForholeInVesselWall(
initialVesselPressure, initialVesselTemprature, ambientPressure,
holeDiameter, dischargeCoeff, molecularWeightOfGivenGas,
poissonRatio, R)
if (maxoutflow < initialOutflowVolume):
maxoutflow = initialOutflowVolume
corespondingRadius = holeDiameter
tuplesValues = [
gasName, holeDiameter, initialOutflowMass, initialOutflowVolume,
initialDensity
]
volumeOfGas = volumeOfGas.append(pandas.DataFrame([tuplesValues],
columns=columnName),
ignore_index=True)
volumeOfGas.to_csv("volumeOfCompressedGas.csv")
return type, maxoutflow, corespondingRadius
def testCalculateGasDispersionModel():
tempratureOfReleaseGas = 420 # K
stackDiameter = 1 # m
stackHeight = 2 # m
day = True
terrain = 'rural'
windRefHeight = 10 # m
intervalOfObservations = 200 # m
coeff = 0.64
y = 0
gas = 'Cl2'
z = 2 #m height of human
puffInitialRadius = 1
TotalGasMassInPuff = 500
timeList = [-1, 60, 240]
gravity = GasChemicalConstantsUtilityFunction.getGravity()
airDensity = GasChemicalConstantsUtilityFunction.getAirDensity()
gasLeakLat = 19.43000031
gasLeakLong = -99.09999847
temprature, windBearing, windDirection, windVelocity, weather, pressure, cloudCoverage,hour,day = WeatherInfo.weatherInfo(
gasLeakLat, gasLeakLong)
dispersionModel = ToxicLightGasDispersionPuffModel()
concentrationData = dispersionModel.calculateConcentrationForPuffGas(stackHeight, cloudCoverage, day, gravity, airDensity,
TotalGasMassInPuff,
puffInitialRadius,
intervalOfObservations, windVelocity,windBearing,weather, windRefHeight, temprature,
tempratureOfReleaseGas, terrain, y, z,timeList, coeff,gas,gasLeakLat,gasLeakLong)
print("Final outcome " + str(concentrationData.head(500)) )
concentrationData.to_csv("testOutComePuffmodelLightGases.csv")
map = visual_on_maps.drawForLightPuff(concentrationData,15)
#draw the graphics.
visual_on_maps.distance_conc('x', 'Cpeak', "light", "puff", concentrationData, "distance (m)")
map
def predictGasDispersionLightGasPlume(gasExitTemprature, stackDiameter,
stackHeight, exitGasSpeed,
sourceEmissionRate, terrain, gas,
gasLeakLat, gasLeakLong):
model = "LightGasPlume"
intervalOfObservations = 100 # m
y = 0
z = 2 # m height of human
windRefHeight = WeatherInfo.windRefHeight()
gravity = GasChemicalConstantsUtilityFunction.getGravity()
airDensity = GasChemicalConstantsUtilityFunction.getAirDensity()
temprature, windBearing, windDirection, windVelocity, weather, pressure, cloudCoverage,hour,day \
= WeatherInfo.weatherInfo(gasLeakLat,gasLeakLong)
dispersionModel = ToxicLightGasDispersionPlumeModel()
concentrationData = dispersionModel.calculateConcentrationForPlumeGas(
cloudCoverage, windVelocity, windBearing, weather, day, terrain,
gravity, windRefHeight, temprature, gasExitTemprature,
intervalOfObservations, stackDiameter, stackHeight, exitGasSpeed,
sourceEmissionRate, y, z, gas, gasLeakLat, gasLeakLong)
concentrationData.to_csv("testOutComeLightGasPlume.csv")
return model, concentrationData
def testCaseOutFlowOfMassForTotalPipeRapture():
initialPressureInPipe = 0.5 * (10**6) # Pa
initialTempratureOfPipe = 288.15 #K
ambientPressure = 1 * (10**5) #mpa
pipeDiameter = 1 #K
pipeLengthUntilRapturePoint = 10000 #m
molecularWeightOfPropane = GasChemicalConstantsUtilityFunction.getGasMolecularWeight(
"LPG")
poissonRatio = 1.19
dischargeCoeff = 1
R = GasChemicalConstantsUtilityFunction.getUniversalGasConstant()
timeStep = 1
massFlowRate, initialOutflowVolume, initialDensity, initialMass, initialVolume = gasMassFlowTotalPipeLineRapture(
initialPressureInPipe, ambientPressure, initialTempratureOfPipe,
pipeDiameter, pipeLengthUntilRapturePoint, dischargeCoeff,
molecularWeightOfPropane, poissonRatio, R)
print(massFlowRate)
print(initialOutflowVolume)
print(initialDensity)
print(initialMass)
print(initialVolume)
def predictGasDispersionLightGasPuff(tempratureOfReleaseGas, stackHeight, terrain, windRefHeight,
gas, puffInitialRadius, TotalGasMassInPuff, timeList, gasLeakLat, gasLeakLong):
model = "LightGasPuff"
intervalOfObservations = 200 # m
coeff = 0.64
y = 0
z = 2 # m height of human
gravity = GasChemicalConstantsUtilityFunction.getGravity()
airDensity = GasChemicalConstantsUtilityFunction.getAirDensity()
temprature, windBearing, windDirection, windVelocity, weather, pressure, cloudCoverage,hour,day = WeatherInfo.weatherInfo(
gasLeakLat, gasLeakLong)
dispersionModel = ToxicLightGasDispersionPuffModel()
concentrationData = dispersionModel.calculateConcentrationForPuffGas(stackHeight, cloudCoverage, day, gravity, airDensity,
TotalGasMassInPuff,
puffInitialRadius,
intervalOfObservations, windVelocity,windBearing,weather, windRefHeight, temprature,
tempratureOfReleaseGas, terrain, y, z,timeList, coeff,gas,gasLeakLat,gasLeakLong)
concentrationData.to_csv("testOutComePuffmodelLightGases.csv")
return model, concentrationData
def calculateConcentrationForPlumeGas(
self, cloudCoverage, windVelocity, windBearing, weather, day,
terrain, gravity, windRefHeight, ambientTemprature,
gasExitTemprature, intervalOfObservations, stackDiameter,
stackHeight, exitGasSpeed, sourceEmissionRate, y, z, gas,
gasLeakLat, gasLeakLong):
stabilityClass = gdmuf.getAtmospericStabilityClass(
windVelocity, cloudCoverage, day)
# for test
#stabilityClass = 'D'
# Wind Speed at the top of the stack
windSpeedAtStackHeight = gdmuf.calculateWindSpeedAtStackHeight(
stabilityClass, windVelocity, stackHeight, windRefHeight, terrain)
print("windSpeedAtStackHeight " + str(windSpeedAtStackHeight) +
"windVelocity " + str(windVelocity))
stackEffectiveHeight = tlgdphr.effectiveStackHeight(
stackHeight, stackDiameter, exitGasSpeed, windSpeedAtStackHeight)
isBuoyancy = tlgdphr.isBuoyancyDominated(stabilityClass,
gasExitTemprature,
ambientTemprature,
stackDiameter, exitGasSpeed)
# for testing
#isBuoyancy = False
buoyancyFluxParameter = tlgdphr.calculateBuoyancyFluxParameter(
gravity, exitGasSpeed, stackDiameter, gasExitTemprature,
ambientTemprature)
distanceOfMaxPlumeRise = tlgdphr.calculationOfDistanceOfMaximumPlumeRise(
isBuoyancy, buoyancyFluxParameter, stabilityClass,
windSpeedAtStackHeight, gasExitTemprature, stackDiameter,
exitGasSpeed)
gradualPlumeRise, plumeRisexf = tlgdphr.calculationOfFinalPlumeRise(
isBuoyancy, buoyancyFluxParameter, stackEffectiveHeight,
distanceOfMaxPlumeRise, intervalOfObservations, stabilityClass,
windSpeedAtStackHeight, ambientTemprature, gasExitTemprature,
stackDiameter, exitGasSpeed)
startingPoint = 0
if (gas != None):
list_c50 = [
'y_c50', 'y_c50_lat1', 'y_c50_long1', 'y_c50_lat2',
'y_c50_long2'
]
list_idlh = [
'y_idlh', 'y_idlh_lat1', 'y_idlh_long1', 'y_idlh_lat2',
'y_idlh_long2'
]
list_loc = [
'y_loc', 'y_loc_lat1', 'y_loc_long1', 'y_loc_lat2',
'y_loc_long2'
]
nameOfColumns = [
'gas', 'x', 'x_lat', 'x_long', 'gasLeakLat', 'gasLeakLong',
'he', 'sigmx', 'sigmay', 'C', 'windSpeed', 'windBearing',
'weather'
]
nameOfColumns.extend(list_c50)
nameOfColumns.extend(list_idlh)
nameOfColumns.extend(list_loc)
else:
nameOfColumns = [
'gas', 'x', 'x_lat', 'x_long', 'gasLeakLat', 'gasLeakLong',
'he', 'sigmx', 'sigmay', 'C', 'windSpeed', 'windBearing',
'weather'
]
concentrationAndDistanceDataFrame = pandas.DataFrame(
columns=nameOfColumns)
for values in gradualPlumeRise:
observationPoint = values[0] #distance in x direction
plumeRise = values[1] #plume height
sigma_y, sigma_z = self.DispersionCoefficientPlume(
observationPoint, stabilityClass, terrain)
c = self.calcuateConcentration(sourceEmissionRate,
windSpeedAtStackHeight, sigma_y,
sigma_z, plumeRise,
observationPoint, y, z)
lat2, long2 = latLongUtil.endPointLatLong(gasLeakLat, gasLeakLong,
observationPoint,
windBearing)
if (gas != None):
c0 = self.calcuateConcentration(sourceEmissionRate,
windSpeedAtStackHeight,
sigma_y, sigma_z, plumeRise,
observationPoint, 0, 0)
y_c50, y_idlh, y_loc = gdmuf.calculateIsopleths(
sigma_y, gas, c0,
GasChemicalConstantsUtilityFunction.MICROG)
#need to calculate the various lat long of isopleths
y_lc501_lat, y_lc501_long = latLongUtil.endPointLatLong(
lat2, long2, y_c50, windBearing + 90)
y_lc502_lat, y_lc502_long = latLongUtil.endPointLatLong(
lat2, long2, -y_c50, windBearing + 90)
l1 = [
y_c50, y_lc501_lat, y_lc501_long, y_lc502_lat, y_lc502_long
]
y_ldhl1_lat, y_ldhl1_long = latLongUtil.endPointLatLong(
lat2, long2, y_idlh, windBearing + 90)
y_ldhl2_lat, y_ldhl2_long = latLongUtil.endPointLatLong(
lat2, long2, -y_idlh, windBearing + 90)
l2 = [
y_idlh, y_ldhl1_lat, y_ldhl1_long, y_ldhl2_lat,
y_ldhl2_long
]
y_loc1_lat, y_loc1_long = latLongUtil.endPointLatLong(
lat2, long2, y_loc, windBearing + 90)
y_loc2_lat, y_loc2_long = latLongUtil.endPointLatLong(
lat2, long2, -y_loc, windBearing + 90)
l3 = [y_loc, y_loc1_lat, y_loc1_long, y_loc2_lat, y_loc2_long]
#We will calculate the lat long for all the y values
tupleValues = [
gas, observationPoint, lat2, long2, gasLeakLat,
gasLeakLong, plumeRise, sigma_y, sigma_z,
math.floor(c), windVelocity, windBearing, weather
]
tupleValues.extend(l1)
tupleValues.extend(l2)
tupleValues.extend(l3)
else:
tupleValues = [
gas, observationPoint, lat2, long2, gasLeakLat,
gasLeakLong, plumeRise, sigma_y, sigma_z,
math.floor(c), windVelocity, windBearing, weather
]
# print(tupleValues)
# nameOfColumns = ['x', 'he', 'sigmx', 'sigmay', 'C']
concentrationAndDistanceDataFrame = concentrationAndDistanceDataFrame.append(
pandas.DataFrame([tupleValues], columns=nameOfColumns),
ignore_index=True)
startingPoint = observationPoint
intervalOfObservations = 2 * intervalOfObservations
initialC = 0
observationPoint = startingPoint
#we align observation point with the nearest hundred.
x = observationPoint % 100
observationPoint = observationPoint + x
lc50, ldhl, loc = GasChemicalConstantsUtilityFunction.getGasLethalConcentration(
gas, GasChemicalConstantsUtilityFunction.MICROG)
stopingConcentration = 0.5 * loc
for x in range(1, 1000):
observationPoint = observationPoint + intervalOfObservations
if (observationPoint >= 1000):
intervalOfObservations = 200
#print("observation point " + str(observationPoint))
#if ((observationPoint >= 1000) & (observationPoint < 3000)):
# intervalOfObservations = 500
#elif ((observationPoint >= 3000) & (observationPoint < 10000)):
# intervalOfObservations = 1000
#elif (observationPoint >= 10000):
# intervalOfObservations = 10000
sigma_y, sigma_z = self.DispersionCoefficientPlume(
observationPoint, stabilityClass, terrain)
c = self.calcuateConcentration(sourceEmissionRate,
windSpeedAtStackHeight, sigma_y,
sigma_z, plumeRisexf,
observationPoint, y, z)
lat2, long2 = latLongUtil.endPointLatLong(gasLeakLat, gasLeakLong,
observationPoint,
windBearing)
if (gas != None):
c0 = self.calcuateConcentration(sourceEmissionRate,
windSpeedAtStackHeight,
sigma_y, sigma_z, plumeRise,
observationPoint, 0, 0)
y_c50, y_idlh, y_loc = gdmuf.calculateIsopleths(
sigma_y, gas, c0,
GasChemicalConstantsUtilityFunction.MICROG)
y_lc501_lat, y_lc501_long = latLongUtil.endPointLatLong(
lat2, long2, y_c50, windBearing + 90)
y_lc502_lat, y_lc502_long = latLongUtil.endPointLatLong(
lat2, long2, -y_c50, windBearing + 90)
l1 = [
y_c50, y_lc501_lat, y_lc501_long, y_lc502_lat, y_lc502_long
]
y_ldhl1_lat, y_ldhl1_long = latLongUtil.endPointLatLong(
lat2, long2, y_idlh, windBearing + 90)
y_ldhl2_lat, y_ldhl2_long = latLongUtil.endPointLatLong(
lat2, long2, -y_idlh, windBearing + 90)
l2 = [
y_idlh, y_ldhl1_lat, y_ldhl1_long, y_ldhl2_lat,
y_ldhl2_long
]
y_loc1_lat, y_loc1_long = latLongUtil.endPointLatLong(
lat2, long2, y_loc, windBearing + 90)
y_loc2_lat, y_loc2_long = latLongUtil.endPointLatLong(
lat2, long2, -y_loc, windBearing + 90)
l3 = [y_loc, y_loc1_lat, y_loc1_long, y_loc2_lat, y_loc2_long]
# We will calculate the lat long for all the y values
tupleValues = [
gas, observationPoint, lat2, long2, gasLeakLat,
gasLeakLong, plumeRise, sigma_y, sigma_z,
math.floor(c), windVelocity, windBearing, weather
]
tupleValues.extend(l1)
tupleValues.extend(l2)
tupleValues.extend(l3)
else:
tupleValues = [
gas, observationPoint, lat2, long2, gasLeakLat,
gasLeakLong, plumeRise, sigma_y, sigma_z,
math.floor(c), windVelocity, windBearing, weather
]
concentrationAndDistanceDataFrame = concentrationAndDistanceDataFrame.append(
pandas.DataFrame([tupleValues], columns=nameOfColumns),
ignore_index=True)
#print("c " + str(c) + " stoping " + str(stopingConcentration))
if (x > 15) & (c < stopingConcentration):
break
return concentrationAndDistanceDataFrame
def calculateIsoplethConcentration( gas,unit):
return idlh.getGasLethalConcentration(gas, unit)
def enumerateAllPossibleValuesforSetOfGivenToxicLiquifiedGasVolumes(
gasName, windVelocity):
type = 'LG'
#Let collect the various parameters for the given gas.
Ti = GasChemicalConstantsUtilityFunction.typicalStorageTemp[gasName]
Pi = GasChemicalConstantsUtilityFunction.typicalStoragePresure[gasName]
massOfGasInVessel = GasChemicalConstantsUtilityFunction.typicalTransportationMaxContainerSize[
gasName]
# Get Chemical properties at the initial stage when the gas is inside the tank.
liquidHeatCapacity, Hvap_i, boilingTemprature, liquidDensity_i, gasDensity_i, criticalTemprature, criticalPressure = \
GasChemicalConstantsUtilityFunction.getChemicalPropertiesForAGivenGasAtGivenTempandPressure(gasName, Ti, Pi)
Tf = boilingTemprature
Pf = 101325 # Ambient pressure. Pa
# Get the checmical properties at final stage that ambient pressure.
liquidHeatCapacity, Hvap_f, boilingTemprature, liquidDensity_f, gasDensity_f, criticalTemprature, criticalPressure = \
GasChemicalConstantsUtilityFunction.getChemicalPropertiesForAGivenGasAtGivenTempandPressure(gasName, Tf, Pf)
BoilingTempratureAtStandardPressure = Tf # K
# pressure = 0.1 * (10**6) #Pa
liquidDensityAtInitialStage = liquidDensity_i
vapourDensityAtIntialStage = gasDensity_i
liquidDensityAtBoilingPointAtmosphericPressure = liquidDensity_f
vapourDensityAtBoilingPointAtmosphericPressure = gasDensity_f
vapourEnthalpyAtInitialStage = 483000 # j/kg not sure how to calculate automatically
vapourEnthalpyAtBoilingPointAtmosphericPressure = 383000 # j/kg not sure how to calculate automatically
heatOfVapourizationInitialStage = Hvap_i
heatOfVaporizationAtArmospericPressure = Hvap_f
liquidHeatCapacity = liquidHeatCapacity
# windVelocity = 3.5 #m/s Gather above using the wounderground API
initialMassFraction = 0.05
#massOfGasInVessel = 5000 # kg
tempratureInVessel = Ti
pressureInVessel = Pi
columnName = [
'windSpeed', 'MassInVessel', 'density', 'volume', 'radius',
'VelocityOfExpansion', 'finalRadius'
]
volumeOfGas = pandas.DataFrame(columns=columnName)
for massOfGasInVessel in range(100, 10000, 100):
m, d, v, r, uf, Rt = liquidfiedGasMassFlowTotalRaptureOfVessel(
initialMassFraction, tempratureInVessel,
BoilingTempratureAtStandardPressure,
heatOfVapourizationInitialStage,
heatOfVaporizationAtArmospericPressure, liquidHeatCapacity,
liquidDensityAtBoilingPointAtmosphericPressure,
vapourDensityAtBoilingPointAtmosphericPressure, massOfGasInVessel,
vapourEnthalpyAtInitialStage,
vapourEnthalpyAtBoilingPointAtmosphericPressure, pressureInVessel,
Pf, vapourDensityAtIntialStage, liquidDensityAtInitialStage,
windVelocity)
tupleValues = [windVelocity, massOfGasInVessel, d, v, r, uf, Rt]
volumeOfGas = volumeOfGas.append(pandas.DataFrame([tupleValues],
columns=columnName),
ignore_index=True)
object = volumeOfGas.describe(percentiles=[0.25, 0.75])
#print(type(object))
#print(object)
#print(object.loc['75%']['finalRadius'])
volumeOfGas.to_csv("volumeOfLiquifiedGases.csv")
finalRadius75 = object.loc['75%']['finalRadius']
finalVolume75 = object.loc['75%']['volume']
finalRadius25 = object.loc['25%']['finalRadius']
finalVolume25 = object.loc['25%']['volume']
return type, finalRadius75, finalVolume75, finalRadius25, finalVolume25
def calculateConcentrationForPuffGas(self,stackHeight,cloudCoverage, day, gravity, airDensity, TotalGasMassInPuff, puffInitialRadius,
intervalOfObservations, windVelocity,windBearing,weather, windRefHeight,ambientTemprature, tempratureOfReleaseGas,terrain,y,z,
timeList, coeff, gas,gasLeakLat,gasLeakLong):
print("windVelocity " + str(windVelocity) + " cloudCoverage " + str(cloudCoverage) + " day " + str(day))
stabilityClass = utilityFunction.getAtmospericStabilityClass(windVelocity, cloudCoverage, day)
windProfile = utilityFunction.getWindProfileExponent(stabilityClass, terrain)
print("Windprofile - " + str(windProfile))
gradualPuffRise, puffHeight = heightRisePuff.calculatePuffRise(stackHeight, cloudCoverage, day, gravity, airDensity,
TotalGasMassInPuff, puffInitialRadius,intervalOfObservations, windVelocity, ambientTemprature,
tempratureOfReleaseGas, windRefHeight, terrain, coeff)
expandedColumn = ['gas','x','x_lat','x_long', 'gasLeakLat','gasLeakLong','he', 'y','z','sigmx', 'sigmaz','zb','zt','puffRadius','meanWindSpeed','weather','tin','tout','tpeak']
#Add columns to the list of columns for all given time specific concentration.
#print(timeList)
#print(expandedColumn)
for i, val in enumerate(timeList):
columnName = self.createColumnNameStr(val,gas,'C')
expandedColumn.append(columnName)
if (gas != None):
columnName = self.createColumnNameStr(val, gas, 'y_c50_')
expandedColumn.append(columnName)
expandedColumn.extend([columnName+'_lat1',columnName+'_long1', columnName+'_lat2',columnName+'_long2'])
columnName = self.createColumnNameStr(val, gas, 'y_idlh_')
expandedColumn.append(columnName)
expandedColumn.extend(
[columnName + '_lat1', columnName + '_long1' ,columnName + '_lat2', columnName + '_long2'])
columnName = self.createColumnNameStr(val, gas, 'y_loc_')
expandedColumn.append(columnName)
expandedColumn.extend(
[columnName + '_lat1', columnName + '_long1' , columnName + '_lat2', columnName + '_long2'])
print("number of columns " + str(len(expandedColumn)))
concentrationAndDistanceDataFrame = pandas.DataFrame(columns=expandedColumn)
print("gradual puff rise " + str(gradualPuffRise) + "final pluff rise " + str(puffHeight))
startingPoint = 0
for values in gradualPuffRise:
observationPoint = values[0] #distance in x direction
plumeRise = values[1] #plume height
concentrationAndDistanceDataFrame,refConcentration = self.helperCalculateConcentrationForPuffGas(stabilityClass, TotalGasMassInPuff,
plumeRise, windVelocity,windBearing,weather,windRefHeight,windProfile, observationPoint, y, z,
concentrationAndDistanceDataFrame, timeList,gas,gasLeakLat,gasLeakLong,expandedColumn)
startingPoint = observationPoint
intervalOfObservations = 2*intervalOfObservations
initialC = 0
observationPoint = startingPoint
#we align observation point with the nearest hundred.
x = observationPoint % 100
observationPoint = observationPoint + x
lc50, ldhl, loc = GasChemicalConstantsUtilityFunction.getGasLethalConcentration(gas,GasChemicalConstantsUtilityFunction.MICROG)
stopingConcentration = 0.8 * loc
for x in range(1,1000):
observationPoint = observationPoint + intervalOfObservations
concentrationAndDistanceDataFrame,refConcentration = self.helperCalculateConcentrationForPuffGas(stabilityClass,
TotalGasMassInPuff,
plumeRise, windVelocity,windBearing,weather,
windRefHeight, windProfile,
observationPoint,
y, z,
concentrationAndDistanceDataFrame,
timeList,gas,gasLeakLat,gasLeakLong,expandedColumn)
#print("refConcentration " + str(refConcentration) + " stopping concentration " + str(stopingConcentration))
if (x > 15) & (refConcentration < stopingConcentration):
#if we reach a concentration is too low let us break.
break
return concentrationAndDistanceDataFrame