diff --git a/src/behavior.jl b/src/behavior.jl index 7b32a0e..d9c2d13 100644 --- a/src/behavior.jl +++ b/src/behavior.jl @@ -150,11 +150,6 @@ function moveAStep(previousPoint::Dict, stepVariable::Symbol, stepSize::Real, cs newPoint[:s] = previousPoint[:s] + newPoint[:Δs] # position (in m) newPoint[:t] = previousPoint[:t] + newPoint[:Δt] # point in time (in s) newPoint[:v] = previousPoint[:v] + newPoint[:Δv] # velocity (in m/s) - newPoint[:ΔW] = calc_ΔW(previousPoint[:F_T], newPoint[:Δs]) # mechanical work in this step (in Ws) - newPoint[:W] = previousPoint[:W] + newPoint[:ΔW] # mechanical work (in Ws) - newPoint[:ΔE] = calc_ΔE(newPoint[:ΔW]) # energy consumption in this step (in Ws) - newPoint[:E] = previousPoint[:E] + newPoint[:ΔE] # energy consumption (in Ws) - return newPoint end #function moveAStep @@ -225,18 +220,15 @@ function addBreakFreeSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags: # remove the accelerating section from the CS CS[:t] = CS[:t] - get(CS[:behaviorSections], :accelerating, Dict(:t=>0.0))[:t] # total running time (in s) - CS[:E] = CS[:E] - get(CS[:behaviorSections], :accelerating, Dict(:E=>0.0))[:E] # total energy consumption (in Ws) delete!(CS[:behaviorSections], :accelerating) # calculate the accumulated breakFree section information merge!(BS, Dict(:length => drivingCourse[end][:s] - BS[:s_entry], # total length (in m) :s_exit => drivingCourse[end][:s], # last position (in m) :t => drivingCourse[end][:t] - drivingCourse[BS[:dataPoints][1]][:t], # total running time (in s) - :E => drivingCourse[end][:E] - drivingCourse[BS[:dataPoints][1]][:E], # total energy consumption (in Ws) :v_exit => drivingCourse[end][:v])) # exit speed (in m/s))) CS[:t] = CS[:t] + BS[:t] # total running time (in s) - CS[:E] = CS[:E] + BS[:E] # total energy consumption (in Ws) merge!(CS[:behaviorSections], Dict(:breakFree => BS)) end # else: return the characteristic section without a breakFree section @@ -516,12 +508,10 @@ function addAcceleratingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFla merge!(BS, Dict(:length => drivingCourse[end][:s] - BS[:s_entry], # total length (in m) :s_exit => drivingCourse[end][:s], # last position (in m) :t => drivingCourse[end][:t] - drivingCourse[BS[:dataPoints][1]][:t], # total running time (in s) - :E => drivingCourse[end][:E] - drivingCourse[BS[:dataPoints][1]][:E], # total energy consumption (in Ws) :v_exit => drivingCourse[end][:v])) # exit speed (in m/s))) # 03/10 old: CS[:v_peak] = max(drivingCourse[end][:v], CS[:v_entry]) # setting v_peak to the last data points velocity which is the highest reachable value in this characteristic section or to v_entry in case it is higher when running on a path with high resistances CS[:t] = CS[:t] + BS[:t] # total running time (in s) - CS[:E] = CS[:E] + BS[:E] # total energy consumption (in Ws) mergeBehaviorSection!(CS[:behaviorSections], BS) end @@ -773,11 +763,9 @@ function addCruisingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: merge!(BS, Dict(:length => drivingCourse[end][:s] - BS[:s_entry], # total length (in m) :s_exit => drivingCourse[end][:s], # last position (in m) :t => drivingCourse[end][:t] - drivingCourse[BS[:dataPoints][1]][:t], # total running time (in s) - :E => drivingCourse[end][:E] - drivingCourse[BS[:dataPoints][1]][:E], # total energy consumption (in Ws) :v_exit => drivingCourse[end][:v])) # exit speed (in m/s))) CS[:t] = CS[:t] + BS[:t] # total running time (in s) - CS[:E] = CS[:E] + BS[:E] # total energy consumption (in Ws) mergeBehaviorSection!(CS[:behaviorSections], BS) end # else: return the characteristic section without a cruising section @@ -962,11 +950,9 @@ function addDiminishingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlag merge!(BS, Dict(:length => drivingCourse[end][:s] - BS[:s_entry], # total length (in m) :s_exit => drivingCourse[end][:s], # last position (in m) :t => drivingCourse[end][:t] - drivingCourse[BS[:dataPoints][1]][:t], # total running time (in s) - :E => drivingCourse[end][:E] - drivingCourse[BS[:dataPoints][1]][:E], # total energy consumption (in Ws) :v_exit => drivingCourse[end][:v])) # exit speed (in m/s))) CS[:t] = CS[:t] + BS[:t] # total running time (in s) - CS[:E] = CS[:E] + BS[:E] # total energy consumption (in Ws) mergeBehaviorSection!(CS[:behaviorSections], BS) end @@ -1127,11 +1113,9 @@ function addCoastingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: merge!(BS, Dict(:length => drivingCourse[end][:s] - BS[:s_entry], # total length (in m) :s_exit => drivingCourse[end][:s], # last position (in m) :t => drivingCourse[end][:t] - drivingCourse[BS[:dataPoints][1]][:t], # total running time (in s) - :E => drivingCourse[end][:E] - drivingCourse[BS[:dataPoints][1]][:E], # total energy consumption (in Ws) :v_exit => drivingCourse[end][:v])) # exit speed (in m/s))) CS[:t] = CS[:t] + BS[:t] # total running time (in s) - CS[:E] = CS[:E] + BS[:E] # total energy consumption (in Ws) merge!(CS[:behaviorSections], Dict(:coasting=>BS)) end @@ -1282,11 +1266,9 @@ function addBrakingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags::D merge!(BS, Dict(:length => drivingCourse[end][:s] - BS[:s_entry], # total length (in m) :s_exit => drivingCourse[end][:s], # last position (in m) :t => drivingCourse[end][:t] - drivingCourse[BS[:dataPoints][1]][:t], # total running time (in s) - :E => drivingCourse[end][:E] - drivingCourse[BS[:dataPoints][1]][:E], # total energy consumption (in Ws) :v_exit => drivingCourse[end][:v])) # exit speed (in m/s))) CS[:t] = CS[:t] + BS[:t] # total running time (in s) - CS[:E] = CS[:E] + BS[:E] # total energy consumption (in Ws) merge!(CS[:behaviorSections], Dict(:braking=>BS)) end # else: return the characteristic section without a braking section @@ -1311,7 +1293,6 @@ function addHalt!(CS::Dict, drivingCourse::Vector{Dict}, settings::Settings, tra BS = createBehaviorSection("halt", drivingCourse[end][:s], drivingCourse[end][:v], drivingCourse[end][:i]) merge!(BS, Dict(:length => 0.0, # total length (in m) :t => 0.0, # total running time (in s) - :E => 0.0, # total energy consumption (in Ws) :s_exit => drivingCourse[end][:s], # last position (in m) :v_exit => drivingCourse[end][:v])) # exit speed (in m/s))) drivingCourse[end][:behavior] = BS[:type] @@ -1355,9 +1336,4 @@ function recalculateLastBrakingPoint!(drivingCourse, s_target, v_target) # end currentPoint[:Δt] = calc_Δt_with_Δv(currentPoint[:Δv], previousPoint[:a]) # step size (in s) currentPoint[:t] = previousPoint[:t] + currentPoint[:Δt] # point in time (in s) - - currentPoint[:ΔW] = 0.0 # mechanical work in this step (in Ws) - currentPoint[:W] = previousPoint[:W] + currentPoint[:ΔW] # mechanical work (in Ws) - currentPoint[:ΔE] = currentPoint[:ΔW] # energy consumption in this step (in Ws) - currentPoint[:E] = previousPoint[:E] + currentPoint[:ΔE] # energy consumption (in Ws) end #function recalculateLastBrakingPoint diff --git a/src/calc.jl b/src/calc.jl index b2ad4cd..3dd3cdc 100644 --- a/src/calc.jl +++ b/src/calc.jl @@ -12,7 +12,7 @@ function calculateMinimumRunningTime!(movingSection::Dict, settings::Settings, t CSs::Vector{Dict} = movingSection[:characteristicSections] if settings.massModel == :homogeneous_strip && settings.stepVariable == speed - println("WARNING: ! ! ! TrainRun.jl doesn't work reliably for the mass model homogeneous strip with step size v in m/s. The calculation time can be extremely high when calcutlating paths with steep gradients ! ! !") + println("WARNING: ! ! ! TrainRuns.jl doesn't work reliably for the mass model homogeneous strip with step size v in m/s. The calculation time can be extremely high when calcutlating paths with steep gradients ! ! !") end startingPoint=createDataPoint() @@ -119,7 +119,6 @@ function calculateMinimumRunningTime!(movingSection::Dict, settings::Settings, t (CSs[end], drivingCourse) = addHalt!(CSs[end], drivingCourse, settings, train, CSs) movingSection[:t] = drivingCourse[end][:t] # total running time (in s) - movingSection[:E] = drivingCourse[end][:E] # total energy consumption (in Ws) return (movingSection, drivingCourse) end #function calculateMinimumRunningTime diff --git a/src/characteristics.jl b/src/characteristics.jl index 35619dc..1c01b3b 100644 --- a/src/characteristics.jl +++ b/src/characteristics.jl @@ -35,7 +35,6 @@ function secureBrakingBehavior!(movingSection::Dict, a_braking::Real, approxLeve # reset the characteristic section (CS), delete behavior sections (BS) that were used during the preperation for setting v_entry, v_peak and v_exit CS[:behaviorSections] = Dict() - CS[:E] = 0.0 CS[:t] = 0.0 followingCSv_entry = CS[:v_entry] @@ -102,69 +101,8 @@ function secureAcceleratingBehavior!(movingSection::Dict, settings::Settings, tr # reset the characteristic section (CS), delete behavior sections (BS) that were used during the preperation for setting v_entry, v_peak and v_exit CS[:behaviorSections] = Dict() - CS[:E] = 0.0 CS[:t] = 0.0 end #for return movingSection end #function secureAcceleratingBehavior! - - -#= -## define the intersection velocities between the characterisitc sections to secure cruising behavior -function secureCruisingBehavior!(movingSection::Dict, settings::Settings, train::Train) - # limit the exit velocity of the characteristic sections in case that the train cruises in every section at v_peak - CSs = movingSection[:characteristicSections] - - startingPoint = createDataPoint() - startingPoint[:i] = 1 - - previousCSv_exit = CSs[1][:v_entry] - - for CS in CSs - # conditions for entering the cruising phase - stateFlags = Dict(:endOfCSReached => false, - :brakingStartReached => false, - :tractionDeficit => false, - :resistingForceNegative => false, - :previousSpeedLimitReached => false, - :speedLimitReached => false, - :error => false, - :usedForDefiningCharacteristics => true) - - CS[:v_entry] = min(CS[:v_entry], previousCSv_exit) - - startingPoint[:s] = CS[:s_entry] - startingPoint[:v] = CS[:v_peak] - cruisingCourse::Vector{Dict} = [startingPoint] # List of data points - - while !stateFlags[:endOfCSReached] #&& s_cruising > 0.0 - if !stateFlags[:tractionDeficit] - s_cruising = CS[:s_exit] - cruisingCourse[end][:s] - if !stateFlags[:resistingForceNegative]# cruisingCourse[end][:F_R] >= 0 - (CS, cruisingCourse, stateFlags) = addCruisingSection!(CS, cruisingCourse, stateFlags, s_cruising, settings, train, CSs, "cruising") # this function changes the cruisingCourse - else - (CS, cruisingCourse, stateFlags) = addCruisingSection!(CS, cruisingCourse, stateFlags, s_cruising, settings, train, CSs, "downhillBraking") - end - else - if settings.massModel == :mass_point || cruisingCourse[end][:s] > CS[:s_entry] + train.length - break - else - (CS, cruisingCourse, stateFlags) = addDiminishingSection!(CS, cruisingCourse, stateFlags, settings, train, CSs) # this function is needed in case the resisitng forces are higher than the maximum possible tractive effort - end - end - end - - CS[:v_exit] = min(CS[:v_exit], cruisingCourse[end][:v]) - - previousCSv_exit = CS[:v_exit] - - # reset the characteristic section (CS), delete behavior sections (BS) that were used during the preperation for setting v_entry, v_peak and v_exit - CS[:behaviorSections] = Dict() - CS[:E] = 0.0 - CS[:t] = 0.0 - end #for - - return movingSection -end #function secureCruisingBehavior! -=# diff --git a/src/constructors.jl b/src/constructors.jl index 116712f..65fef2d 100644 --- a/src/constructors.jl +++ b/src/constructors.jl @@ -643,7 +643,6 @@ function createMovingSection(path::Path, v_trainLimit::Real, s_trainLength::Real :s_entry => s_entry, # first position (in m) :s_exit => s_exit, # last position (in m) :t => 0.0, # total running time (in s) - :E => 0.0, # total energy consumption (in Ws) :characteristicSections => CSs) # list of containing characteristic sections return movingSection @@ -659,7 +658,6 @@ function createCharacteristicSection(id::Integer, s_entry::Real, section::Dict, :r_path => section[:f_Rp], # path resistance (in ‰) :behaviorSections => Dict(), # list of containing behavior sections :t => 0.0, # total running time (in s) - :E => 0.0, # total energy consumption (in Ws) :v_limit => v_limit, # speed limit (in m/s) # initializing :v_entry, :v_peak and :v_exit with :v_limit :v_peak => v_limit, # maximum reachable speed (in m/s) @@ -707,10 +705,6 @@ function createDataPoint() :v => 0.0, # velocity (in m/s) :Δv => 0.0, # step size (in m/s) :a => 0.0, # acceleration (in m/s^2) - :W => 0.0, # mechanical work (in Ws) - :ΔW => 0.0, # mechanical work in this step (in Ws) - :E => 0.0, # energy consumption (in Ws) - :ΔE => 0.0, # energy consumption in this step (in Ws) :F_T => 0.0, # tractive effort (in N) :F_R => 0.0, # resisting force (in N) :R_path => 0.0, # path resistance (in N) @@ -732,7 +726,6 @@ function createBehaviorSection(type::String, s_entry::Real, v_entry::Real, start :s_entry => s_entry, # first position (in m) :s_exit => 0.0, # last position (in m) :t => 0.0, # total running time (in s) - :E => 0.0, # total energy consumption (in Ws) :v_entry => v_entry, # entry speed (in m/s) :v_exit => 0.0, # exit speed (in m/s) :dataPoints => [startingPoint] # list of identifiers of the containing data points starting with the initial point diff --git a/src/formulary.jl b/src/formulary.jl index 93161a4..f0df586 100644 --- a/src/formulary.jl +++ b/src/formulary.jl @@ -189,23 +189,6 @@ function calc_Δv_with_Δt(Δt::Real, a_prev::Real) return Δv end #function calc_Δv_with_Δt -function calc_ΔW(F_T_prev::Real, Δs::Real) - # equation is based on [Wende:2003, page 17] - - # F_T_prev: tractive force from previous data point - # Δs: distance step - ΔW = F_T_prev * Δs # mechanical work in this step (in Ws) - return ΔW -end #function calc_ΔW - -function calc_ΔE(ΔW::Real) - # simplified equation - # TODO! - # ΔW: mechanical work in this step (in Ws) - ΔE = ΔW # energy consumption in this step (in Ws) - return ΔE -end #function calc_ΔW - function calcBrakingDistance(v_start::Real, v_end::Real, a_braking::Real, approxLevel::Integer) # equation is based on [Wende:2003, page 37]