diff --git a/src/behavior.jl b/src/behavior.jl index 97f238e..eadaa8c 100644 --- a/src/behavior.jl +++ b/src/behavior.jl @@ -56,7 +56,7 @@ function addBreakFreeSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags: if haskey(stateFlags, :usedForDefiningCharacteristics) && stateFlags[:usedForDefiningCharacteristics] s_braking = 0.0 else - s_braking = calcBrakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) + s_braking = brakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) end # reset state flags @@ -82,7 +82,7 @@ function addClearingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: s_braking = 0.0 else ignoreBraking = false - s_braking = calcBrakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) + s_braking = brakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) end s_clearing = min(CS[:s_exit]-drivingCourse[end][:s]-s_braking, currentSpeedLimit[:s_end] - drivingCourse[end][:s]) @@ -120,7 +120,7 @@ function addAcceleratingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFla s_braking = 0.0 else ignoreBraking = false - s_braking = calcBrakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) + s_braking = brakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) end # conditions for the accelerating section @@ -147,7 +147,7 @@ function addAcceleratingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFla 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 if !ignoreBraking - s_braking = calcBrakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) + s_braking = brakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) end while !targetSpeedReached && !speedLimitReached && !brakingStartReached && !pointOfInterestReached && tractionSurplus && !previousSpeedLimitReached @@ -158,7 +158,7 @@ function addAcceleratingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFla end # acceleration (in m/s^2): - drivingCourse[end][:a] = calcAcceleration(drivingCourse[end][:F_T], drivingCourse[end][:F_R], train.m_train_full, train.ξ_train) + drivingCourse[end][:a] = acceleration(drivingCourse[end][:F_T], drivingCourse[end][:F_R], train.m_train_full, train.ξ_train) # create the next data point push!(drivingCourse, moveAStep(drivingCourse[end], settings.stepVariable, currentStepSize, CS[:id])) @@ -169,7 +169,7 @@ function addAcceleratingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFla # conditions for the next while cycle if !ignoreBraking - s_braking = calcBrakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) + s_braking = brakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) end brakingStartReached = drivingCourse[end][:s] +s_braking >= CS[:s_exit] speedLimitReached = drivingCourse[end][:v] > CS[:v_limit] @@ -369,11 +369,11 @@ function addCruisingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: s_braking = 0.0 else ignoreBraking = false - s_braking = calcBrakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) + s_braking = brakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) end # conditions for cruising section - #s_braking = calcBrakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) + #s_braking = brakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) brakingStartReached = drivingCourse[end][:s] + s_braking >= CS[:s_exit] || stateFlags[:brakingStartReached] speedIsValid = drivingCourse[end][:v]>0.0 && drivingCourse[end][:v]<=CS[:v_peak] tractionDeficit = drivingCourse[end][:F_T] < drivingCourse[end][:F_R] @@ -605,7 +605,7 @@ function addCruisingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: # set state flags stateFlags[:endOfCSReached] = drivingCourse[end][:s] == CS[:s_exit] if !ignoreBraking - s_braking = calcBrakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) + s_braking = brakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) end stateFlags[:brakingStartReached] = brakingStartReached || drivingCourse[end][:s] + s_braking >= CS[:s_exit] stateFlags[:tractionDeficit] = tractionDeficit @@ -627,14 +627,14 @@ function addDiminishingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlag s_braking = 0.0 else ignoreBraking = false - s_braking = calcBrakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) + s_braking = brakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) end # conditions for diminishing section targetSpeedReached = drivingCourse[end][:v] <= 0.0 endOfCSReached = drivingCourse[end][:s] >= CS[:s_exit] || stateFlags[:endOfCSReached] tractionDeficit = drivingCourse[end][:F_T] < drivingCourse[end][:F_R] #|| stateFlags[:tractionDeficit] - #s_braking = calcBrakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) + #s_braking = brakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) brakingStartReached = drivingCourse[end][:s] + s_braking >= CS[:s_exit] || stateFlags[:brakingStartReached] # use the conditions for the diminishing section @@ -651,7 +651,7 @@ function addDiminishingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlag while tractionDeficit && !brakingStartReached && !pointOfInterestReached && !targetSpeedReached # 03/09 old: while drivingCourse[end][:F_T] < drivingCourse[end][:F_R] && !brakingStartReached && drivingCourse[end][:s] < nextPointOfInterest[1] && drivingCourse[end][:v]>0.0 # as long as s_i + s_braking < s_end # acceleration (in m/s^2): - drivingCourse[end][:a] = calcAcceleration(drivingCourse[end][:F_T], drivingCourse[end][:F_R], train.m_train_full, train.ξ_train) + drivingCourse[end][:a] = acceleration(drivingCourse[end][:F_T], drivingCourse[end][:F_R], train.m_train_full, train.ξ_train) # create the next data point push!(drivingCourse, moveAStep(drivingCourse[end], settings.stepVariable, currentStepSize, CS[:id])) @@ -662,7 +662,7 @@ function addDiminishingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlag # conditions for the next while cycle if !ignoreBraking - s_braking = calcBrakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) + s_braking = brakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) end brakingStartReached = drivingCourse[end][:s] +s_braking >= CS[:s_exit] pointOfInterestReached = drivingCourse[end][:s] >= nextPointOfInterest[1] @@ -816,7 +816,7 @@ function addCoastingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: targetSpeedReached = drivingCourse[end][:v] <= CS[:v_exit] endOfCSReached = drivingCourse[end][:s] >= CS[:s_exit] || stateFlags[:endOfCSReached] - s_braking = calcBrakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) + s_braking = brakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) brakingStartReached = drivingCourse[end][:s] + s_braking >= CS[:s_exit] || stateFlags[:brakingStartReached] # use the conditions for the coasting section @@ -836,7 +836,7 @@ function addCoastingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: calculateForces!(drivingCourse[end], CSs, CS[:id], BS[:type], train, settings.massModel) # acceleration (in m/s^2): - drivingCourse[end][:a] = calcAcceleration(drivingCourse[end][:F_T], drivingCourse[end][:F_R], train.m_train_full, train.ξ_train) + drivingCourse[end][:a] = acceleration(drivingCourse[end][:F_T], drivingCourse[end][:F_R], train.m_train_full, train.ξ_train) # create the next data point push!(drivingCourse, moveAStep(drivingCourse[end], settings.stepVariable, currentStepSize, CS[:id])) @@ -844,7 +844,7 @@ function addCoastingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags:: push!(BS[:dataPoints], drivingCourse[end][:i]) # conditions for the next while cycle - s_braking = calcBrakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) + s_braking = brakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) brakingStartReached = drivingCourse[end][:s] + s_braking >= CS[:s_exit] pointOfInterestReached = drivingCourse[end][:s] >= nextPointOfInterest[1] targetSpeedReached = drivingCourse[end][:v] <= CS[:v_exit] || drivingCourse[end][:v] > CS[:v_peak] @@ -997,7 +997,7 @@ function addBrakingSection!(CS::Dict, drivingCourse::Vector{Dict}, stateFlags::D # acceleration (in m/s^2): drivingCourse[end][:a] = train.a_braking - # TODO or: drivingCourse[end][:a] = calcBrakingAcceleration(drivingCourse[end][:v], CS[:v_exit], CS[:s_exit]-drivingCourse[end][:s]) + # TODO or: drivingCourse[end][:a] = brakingAcceleration(drivingCourse[end][:v], CS[:v_exit], CS[:s_exit]-drivingCourse[end][:s]) if settings.stepVariable == :distance && ((drivingCourse[end][:v]/drivingCourse[end][:a])^2+2*currentStepSize/drivingCourse[end][:a])<0.0 || (drivingCourse[end][:v]^2+2*currentStepSize*drivingCourse[end][:a])<0.0 # create empty data point and set it for the values of s_exit and v_exit @@ -1175,12 +1175,12 @@ function recalculateLastBrakingPoint!(drivingCourse, s_target, v_target) currentPoint[:Δv] = currentPoint[:v] - previousPoint[:v] # step size (in m/s) # calculate other values - previousPoint[:a] = calcBrakingAcceleration(previousPoint[:v], currentPoint[:v], currentPoint[:Δs]) + previousPoint[:a] = brakingAcceleration(previousPoint[:v], currentPoint[:v], currentPoint[:Δs]) # # TODO: just for testing # if previousPoint[:a]=0.0 # println("Warning: a_braking gets to high in CS ",CS[:id], " with a=",previousPoint[:a] ," > ",train.a_braking) # end - currentPoint[:Δt] = calc_Δt_with_Δv(currentPoint[:Δv], previousPoint[:a]) # step size (in s) + currentPoint[:Δt] = Δt_with_Δv(currentPoint[:Δv], previousPoint[:a]) # step size (in s) currentPoint[:t] = previousPoint[:t] + currentPoint[:Δt] # point in time (in s) end #function recalculateLastBrakingPoint @@ -1196,7 +1196,7 @@ function secureBrakingBehavior!(movingSection::Dict, a_braking::Real, approxLeve CS[:v_exit] = min(CS[:v_limit], followingCSv_entry) - v_entryMax = calcBrakingStartVelocity(CS[:v_exit], a_braking, CS[:length], approxLevel) + v_entryMax = brakingStartVelocity(CS[:v_exit], a_braking, CS[:length], approxLevel) CS[:v_entry] = min(CS[:v_limit], v_entryMax) CS[:v_peak] = CS[:v_entry] diff --git a/src/calc.jl b/src/calc.jl index 15e8f1d..b37d8c1 100644 --- a/src/calc.jl +++ b/src/calc.jl @@ -31,7 +31,7 @@ function calculateMinimumRunningTime!(movingSection::Dict, settings::Settings, t end # determine the different flags for switching between the states for creatinge moving phases - s_braking = calcBrakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) + s_braking = brakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) calculateForces!(drivingCourse[end], CSs, CS[:id], "default", train, settings.massModel) # tractive effort and resisting forces (in N) previousSpeedLimitReached = false @@ -61,14 +61,14 @@ function calculateMinimumRunningTime!(movingSection::Dict, settings::Settings, t if settings.stepVariable == :distance s_cruising = settings.stepSize elseif settings.stepVariable == time - s_cruising = calc_Δs_with_Δt(settings.stepSize, drivingCourse[end][:a], drivingCourse[end][:v]) + s_cruising = Δs_with_Δt(settings.stepSize, drivingCourse[end][:a], drivingCourse[end][:v]) elseif settings.stepVariable == velocity s_cruising = train.length/(10.0) # TODO which step size should be used? end (CS, drivingCourse, stateFlags) = addCruisingSection!(CS, drivingCourse, stateFlags, s_cruising, settings, train, CSs, "cruising") elseif drivingCourse[end][:F_R] < 0 && stateFlags[:speedLimitReached] - s_braking = calcBrakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) + s_braking = brakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) s_cruising = CS[:s_exit] - drivingCourse[end][:s] - s_braking if s_cruising > 0.0 @@ -78,7 +78,7 @@ function calculateMinimumRunningTime!(movingSection::Dict, settings::Settings, t end elseif drivingCourse[end][:F_T] == drivingCourse[end][:F_R] || stateFlags[:speedLimitReached] - s_braking = calcBrakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) + s_braking = brakingDistance(drivingCourse[end][:v], CS[:v_exit], train.a_braking, settings.approxLevel) s_cruising = CS[:s_exit] - drivingCourse[end][:s] - s_braking if s_cruising > 0.0 # TODO: define a minimum cruising length? @@ -172,16 +172,16 @@ calculate and return the path resistance dependend on the trains position and ma function calculatePathResistance(CSs::Vector{Dict}, csId::Integer, s::Real, massModel, train::Train) if massModel == :mass_point - pathResistance = calcForceFromCoefficient(CSs[csId][:r_path], train.m_train_full) + pathResistance = forceFromCoefficient(CSs[csId][:r_path], train.m_train_full) elseif massModel == :homogeneous_strip pathResistance = 0.0 s_rear = s - train.length # position of the rear of the train while csId > 0 && s_rear < CSs[csId][:s_exit] - pathResistance = pathResistance + (min(s, CSs[csId][:s_exit]) - max(s_rear, CSs[csId][:s_entry])) / train.length * calcForceFromCoefficient(CSs[csId][:r_path], train.m_train_full) + pathResistance = pathResistance + (min(s, CSs[csId][:s_exit]) - max(s_rear, CSs[csId][:s_entry])) / train.length * forceFromCoefficient(CSs[csId][:r_path], train.m_train_full) csId = csId-1 if csId == 0 # TODO: currently for values < movingSection[:s_entry] the values of movingSection[:s_entry] will be used - return pathResistance + (CSs[1][:s_entry] - s_rear) / train.length * calcForceFromCoefficient(CSs[1][:r_path], train.m_train_full) + return pathResistance + (CSs[1][:s_entry] - s_rear) / train.length * forceFromCoefficient(CSs[1][:r_path], train.m_train_full) end #if end #while end #if @@ -195,11 +195,11 @@ calculate and return tractive and resisting forces for a data point """ function calculateForces!(dataPoint::Dict, CSs::Vector{Dict}, csId::Integer, bsType::String, train::Train, massModel) # calculate resisting forces - dataPoint[:R_traction] = calcTractionUnitResistance(dataPoint[:v], train) + dataPoint[:R_traction] = tractionUnitResistance(dataPoint[:v], train) if train.transportType == :freight - dataPoint[:R_wagons] = calcFreightWagonsResistance(dataPoint[:v], train) + dataPoint[:R_wagons] = freightWagonsResistance(dataPoint[:v], train) elseif train.transportType == :passenger - dataPoint[:R_wagons] = calcPassengerWagonsResistance(dataPoint[:v], train) + dataPoint[:R_wagons] = passengerWagonsResistance(dataPoint[:v], train) end dataPoint[:R_train] = dataPoint[:R_traction] + dataPoint[:R_wagons] dataPoint[:R_path] = calculatePathResistance(CSs, csId, dataPoint[:s], massModel, train) @@ -237,24 +237,24 @@ function moveAStep(previousPoint::Dict, stepVariable::Symbol, stepSize::Real, cs if previousPoint[:v] == 0.0 error("ERROR: The train tries to cruise at v=0.0 m/s at s=",previousPoint[:s]," in CS",csId,".") end - newPoint[:Δt] = calc_Δt_with_constant_v(newPoint[:Δs], previousPoint[:v]) # step size (in s) + newPoint[:Δt] = Δt_with_constant_v(newPoint[:Δs], previousPoint[:v]) # step size (in s) newPoint[:Δv] = 0.0 # step size (in m/s) else - # check if the parts of the following square roots will be <0.0 in the functions calc_Δt_with_Δs and calc_Δv_with_Δs + # check if the parts of the following square roots will be <0.0 in the functions Δt_with_Δs and Δv_with_Δs squareRootPartIsNegative = (previousPoint[:v]/previousPoint[:a])^2+2*newPoint[:Δs]/previousPoint[:a] < 0.0 || previousPoint[:v]^2+2*newPoint[:Δs]*previousPoint[:a] < 0.0 if previousPoint[:a] < 0.0 && squareRootPartIsNegative error("ERROR: The train stops during the accelerating section in CS",csId," because the tractive effort is lower than the resistant forces.", " Before the stop the last point has the values s=",previousPoint[:s]," m, v=",previousPoint[:v]," m/s, a=",previousPoint[:a]," m/s^2,", " F_T=",previousPoint[:F_T]," N, R_traction=",previousPoint[:R_traction]," N, R_wagons=",previousPoint[:R_wagons]," N, R_path=",previousPoint[:R_path]," N.") end - newPoint[:Δt] = calc_Δt_with_Δs(newPoint[:Δs], previousPoint[:a], previousPoint[:v]) # step size (in s) - newPoint[:Δv] = calc_Δv_with_Δs(newPoint[:Δs], previousPoint[:a], previousPoint[:v]) # step size (in m/s) + newPoint[:Δt] = Δt_with_Δs(newPoint[:Δs], previousPoint[:a], previousPoint[:v]) # step size (in s) + newPoint[:Δv] = Δv_with_Δs(newPoint[:Δs], previousPoint[:a], previousPoint[:v]) # step size (in m/s) end elseif stepVariable == :time # time step method newPoint[:Δt] = stepSize # step size (in s) - newPoint[:Δs] = calc_Δs_with_Δt(newPoint[:Δt], previousPoint[:a], previousPoint[:v]) # step size (in m) - newPoint[:Δv] = calc_Δv_with_Δt(newPoint[:Δt], previousPoint[:a]) # step size (in m/s) + newPoint[:Δs] = Δs_with_Δt(newPoint[:Δt], previousPoint[:a], previousPoint[:v]) # step size (in m) + newPoint[:Δv] = Δv_with_Δt(newPoint[:Δt], previousPoint[:a]) # step size (in m/s) elseif stepVariable == :velocity # velocity step method if previousPoint[:a] == 0.0 @@ -263,12 +263,12 @@ function moveAStep(previousPoint::Dict, stepVariable::Symbol, stepSize::Real, cs end newPoint[:Δs] = stepSize # step size (in m) # TODO what is the best default step size for constant v? define Δs or Δt? - newPoint[:Δt] = calc_Δt_with_constant_v(newPoint[:Δs], previousPoint[:v]) # step size (in s) + newPoint[:Δt] = Δt_with_constant_v(newPoint[:Δs], previousPoint[:v]) # step size (in s) newPoint[:Δv] = 0.0 # step size (in m/s) else newPoint[:Δv] = stepSize * sign(previousPoint[:a]) # step size (in m/s) - newPoint[:Δs] = calc_Δs_with_Δv(newPoint[:Δv], previousPoint[:a], previousPoint[:v]) # step size (in m) - newPoint[:Δt] = calc_Δt_with_Δv(newPoint[:Δv], previousPoint[:a]) # step size (in s) + newPoint[:Δs] = Δs_with_Δv(newPoint[:Δv], previousPoint[:a], previousPoint[:v]) # step size (in m) + newPoint[:Δt] = Δt_with_Δv(newPoint[:Δv], previousPoint[:a]) # step size (in s) end end #if diff --git a/src/formulary.jl b/src/formulary.jl index fe0c5d2..fffa909 100644 --- a/src/formulary.jl +++ b/src/formulary.jl @@ -34,7 +34,7 @@ v00 = 100/3.6 # velocity factor (in m/s) #TODO: replace the ? ? ? """ - calcTractionUnitResistance(v, train) + tractionUnitResistance(v, train) Calculate the vehicle resistance for the traction unit of the `train` dependend on the velocity `v`. @@ -46,11 +46,11 @@ Calculate the vehicle resistance for the traction unit of the `train` dependend # Examples ```julia-repl -julia> calcTractionUnitResistance(30.0, ? ? ?) +julia> tractionUnitResistance(30.0, ? ? ?) ? ? ? ``` """ -function calcTractionUnitResistance(v::AbstractFloat, train::Train) +function tractionUnitResistance(v::AbstractFloat, train::Train) # equation is based on [Wende:2003, page 151] f_Rtd0 = train.f_Rtd0 # coefficient for basic resistance due to the traction units driving axles (in ‰) f_Rtc0 = train.f_Rtc0 # coefficient for basic resistance due to the traction units carring axles (in ‰) @@ -60,16 +60,16 @@ function calcTractionUnitResistance(v::AbstractFloat, train::Train) F_R_tractionUnit = f_Rtd0/1000 * m_td * g + f_Rtc0/1000 * m_tc * g + f_Rt2/1000 * (m_td+m_tc) * g * ((v + Δv_air) /v00)^2 # vehicle resistance of the traction unit (in N) # /1000 because of the unit ‰ - # TODO: use calcForceFromCoefficient? F_R_tractionUnit = calcForceFromCoefficient(f_Rtd0, m_td) + calcForceFromCoefficient(f_Rtc0, m_tc) + calcForceFromCoefficient(f_Rt2, m_td+m_tc) * ((v + Δv_air) /v00)^2 # vehicle resistance of the traction unit (in N) + # TODO: use forceFromCoefficient? F_R_tractionUnit = forceFromCoefficient(f_Rtd0, m_td) + forceFromCoefficient(f_Rtc0, m_tc) + forceFromCoefficient(f_Rt2, m_td+m_tc) * ((v + Δv_air) /v00)^2 # vehicle resistance of the traction unit (in N) return F_R_tractionUnit #TODO: same variable name like in the rest of TrainRuns? return R_traction -end #function calcTractionUnitResistance +end #function tractionUnitResistance """ TODO calculate and return the freight wagons' vehicle resistance dependend on the velocity """ -function calcFreightWagonsResistance(v::AbstractFloat, train::Train) +function freightWagonsResistance(v::AbstractFloat, train::Train) # equation is based on a combination of the equations of Strahl and Sauthoff [Wende:2003, page 153] f_Rw0 = train.f_Rw0 # coefficient for basic resistance of the set of wagons (consist) (in ‰) f_Rw2 = train.f_Rw2 # coefficient fo the consistsr air resistance (in ‰) @@ -77,7 +77,7 @@ function calcFreightWagonsResistance(v::AbstractFloat, train::Train) F_R_wagons = m_w *g *(f_Rw0/1000 + f_Rw2/1000 * (v /v00)^2) # vehicle resistance of freight wagons (in N) with Strahl # /1000 because of the unit ‰ -# TODO: use calcForceFromCoefficient? F_R_wagons = calcForceFromCoefficient(f_Rw0, m_w) + ... +# TODO: use forceFromCoefficient? F_R_wagons = forceFromCoefficient(f_Rw0, m_w) + ... return F_R_wagons end #function calcWagonsResistance @@ -85,7 +85,7 @@ end #function calcWagonsResistance TODO calculate and return the passenger wagons' vehicle resistance dependend on the velocity """ -function calcPassengerWagonsResistance(v::AbstractFloat, train::Train) +function passengerWagonsResistance(v::AbstractFloat, train::Train) # equation is based on the equations of Sauthoff [Wende:2003, page 153] f_Rw0 = train.f_Rw0 # coefficient for basic resistance of the set of wagons (consist) (in ‰) f_Rw1 = train.f_Rw1 # coefficient for the consists resistance to rolling (in ‰) @@ -94,11 +94,11 @@ function calcPassengerWagonsResistance(v::AbstractFloat, train::Train) F_R_wagons = m_w *g *(f_Rw0/1000 + f_Rw1/1000 *v /v00 + f_Rw2/1000 * ((v + Δv_air) /v00)^2) # vehicle resistance of passenger wagons (in N) with Sauthoff # /1000 because of the unit ‰ -# TODO: use calcForceFromCoefficient? F_R_wagons = calcForceFromCoefficient(f_Rw0, m_w) + ... +# TODO: use forceFromCoefficient? F_R_wagons = forceFromCoefficient(f_Rw0, m_w) + ... return F_R_wagons end #function calcWagonsResistance -function calcForceFromCoefficient(f_R::Real, m::Real) +function forceFromCoefficient(f_R::Real, m::Real) # equation is based on [Wende:2003, page 8] # f_R: specific resistance (in ‰) @@ -106,9 +106,9 @@ function calcForceFromCoefficient(f_R::Real, m::Real) F_R = f_R /1000 *m *g # Resisting Force (in N) # /1000 because of the unit ‰ return F_R -end #function calcForceFromCoefficient +end #function forceFromCoefficient -function calcAcceleration(F_T::Real, F_R::Real, m_train::Real, ξ_train::Real) +function acceleration(F_T::Real, F_R::Real, m_train::Real, ξ_train::Real) # equation is based on [Bruenger:2014, page 72] with a=dv/dt # F_T: tractive effort (in N) @@ -118,9 +118,9 @@ function calcAcceleration(F_T::Real, F_R::Real, m_train::Real, ξ_train::Real) a = (F_T - F_R) /m_train /ξ_train # acceleration (in m/s) return a -end #function calcAcceleration +end #function acceleration -function calc_Δs_with_Δt(Δt::Real, a_prev::Real, v_prev::Real) +function Δs_with_Δt(Δt::Real, a_prev::Real, v_prev::Real) # equation is based on [Wende:2003, page 37] # Δt: time step (in s) @@ -128,9 +128,9 @@ function calc_Δs_with_Δt(Δt::Real, a_prev::Real, v_prev::Real) # v_prev: velocitiy from previous data point Δs = Δt * (2*v_prev + Δt*a_prev) /2 # step size (in m) return Δs -end #function calc_Δs_with_Δt +end #function Δs_with_Δt -function calc_Δs_with_Δv(Δv::Real, a_prev::Real, v_prev::Real) +function Δs_with_Δv(Δv::Real, a_prev::Real, v_prev::Real) # equation is based on [Wende:2003, page 37] # Δv: velocity step (in m/s) @@ -138,9 +138,9 @@ function calc_Δs_with_Δv(Δv::Real, a_prev::Real, v_prev::Real) # v_prev: velocitiy from previous data point Δs = ((v_prev + Δv)^2 - v_prev^2)/2/a_prev # step size (in m) return Δs -end #function calc_Δs_with_Δv +end #function Δs_with_Δv -function calc_Δt_with_Δs(Δs::Real, a_prev::Real, v_prev::Real) +function Δt_with_Δs(Δs::Real, a_prev::Real, v_prev::Real) # equation is based on [Wende:2003, page 37] # Δs: distance step (in m) @@ -149,27 +149,27 @@ function calc_Δt_with_Δs(Δs::Real, a_prev::Real, v_prev::Real) Δt = sign(a_prev) *sqrt((v_prev /a_prev)^2 + 2 *Δs /a_prev) - v_prev /a_prev # step size (in m/s) return Δt -end #function calc_Δt_with_Δs +end #function Δt_with_Δs -function calc_Δt_with_Δv(Δv::Real, a_prev::Real) +function Δt_with_Δv(Δv::Real, a_prev::Real) # equation is based on [Wende:2003, page 37] # Δv: velocity step (in m/s) # a_prev: acceleration from previous data point Δt = Δv /a_prev # step size (in s) return Δt -end #function calc_Δt_with_Δv +end #function Δt_with_Δv -function calc_Δt_with_constant_v(Δs::Real, v::Real) +function Δt_with_constant_v(Δs::Real, v::Real) # equation is based on [Wende:2003, page 37] # Δs: distance step (in m) # v: constant velocity (in m/s) Δt = Δs /v # step size (in s) return Δt -end #function calc_Δt_with_constant_v +end #function Δt_with_constant_v -function calc_Δv_with_Δs(Δs::Real, a_prev::Real, v_prev::Real) +function Δv_with_Δs(Δs::Real, a_prev::Real, v_prev::Real) # equation is based on [Wende:2003, page 37] # Δs: distance step (in m) @@ -177,30 +177,30 @@ function calc_Δv_with_Δs(Δs::Real, a_prev::Real, v_prev::Real) # v_prev: velocitiy from previous data point Δv = sqrt(v_prev^2 + 2*Δs*a_prev) - v_prev # step size (in m/s) return Δv -end #function calc_Δv_with_Δs +end #function Δv_with_Δs -function calc_Δv_with_Δt(Δt::Real, a_prev::Real) +function Δv_with_Δt(Δt::Real, a_prev::Real) # equation is based on [Wende:2003, page 37] # Δt: time step (in s) # a_prev: acceleration from previous data point Δv = Δt * a_prev # step size (in m/s) return Δv -end #function calc_Δv_with_Δt +end #function Δv_with_Δt -function calcBrakingDistance(v_start::Real, v_end::Real, a_braking::Real, approxLevel::Integer) +function brakingDistance(v_start::Real, v_end::Real, a_braking::Real, approxLevel::Integer) # equation is based on [Wende:2003, page 37] # v_start: velocity at the start of braking (in m/s) # v_end: target velocity at the end of braking (in m/s) # a_braking: constant braking acceleration (in m/s^2) s_braking = (v_end^2 - v_start^2) /2 /a_braking # braking distance (in m) - # TODO: also possible: calc_Δs_with_Δv(v_end-v_start, a_braking, v_start) + # TODO: also possible: Δs_with_Δv(v_end-v_start, a_braking, v_start) # return max(0.0, ceil(s_braking, digits=approxLevel)) # ceil is used to be sure that the train stops at s_exit in spite of rounding errors return max(0.0, ceil(s_braking, digits= approxLevel +1)) # ceil is used to be sure that the train stops at s_exit in spite of rounding errors -end #function calcBrakingDistance +end #function brakingDistance -function calcBrakingStartVelocity(v_end::Real, a_braking::Real, s_braking::Real, approxLevel::Integer) +function brakingStartVelocity(v_end::Real, a_braking::Real, s_braking::Real, approxLevel::Integer) # equation is based on [Wende:2003, page 37] # v_end: target velocity at the end of braking (in m/s) @@ -209,9 +209,9 @@ function calcBrakingStartVelocity(v_end::Real, a_braking::Real, s_braking::Real, v_start = sqrt(v_end^2 - 2*a_braking *s_braking) # braking start velocity (in m/s) # return floor(v_start, digits= approxLevel) return floor(v_start, digits= approxLevel +1) -end #function calcBrakingStartVelocity +end #function brakingStartVelocity -function calcBrakingAcceleration(v_start::Real, v_end::Real, s_braking::Real) +function brakingAcceleration(v_start::Real, v_end::Real, s_braking::Real) # equation is based on [Wende:2003, page 37] # v_start: braking start velocity (in m/s) @@ -219,4 +219,4 @@ function calcBrakingAcceleration(v_start::Real, v_end::Real, s_braking::Real) # s_braking: braking distance (in Ws) a_braking = (v_end^2 - v_start^2) /2 /s_braking # constant braking acceleration (in m/s^2) return a_braking -end #function calcBrakingAcceleration +end #function brakingAcceleration