From acf8cd0c3b1a72eda63fa05d55791a1085b1dd18 Mon Sep 17 00:00:00 2001 From: Max Kannenberg <95709892+MaxKannenberg@users.noreply.github.com> Date: Wed, 13 Jul 2022 00:15:57 +0200 Subject: [PATCH] Remove the Dictionary for the behavior sections --- src/behavior.jl | 221 ++++++++++---------------------------------- src/constructors.jl | 39 ++------ 2 files changed, 59 insertions(+), 201 deletions(-) diff --git a/src/behavior.jl b/src/behavior.jl index f64d817..4649260 100644 --- a/src/behavior.jl +++ b/src/behavior.jl @@ -13,8 +13,9 @@ function addBreakFreeSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags: trainIsHalting = drivingCourse[end][:v] == 0.0 if trainIsHalting && !endOfCSReached - BS = BehaviorSection("breakFree", drivingCourse[end][:s], drivingCourse[end][:v], drivingCourse[end][:i]) - drivingCourse[end][:behavior] = BS[:type] + drivingMode = "breakFree" + drivingCourse[end][:behavior] = drivingMode + startingPoint = drivingCourse[end][:i] # traction effort and resisting forces (in N) calculateForces!(drivingCourse[end], CSs, CS[:id], "accelerating", train, settings.massModel) # currently the tractive effort is calculated like in the accelerating section @@ -27,28 +28,13 @@ function addBreakFreeSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags: end # delete every supportPoint except the first two - while drivingCourse[end][:i] > drivingCourse[BS[:supportPoints][1]][:i] +1 + while drivingCourse[end][:i] > startingPoint +1 pop!(drivingCourse) end # change the accelerating data to break free - drivingCourse[end-1][:behavior] = BS[:type] - drivingCourse[end][:behavior] = BS[:type] - push!(BS[:supportPoints], drivingCourse[end][:i]) - - # 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) - 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[:supportPoints][1]][:t], # total running time (in s) - :v_exit => drivingCourse[end][:v])) # exit speed (in m/s))) - - CS[:t] = CS[:t] + BS[:t] # total running time (in s) - - merge!(CS[:behaviorSections], Dict(:breakFree => BS)) + drivingCourse[end-1][:behavior] = drivingMode + drivingCourse[end][:behavior] = drivingMode end # else: return the characteristic section without a breakFree section # determine state flags @@ -107,7 +93,7 @@ end #function addClearingSection ## This function calculates the support points of the accelerating section. # Therefore it gets its previous driving course and the characteristic section and returns the characteristic section and driving course including the accelerating section function addAcceleratingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags::Dict, settings::Settings, train::Train, CSs::Vector{Dict}) -#= TODO: instead of CS just give csId? + #= TODO: instead of CS just give csId? -> CS = CSs[csId] =# calculateForces!(drivingCourse[end], CSs, CS[:id], "accelerating", train, settings.massModel) @@ -129,8 +115,8 @@ function addAcceleratingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFla # use the conditions for the accelerating section if !targetSpeedReached && !endOfCSReached && tractionSurplus && !brakingStartReached - BS = BehaviorSection("accelerating", drivingCourse[end][:s], drivingCourse[end][:v], drivingCourse[end][:i]) - drivingCourse[end][:behavior] = BS[:type] + drivingMode = "accelerating" + drivingCourse[end][:behavior] = drivingMode currentSpeedLimit = getCurrentSpeedLimit(CSs, CS[:id], drivingCourse[end][:s], train.length) previousSpeedLimitReached = currentSpeedLimit[:v] != CS[:v_limit] && drivingCourse[end][:v] >= currentSpeedLimit[:v] @@ -159,10 +145,9 @@ function addAcceleratingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFla # create the next support point push!(drivingCourse, moveAStep(drivingCourse[end], settings.stepVariable, currentStepSize, CS[:id])) - drivingCourse[end][:behavior] = BS[:type] - push!(BS[:supportPoints], drivingCourse[end][:i]) + drivingCourse[end][:behavior] = drivingMode - calculateForces!(drivingCourse[end], CSs, CS[:id], BS[:type], train, settings.massModel) + calculateForces!(drivingCourse[end], CSs, CS[:id], drivingMode, train, settings.massModel) # conditions for the next while cycle if !ignoreBraking @@ -249,7 +234,6 @@ function addAcceleratingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFla end # delete last support point for recalculating the last step with reduced step size pop!(drivingCourse) - pop!(BS[:supportPoints]) # conditions for the next for cycle brakingStartReached = false @@ -264,7 +248,6 @@ function addAcceleratingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFla if drivingCourse[end][:v] > CS[:v_peak] testFlag && println("in CS",CS[:id]," accelerating cycle",cycle," case: v=", drivingCourse[end][:v]," > v_peak=",CS[:v_peak]) # for testing pop!(drivingCourse) - pop!(BS[:supportPoints]) # conditions for the next section brakingStartReached = false @@ -273,7 +256,6 @@ function addAcceleratingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFla testFlag && println("in CS",CS[:id]," accelerating cycle",cycle," case: s +s_braking=", drivingCourse[end][:s],",+",s_braking," = ",drivingCourse[end][:s] +s_braking," > s_exit=",CS[:s_exit]) # for testing if s_braking > 0.0 pop!(drivingCourse) - pop!(BS[:supportPoints]) else drivingCourse[end][:s] = CS[:s_exit] # round s down to CS[:s_exit] @@ -291,7 +273,6 @@ function addAcceleratingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFla previousSpeedLimitReached = true pop!(drivingCourse) - pop!(BS[:supportPoints]) else if drivingCourse[end][:s] + s_braking == CS[:s_exit] @@ -318,19 +299,6 @@ function addAcceleratingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFla end end #while - - if length(BS[:supportPoints]) > 1 - # calculate the accumulated accelerating 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[:supportPoints][1]][:t], # total running time (in s) - :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 support 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) - - mergeBehaviorSection!(CS[:behaviorSections], BS) - end end # set state flags @@ -353,7 +321,7 @@ function addCruisingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: trainIsBrakingDownhill = cruisingType == "downhillBraking" # traction effort and resisting forces (in N) - if !trainIsBrakingDownhill # TODO: or just give BS[:type] instead of "cruising"/"braking"? + if !trainIsBrakingDownhill # TODO: or just give drivingMode instead of "cruising"/"braking"? calculateForces!(drivingCourse[end], CSs, CS[:id], "cruising", train, settings.massModel) else calculateForces!(drivingCourse[end], CSs, CS[:id], "braking", train, settings.massModel) @@ -374,17 +342,16 @@ function addCruisingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: tractionDeficit = drivingCourse[end][:F_T] < drivingCourse[end][:F_R] targetPositionReached = s_cruising == 0.0 resistingForceNegative = drivingCourse[end][:F_R] < 0 -#println(" vor if speedIsValid=",speedIsValid ," brakingStartReached=", brakingStartReached," tractionDeficit=", tractionDeficit," targetPositionReached=", targetPositionReached) if speedIsValid && !brakingStartReached && !tractionDeficit && !targetPositionReached # 03/04 old: if drivingCourse[end][:v]>0.0 && drivingCourse[end][:v]<=CS[:v_peak] && !brakingStartReached && drivingCourse[end][:F_T] >= drivingCourse[end][:F_R] - BS = BehaviorSection(cruisingType, drivingCourse[end][:s], drivingCourse[end][:v], drivingCourse[end][:i]) - drivingCourse[end][:behavior] = BS[:type] + drivingMode = cruisingType + drivingCourse[end][:behavior] = drivingMode # TODO: necessary? - s_cruising = min(s_cruising, CS[:s_exit]-BS[:s_entry]) + targetPosition = min(drivingCourse[end][:s] + s_cruising, CS[:s_exit]) + # 07/12 old: s_cruising = min(s_cruising, CS[:s_exit]-drivingCourse[end][:s]) # traction effort and resisting forces (in N) -#03/25 calculateForces!(drivingCourse[end], CSs, CS[:id], "cruising", train, settings.massModel) if !trainIsBrakingDownhill calculateForces!(drivingCourse[end], CSs, CS[:id], "cruising", train, settings.massModel) else @@ -394,7 +361,7 @@ function addCruisingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: if settings.massModel == :homogeneous_strip && CS[:id] > 1 # conditions for cruising section trainInPreviousCS = drivingCourse[end][:s] < CS[:s_entry] + train.length - targetPositionReached = drivingCourse[end][:s] >= BS[:s_entry] +s_cruising + targetPositionReached = drivingCourse[end][:s] >= targetPosition resistingForceNegative = drivingCourse[end][:F_R] < 0.0 # targetSpeedReached = stateFlags[:speedLimitReached] || drivingCourse[end][:v] >= CS[:v_peak] # TODO: change? to correctCruisingType = (trainIsClearing || (trainIsBrakingDownhill == drivingCourse[end][:F_R] < 0)) # while clearing tractive or braking force can be used @@ -407,11 +374,9 @@ function addCruisingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: for cycle in 1:settings.approxLevel+1 # first cycle with normal step size followed by cycles with reduced step size depending on the level of approximation while trainInPreviousCS && !targetPositionReached && !pointOfInterestReached && !tractionDeficit && (trainIsClearing || (trainIsBrakingDownhill == resistingForceNegative)) # while clearing tractive or braking force can be used - # 03/09 old: while drivingCourse[end][:s] < CS[:s_entry] + train.length && drivingCourse[end][:s] < BS[:s_entry] +s_cruising && drivingCourse[end][:s] < nextPointOfInterest[1] && drivingCourse[end][:F_T]>=drivingCourse[end][:F_R] # the tractive effort is lower than the resisiting forces and the train has use the highest possible effort to try to stay at v_peak OR the mass model homogeneous strip is used and parts of the train are still in former CS #TODO: maybe just consider former CS with different path resistance? # tractive effort (in N): -#03/25 drivingCourse[end][:F_T] = min(drivingCourse[end][:F_T], max(0.0, drivingCourse[end][:F_R])) if !trainIsBrakingDownhill drivingCourse[end][:F_T] = min(drivingCourse[end][:F_T], max(0.0, drivingCourse[end][:F_R])) else @@ -428,8 +393,7 @@ function addCruisingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: else push!(drivingCourse, moveAStep(drivingCourse[end], position, train.length/(10.0^cycle), CS[:id])) # TODO which step size should be used? end - drivingCourse[end][:behavior] = BS[:type] - push!(BS[:supportPoints], drivingCourse[end][:i]) + drivingCourse[end][:behavior] = drivingMode # traction effort and resisting forces (in N) calculateForces!(drivingCourse[end], CSs, CS[:id], "default", train, settings.massModel) @@ -443,7 +407,7 @@ function addCruisingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: # conditions for the next while cycle pointOfInterestReached = drivingCourse[end][:s] >= nextPointOfInterest[1] # POIs include s_exit as well tractionDeficit = drivingCourse[end][:F_T] < drivingCourse[end][:F_R] - targetPositionReached = drivingCourse[end][:s] >= BS[:s_entry] +s_cruising + targetPositionReached = drivingCourse[end][:s] >= targetPosition trainInPreviousCS = drivingCourse[end][:s] < CS[:s_entry] + train.length resistingForceNegative = drivingCourse[end][:F_R] < 0.0 end #while @@ -466,14 +430,14 @@ function addCruisingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: currentStepSize = settings.stepSize / 10.0^cycle end - elseif drivingCourse[end][:s] > BS[:s_entry] + s_cruising # TODO also the following? drivingCourse[end][:s] > CSs[CS[:id]][:s_entry] + train.length)) + elseif drivingCourse[end][:s] > targetPosition # TODO also the following? drivingCourse[end][:s] > CSs[CS[:id]][:s_entry] + train.length)) if settings.stepVariable == :distance - currentStepSize=BS[:s_entry] + s_cruising-drivingCourse[end-1][:s] + currentStepSize = targetPosition - drivingCourse[end-1][:s] else currentStepSize = settings.stepSize / 10.0^cycle end - elseif drivingCourse[end][:s] == BS[:s_entry] + s_cruising # || drivingCourse[end][:s]==CS[:s_exit] + elseif drivingCourse[end][:s] == targetPosition # || drivingCourse[end][:s]==CS[:s_exit] break elseif drivingCourse[end][:s] >= CS[:s_entry] + train.length @@ -491,7 +455,6 @@ function addCruisingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: # delete last support point for recalculating the last step with reduced step size pop!(drivingCourse) - pop!(BS[:supportPoints]) # conditions for the next for cycle pointOfInterestReached = false @@ -503,12 +466,11 @@ function addCruisingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: else # if the level of approximation is reached if drivingCourse[end][:s] > nextPointOfInterest[1] drivingCourse[end][:s] = nextPointOfInterest[1] # round s down to nextPointOfInterest - elseif drivingCourse[end][:s] > BS[:s_entry]+s_cruising - if BS[:type] != "clearing" + elseif drivingCourse[end][:s] > targetPosition + if drivingMode != "clearing" pop!(drivingCourse) - pop!(BS[:supportPoints]) end - elseif drivingCourse[end][:s] == BS[:s_entry]+s_cruising + elseif drivingCourse[end][:s] == targetPosition break elseif drivingCourse[end][:F_T] < drivingCourse[end][:F_R] break @@ -533,15 +495,15 @@ function addCruisingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: end #if # conditions for the next while cycle - targetPositionReached = drivingCourse[end][:s] >= BS[:s_entry] +s_cruising + targetPositionReached = drivingCourse[end][:s] >= targetPosition tractionDeficit = drivingCourse[end][:F_T] < drivingCourse[end][:F_R] resistingForceNegative = drivingCourse[end][:F_R] < 0.0 while !targetPositionReached && !tractionDeficit && (trainIsClearing || (trainIsBrakingDownhill == resistingForceNegative)) # while clearing tractive or braking force can be used - # 03/09 old: while drivingCourse[end][:s] < BS[:s_entry]+s_cruising && drivingCourse[end][:F_T] >= drivingCourse[end][:F_R] + # 03/09 old: while drivingCourse[end][:s] < targetPosition && drivingCourse[end][:F_T] >= drivingCourse[end][:F_R] nextPointOfInterest = getNextPointOfInterest(CS[:pointsOfInterest], drivingCourse[end][:s]) - if nextPointOfInterest[1] > BS[:s_entry]+s_cruising - nextPointOfInterest = [BS[:s_entry]+s_cruising, ""] + if nextPointOfInterest[1] > targetPosition + nextPointOfInterest = [targetPosition, ""] end # tractive effort (in N): @@ -557,16 +519,15 @@ function addCruisingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: drivingCourse[end][:a] = 0.0 # acceleration (in m/s^2) # calculate the remaining cruising way - #s_cruisingRemaining=BS[:s_entry] + s_cruising-drivingCourse[end][:s] - s_cruisingRemaining = min(nextPointOfInterest[1] -drivingCourse[end][:s], BS[:s_entry] +s_cruising -drivingCourse[end][:s]) + #s_cruisingRemaining=targetPosition-drivingCourse[end][:s] + s_cruisingRemaining = min(nextPointOfInterest[1] -drivingCourse[end][:s], targetPosition -drivingCourse[end][:s]) # create the next support point push!(drivingCourse, moveAStep(drivingCourse[end], :distance, s_cruisingRemaining, CS[:id])) - drivingCourse[end][:behavior] = BS[:type] + drivingCourse[end][:behavior] = drivingMode if drivingCourse[end][:s] == nextPointOfInterest[1] drivingCourse[end][:label] = nextPointOfInterest[2] end - push!(BS[:supportPoints], drivingCourse[end][:i]) calculateForces!(drivingCourse[end], CSs, CS[:id], "default", train, settings.massModel) # calculateForces!(drivingCourse[end], CSs, CS[:id], "cruising", train, settings.massModel) @@ -577,23 +538,11 @@ function addCruisingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: #end # conditions for the next while cycle - targetPositionReached = drivingCourse[end][:s] >= BS[:s_entry] +s_cruising + targetPositionReached = drivingCourse[end][:s] >= targetPosition tractionDeficit = drivingCourse[end][:F_T] < drivingCourse[end][:F_R] resistingForceNegative = drivingCourse[end][:F_R] < 0 end #while - # TODO: realize this better inside the upper loops? - - - # calculate the accumulated cruising 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[:supportPoints][1]][:t], # total running time (in s) - :v_exit => drivingCourse[end][:v])) # exit speed (in m/s))) - - CS[:t] = CS[:t] + BS[:t] # total running time (in s) - - mergeBehaviorSection!(CS[:behaviorSections], BS) end # else: return the characteristic section without a cruising section # set state flags @@ -633,8 +582,8 @@ function addDiminishingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlag # use the conditions for the diminishing section if tractionDeficit && !targetSpeedReached && !endOfCSReached - BS = BehaviorSection("diminishing", drivingCourse[end][:s], drivingCourse[end][:v], drivingCourse[end][:i]) - drivingCourse[end][:behavior] = BS[:type] + drivingMode = "diminishing" + drivingCourse[end][:behavior] = drivingMode while tractionDeficit && !targetSpeedReached && !endOfCSReached && !brakingStartReached currentStepSize=settings.stepSize # initialize the step size that can be reduced near intersections @@ -649,10 +598,9 @@ function addDiminishingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlag # create the next support point push!(drivingCourse, moveAStep(drivingCourse[end], settings.stepVariable, currentStepSize, CS[:id])) - drivingCourse[end][:behavior] = BS[:type] - push!(BS[:supportPoints], drivingCourse[end][:i]) + drivingCourse[end][:behavior] = drivingMode - calculateForces!(drivingCourse[end], CSs, CS[:id], BS[:type], train, settings.massModel) + calculateForces!(drivingCourse[end], CSs, CS[:id], drivingMode, train, settings.massModel) # conditions for the next while cycle if !ignoreBraking @@ -717,7 +665,6 @@ function addDiminishingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlag end # delete last support point for recalculating the last step with reduced step size pop!(drivingCourse) - pop!(BS[:supportPoints]) # conditions for the next for cycle brakingStartReached = false @@ -729,7 +676,6 @@ function addDiminishingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlag else # if the level of approximation is reached if drivingCourse[end][:v] <= 0.0 testFlag && println("in CS",CS[:id]," diminishing cycle",cycle," case: v=", drivingCourse[end][:v]," <= 0.0") # for testing - # push!(BS[:supportPoints], drivingCourse[end][:i]) error("ERROR: The train stops during diminishing run in CS",CS[:id]," because the maximum tractive effort is lower than the resistant forces.", " Before the stop the last point has the values s=",drivingCourse[end-1][:s]," m v=",drivingCourse[end-1][:v]," m/s a=",drivingCourse[end-1][:a]," m/s^2", " F_T=",drivingCourse[end-1][:F_T]," N R_traction=",drivingCourse[end-1][:R_traction]," N R_wagons=",drivingCourse[end-1][:R_wagons]," N R_path=",drivingCourse[end-1][:R_path]," N.") @@ -737,7 +683,6 @@ function addDiminishingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlag elseif s_braking > 0.0 && drivingCourse[end][:s] + s_braking > CS[:s_exit] testFlag && println("in CS",CS[:id]," diminishing cycle",cycle," case: s +s_braking=", drivingCourse[end][:s],"+",s_braking," = ",drivingCourse[end][:s] +s_braking," > s_exit=",CS[:s_exit]) # for testing pop!(drivingCourse) - pop!(BS[:supportPoints]) pointOfInterestReached = false targetSpeedReached = false @@ -773,18 +718,6 @@ function addDiminishingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlag drivingCourse[end][:label] = nextPointOfInterest[2] end end #while - - if length(BS[:supportPoints]) > 1 # TODO: necessary? May it be possible that there is no diminishing because braking has to start? - # calculate the accumulated diminishing 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[:supportPoints][1]][:t], # total running time (in s) - :v_exit => drivingCourse[end][:v])) # exit speed (in m/s))) - - CS[:t] = CS[:t] + BS[:t] # total running time (in s) - - mergeBehaviorSection!(CS[:behaviorSections], BS) - end end # set state flags @@ -814,8 +747,8 @@ function addCoastingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: # use the conditions for the coasting section if !targetSpeedReached && !endOfCSReached - BS = BehaviorSection("coasting", drivingCourse[end][:s], drivingCourse[end][:v], drivingCourse[end][:i]) - drivingCourse[end][:behavior] = BS[:type] + drivingMode = "coasting" + drivingCourse[end][:behavior] = drivingMode while !targetSpeedReached && !endOfCSReached && !brakingStartReached currentStepSize=settings.stepSize # initialize the step size that can be reduced near intersections @@ -826,15 +759,14 @@ function addCoastingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: while !targetSpeedReached && !brakingStartReached && !pointOfInterestReached # 03/09 old : while drivingCourse[end][:v] > CS[:v_exit] && drivingCourse[end][:v] <= CS[:v_peak] && !brakingStartReached && drivingCourse[end][:s] < nextPointOfInterest[1] # traction effort and resisting forces (in N): - calculateForces!(drivingCourse[end], CSs, CS[:id], BS[:type], train, settings.massModel) + calculateForces!(drivingCourse[end], CSs, CS[:id], drivingMode, train, settings.massModel) # acceleration (in m/s^2): drivingCourse[end][:a] = acceleration(drivingCourse[end][:F_T], drivingCourse[end][:F_R], train.m_train_full, train.ξ_train) # create the next support point push!(drivingCourse, moveAStep(drivingCourse[end], settings.stepVariable, currentStepSize, CS[:id])) - drivingCourse[end][:behavior] = BS[:type] - push!(BS[:supportPoints], drivingCourse[end][:i]) + drivingCourse[end][:behavior] = drivingMode # conditions for the next while cycle s_braking = brakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) @@ -892,7 +824,6 @@ function addCoastingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: end # delete last support point for recalculating the last step with reduced step size pop!(drivingCourse) - pop!(BS[:supportPoints]) # conditions for the next for cycle brakingStartReached = false @@ -909,7 +840,6 @@ function addCoastingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: elseif drivingCourse[end][:s] + s_braking > CS[:s_exit] # delete last support point because it went to far pop!(drivingCourse) - pop!(BS[:supportPoints]) # conditions for the next for cycle # brakingStartReached = true @@ -919,7 +849,6 @@ function addCoastingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: elseif drivingCourse[end][:v] > CS[:v_peak] # if the train gets to fast it has to brake # TODO: if accelereation and coasting functions will be combined this case is different for coasting and also the order of if cases is different # delete last support point because it went to far pop!(drivingCourse) - pop!(BS[:supportPoints]) # conditions for the next for cycle brakingStartReached = false @@ -941,16 +870,6 @@ function addCoastingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: end #while stateFlags[:speedLimitReached] = false - - # calculate the accumulated coasting 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[:supportPoints][1]][:t], # total running time (in s) - :v_exit => drivingCourse[end][:v])) # exit speed (in m/s))) - - CS[:t] = CS[:t] + BS[:t] # total running time (in s) - - merge!(CS[:behaviorSections], Dict(:coasting=>BS)) end # set state flags @@ -973,8 +892,8 @@ function addBrakingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags::D # use the conditions for the braking section if !targetSpeedReached && !endOfCSReached - BS = BehaviorSection("braking", drivingCourse[end][:s], drivingCourse[end][:v], drivingCourse[end][:i]) - drivingCourse[end][:behavior] = BS[:type] + drivingMode = "braking" + drivingCourse[end][:behavior] = drivingMode while !targetSpeedReached && !endOfCSReached currentStepSize = settings.stepSize # initialize the step size that can be reduced near intersections @@ -985,7 +904,7 @@ function addBrakingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags::D while !targetSpeedReached && !endOfCSReached && !pointOfInterestReached # 03/09 old: while drivingCourse[end][:v] > CS[:v_exit] && !targetSpeedReached && drivingCourse[end][:s] < CS[:s_exit] && drivingCourse[end][:s] < nextPointOfInterest[1] # traction effort and resisting forces (in N): - calculateForces!(drivingCourse[end], CSs, CS[:id], BS[:type], train, settings.massModel) + calculateForces!(drivingCourse[end], CSs, CS[:id], drivingMode, train, settings.massModel) # acceleration (in m/s^2): drivingCourse[end][:a] = train.a_braking @@ -995,14 +914,12 @@ function addBrakingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags::D # create empty support point and set it for the values of s_exit and v_exit push!(drivingCourse, SupportPoint()) drivingCourse[end][:i] = drivingCourse[end-1][:i]+1 - drivingCourse[end][:behavior] = BS[:type] - push!(BS[:supportPoints], drivingCourse[end][:i]) + drivingCourse[end][:behavior] = drivingMode recalculateLastBrakingPoint!(drivingCourse, CS[:s_exit], CS[:v_exit]) else # create the next support point push!(drivingCourse, moveAStep(drivingCourse[end], settings.stepVariable, currentStepSize, CS[:id])) - drivingCourse[end][:behavior] = BS[:type] - push!(BS[:supportPoints], drivingCourse[end][:i]) + drivingCourse[end][:behavior] = drivingMode end #println(drivingCourse[end][:i],". s=",drivingCourse[end][:s]," s_exit=", CS[:s_exit]," v_exit=", CS[:v_exit]," v=",drivingCourse[end][:v]) @@ -1046,7 +963,6 @@ function addBrakingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags::D # delete last support point for recalculating the last step with reduced step size pop!(drivingCourse) - pop!(BS[:supportPoints]) # conditions for the next for cycle pointOfInterestReached = false @@ -1098,16 +1014,6 @@ function addBrakingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags::D end end #while - - # calculate the accumulated coasting 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[:supportPoints][1]][:t], # total running time (in s) - :v_exit => drivingCourse[end][:v])) # exit speed (in m/s))) - - CS[:t] = CS[:t] + BS[:t] # total running time (in s) - - merge!(CS[:behaviorSections], Dict(:braking=>BS)) end # else: return the characteristic section without a braking section # set state flags @@ -1127,35 +1033,15 @@ end #function addBrakingSection! # Therefore it gets its first support point and the characteristic section and returns the characteristic section including the halt if needed. function addHalt!(CS::Dict, drivingCourse::Vector{Dict}, settings::Settings, train::Train, CSs::Vector{Dict}) if drivingCourse[end][:v] == 0.0 - BS = BehaviorSection("standstill", 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) - :s_exit => drivingCourse[end][:s], # last position (in m) - :v_exit => drivingCourse[end][:v])) # exit speed (in m/s))) - drivingCourse[end][:behavior] = BS[:type] + drivingMode = "halt" + drivingCourse[end][:behavior] = drivingMode # traction effort and resisting forces (in N) - calculateForces!(drivingCourse[end], CSs, CS[:id], BS[:type], train, settings.massModel) - - merge!(CS[:behaviorSections], Dict(:halt => BS)) + calculateForces!(drivingCourse[end], CSs, CS[:id], drivingMode, train, settings.massModel) end # else: return the characteristic section without a halt section section return (CS, drivingCourse) end #function addHalt! -function mergeBehaviorSection!(BSs::Dict, BS::Dict) - if !haskey(BSs, Symbol(BS[:type])) - merge!(BSs, Dict(Symbol(BS[:type]) => BS)) - else - number = "2" - while haskey(BSs, Symbol(BS[:type]*number)) - number = string(parse(Int, number)+1) - end - merge!(BSs, Dict(Symbol(BS[:type]*number) => BS)) - # println("INFO: The ",number,". ",BS[:type]," section has been created. ! ! ! ! ! ! ! ! !") - end - return BSs -end #function mergeBehaviorSection! - function recalculateLastBrakingPoint!(drivingCourse, s_target, v_target) currentPoint = drivingCourse[end] previousPoint = drivingCourse[end-1] @@ -1188,11 +1074,6 @@ function secureBrakingBehavior!(CSs::Vector{Dict}, a_braking::Real, approxLevel: CS[:v_entry] = min(CS[:v_limit], v_entryMax) CS[:v_peak] = CS[:v_entry] - - # 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[:t] = 0.0 - followingCSv_entry = CS[:v_entry] csId = csId - 1 end #while @@ -1253,10 +1134,6 @@ function secureAcceleratingBehavior!(CSs::Vector{Dict}, settings::Settings, trai end #if 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[:t] = 0.0 end #for return CSs diff --git a/src/constructors.jl b/src/constructors.jl index 2b89c4d..7d93711 100644 --- a/src/constructors.jl +++ b/src/constructors.jl @@ -639,18 +639,16 @@ end #function CharacteristicSections ## create a characteristic section for a path section. A characteristic section is a part of the moving section. It contains behavior sections. function CharacteristicSection(id::Integer, s_entry::Real, section::Dict, v_limit::Real, s_trainLength::Real, MS_poi::Vector{Tuple}) # Create and return a characteristic section dependent on the paths attributes - characteristicSection= Dict(:id => id, # identifier - :s_entry => s_entry, # first position (in m) - :s_exit => section[:s_end], # last position (in m) - :length => section[:s_end] -s_entry, # total length (in m) - :r_path => section[:f_Rp], # path resistance (in ‰) - :behaviorSections => Dict(), # list of containing behavior sections - :t => 0.0, # total running time (in s) - :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) - :v_entry => v_limit, # maximum entry speed (in m/s) - :v_exit => v_limit) # maximum exit speed (in m/s) + characteristicSection::Dict{Symbol, Any} = Dict(:id => id, # identifier + :s_entry => s_entry, # first position (in m) + :s_exit => section[:s_end], # last position (in m) + :length => section[:s_end] -s_entry, # total length (in m) + :r_path => section[:f_Rp], # path resistance (in ‰) + :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) + :v_entry => v_limit, # maximum entry speed (in m/s) + :v_exit => v_limit) # maximum exit speed (in m/s) # list of positions of every point of interest (POI) in this charateristic section for which support points should be calculated s_exit = characteristicSection[:s_exit] @@ -673,23 +671,6 @@ function CharacteristicSection(id::Integer, s_entry::Real, section::Dict, v_limi return characteristicSection end #function CharacteristicSection -""" -BehaviorSection() TODO! -""" -function BehaviorSection(type::String, s_entry::Real, v_entry::Real, startingPoint::Integer) - BS= Dict( - :type => type, # type of behavior section: "breakFree", "clearing", "accelerating", "cruising", "downhillBraking", "diminishing", "coasting", "braking" or "standstill" - :length => 0.0, # total length (in m) - :s_entry => s_entry, # first position (in m) - :s_exit => 0.0, # last position (in m) - :t => 0.0, # total running time (in s) - :v_entry => v_entry, # entry speed (in m/s) - :v_exit => 0.0, # exit speed (in m/s) - :supportPoints => [startingPoint] # list of identifiers of the containing support points starting with the initial point - ) - return BS -end #function BehaviorSection - """ a SupportPoint is the smallest element of the driving course. One step of the step approach is between two support points """