User Manual
Version: VECTO 2.2 / VectoCore 3.0.2 / VectoCmd 3.0.2
VECTO is a tool for the calculation of energy consumption and CO2 emissions of vehicles. It models the components of a heavy-duty vehicle and simulates a virtual drive on a route. The goal is to provide a standardized way of calculating the energy consumption (fuel consumption) and corresponding CO2 emissions.
This User Manual consists of 4 Parts:
- Graphical User Interface:
- Here graphical user interface of VECTO with all windows and configuration possibilities is described.
- Calculation Modes:
- The calculation modes of VECTO are described here (Declaration, Engineering, …).
- Simulation Models:
- This chapter describes the used component models and formulas which are implemented in the software.
- Input and Output:
- The input and output file formats are described in this chapter.
This user manual describes both, version 2.2 and verson 3.0.x of Vecto. Vecto 3.x is a complete rewrite of Vecto 2.2 that uses the same models and input data and also produces the same output. However, in some parts version 3.x differs from version 2.2. The according paragraphs are highlighted accordingly.
Calculation Modes
VECTO supports different calculation modes for declaring a vehicle, validation of test-results, or experimenting with different parameters and components. These modes are described here.
- Declaration Mode
- In this mode a vehicle can be declared. Many simulation parameters are predefined to provide a generic way of comparing the emissions.
- Engineering Mode
- This mode is for experimenting and validation of a vehicle. There exist several options how the driving cycle may be defined (Target speed, Measured Speed, Pwheel).
- Engine Only Mode
- This mode is for validation of a measured engine component. Only the engine is simulated in this mode.
In the GUI the Calculation Mode can be changed via the Options Tab of the Main Form.
In the Command Line the Calculation Mode is Declaration by default, but can be changed to Engineering with the “-eng” flag.
A so called Batch Mode exists in VECTO v2.2, which simulates every given job file with every given cycle file. This has nothing to do with the command line, it is just a convenience function to combine job files and cycle files.
VECTO V3.x doesn’t support Batch mode anymore. The same functionality can be achieved by referencing every needed cycle file in the job files.
Engineering Mode
The Engineering Mode lets the user define every aspect in the components of the vehicle and the driving cycle. This is for experimenting and validation purposes.
In this mode the given list of job files is simulated with the respective driving cycles. Each job file defines a separate vehicle.
This is the default calculation mode in VECTO V2.
In VectoCMD V3.x the default mode is Declaration Mode.
Requirements
- One or more checked job files in the Job List
- Each job file must include at least one driving cycle
Results
- Modal results (.vmod). One file for each vehicle/cycle combination.
- Sum results (.vsum). One file for each invocation of VECTO.
Options
The Driving Cycle determines the simulation method in engineering mode. The option depends directly on the driving cycle input and cannot be set explicitely. For more information about the formats see Driving Cycles.
Declaration Mode
In Declaration Mode many input parameters are predefined for the official certification. They are locked in the user interface and will automatically be set by VECTO during calculation. Calculations will be performed for each mission profile (of the corresponding HDV class) with three different loadings each: Empty, full, and reference loading.
Declaration Mode can be activated in the Options Tab.
Requirements
- One or more checked job files in the Job List
- The job files don’t need to include driving cycles. These are automatically assigned.
Results
- Modal results (.vmod). One file for each vehicle/cycle/loading combination.
- Sum results (.vsum). One file for each invocation of VECTO.
- Results overview (.pdf). One file for each job.
Engine-Only Mode
When this mode is enabled in the Job File then VECTO only calculates the fuel consumption based on a load cycle (engine speed and torque). In the Job File only the following parameters are needed:
- Filepath to the Engine File (.veng)
- Driving Cycles including engine torque (or power) and engine speed
The driving cycle also has to be in a special format which is described here: Engine Only Driving Cycle.
Batch Mode
In Batch Mode a list of vehicles is run with a list of driving cycles. Each vehicle defined in the Job List is calculated with each driving cycle defined in the Driving Cycle List. Note that the Driving Cycle List is only visible if Batch Mode is enabled in the Main Form / Options Tab.
Requirements
- One or more checked job files in the Job List. The job files don’t need to include driving cycles. These are ignored in Batch mode.
- One or more checked driving cycles in the Dricing Cycle List
Results
- Modal results (.vmod) for each job file and driving cycle. One file for each vehicle/cycle combination.
- Average/sum results (.vsum / .vsum.json). One file in total containing results for each vehicle/cycle combination.
VECTO V3.x doesn’t support Batch mode anymore. The same functionality can be achieved by referencing every needed cycle file in the job files.
Simulation Models
In this chapter the used component models for the simulation are described.
Acceleration Limiting
VECTO limits the vehicle acceleration and deceleration depending on current vehicle speed, to model a realistic driver behavior. These limits are defined in the Acceleration Limiting Input File (.vacc), which can be set in the Job File. In Declaration mode this is already predefined.
- If the engine can’t provide the required power, the vehicle might accelerate slower than the defined driver limit.
- The minimum deceleration can always be maintained via the brakes.
- In Measured Speed Mode these limits are not used, due to the nature of this mode (speeds and accelerations are already real measured values, therefore VECTO uses them directly without limitation).
Look-Ahead Coasting
Like Overspeed, Look-Ahead Coasting is a function that aims on modelling real-life driver behaviour. It is a forward-looking function that detects forthcoming reductions in target speed in the mission profile (e.g. speed limit, etc.) and induces an early deceleration using engine braking before applying mechanical brakes according to the deceleration limit.
The implemented approach uses a predefined target deceleration (alookahead) to calculate the deceleration time for each particular target speed change.
At the resulting deceleration start point the model calculates the coasting trajectory until it meets the brake deceleration trajectory. The resulting deceleration consists of a coasting phase followed by combined mechanical/engine braking. If Look-Ahead Coasting is disabled only the braking phase according to the deceleration limit will be applied.
- Parameters in Job File:
- Target Retardation = alookahead
- Minimum speed. Below this speed the function is disabled.
Overspeed / Eco-Roll
Both functions control the vehicle’s behaviour on uneven road sections (slope ≠ 0) and can be configured in the Job File’s Driver Assist Tab. Overspeed is designed to model an average driver’s behaviour without the aid of driver assistance systems. Eco-Roll represents an optional driver assistance feature. For this reason vehicles without Eco-Roll should always have the Overspeed function enabled.
Overspeed
Overspeed activates as soon as the total power demand at the wheels (Pwheel) falls below zero, i.e. the vehicle accelerates on a negative slope. The clutch remains closed, engine in motoring operation, and the vehicle accelerates beyond the cycle’s target speed. When the speed limit (target speed plus Max. Overspeed) is reached the mechanical brakes are engaged to prevent further acceleration.
Example with target (purple) and actual speed (orange) on the top left axis, slope (brown) on the top right axis. The bottom graph shows engine power (blue), motoring curve (orange) and mechanical brake power (green). In this example Overspeed is allowed until the vehicle’s speed exceeds target speed by 5 [km/h].
- Parameters in Job File:
- Minimum speed [km/h]. Below this speed the function is disabled.
- Max. Overspeed [km/h] (relative to target speed)
Eco-Roll
Instead of using the engine brake (with no fuel consumption) Eco-Roll shifts to Neutral, engine idling, to minimize deceleration and maximize the vehicle’s roll out distance. During this phase the engine has to overcome its own idling losses and the power demand from the auxiliaries. The engine is engaged again if the speed exceeds the speed limits defined by Max. Over-/Underspeed.
Example of Eco-Roll. Target (purple) and actual speed (orange) on the top left axis, slope (brown) on the top right axis. The bottom graph shows engine power (blue), motoring curve (orange) and mechanical brake power (green). The engine is idling while the vehicle rolls freely and braking when the upper speed limit is reached.
- Parameters in Job File:
- Minimum speed [km/h] Below this speed the function is disabled.
- Max. Overspeed [km/h] (relative to target speed)
- Max. Underspeed [km/h] (relative to target speed)
Cross Wind Correction
VECTO offers three different modes to consider cross wind influence on the drag coefficient. It is configured in the Vehicle File.
Speed dependent correction (Declaration Mode)
This is the mode which is used in Declaration Mode. The speed dependent CdA curve (see below) is calculated based on generic parameters for each vehicle class and the CdA value from the Vehicle File.
Speed dependent correction (User-defined)
The base CdA value (see Vehicle File) is corrected with a user-defined speed dependent scaling function. A vcdv-File is needed for this calculation.
The CdA value given in the vehicle configuration is corrected depending on the vehicle’s speed and the Cd scaling factor from the input file as follows:
\(C_dA_{effective} = C_dA * C_d(v_{veh})\)
Rolling Resistance Coefficient
The rolling resistance is calculated using a speed-independent rolling resistance coefficient (RRC). In order to consider that the RRC depends on the vehicle weight it is modelled as a function of the total vehicle mass. The total RRC is calculated in VECTO using the following equation (the index i refers to the vehicle’s axle (truck and trailer)):
\(RRC = \sum_{i=1}^{n} s_{(i)} \cdot RRC_{ISO(i)} \cdot \left( \fracs{_{(i)} \cdot m \cdot g }{w_{(i)} \cdot F_{zISO(i)} } \right)^{\beta-1}\)
with:
| RRC |
[-] |
Total rolling resistance coefficient used for calculation |
[calculated] |
| s(i) |
[-] |
Relative axle load. Defined in the Vehicle File. |
[user input] |
| RRCISO(i) |
[-] |
…Tyre RRC according to ISO 28580. Defined in the Vehicle File. |
[user input] |
| w(i) |
[-] |
Number of tyres (4 if Twin Tyres, else 2). Defined in the Vehicle File. |
[user input] |
| FzISO(i) |
[N] |
Tyre test load according to ISO 28580 (85% of max. load capacity). Defined in the Vehicle File. |
[user input] |
| m |
[kg] |
Vehicle mass plus loading. |
[calculated] |
| g |
[m/s²] |
Earth gravity acceleration (constant = 9.81, Vecto 3.x: 9.80665) |
[constant model parameter] |
| β |
[-] |
Constant parameter = 0.9 |
[constant model parameter] |
For each axle the parameters Relative axle load, RRCISO and FzISO have to be defined. Axles with twin tyres have to be marked using the respective checkbox in the Vehicle-Editor.
Engine Start/Stop
If enabled the engine will be turned off after the set Activation Delay [s] if the following conditions apply:
- Power demand ≤ 0
- Vehicle speed is below Max Speed [km/h]
- Engine was running for at least Min ICE-On Time [s]
Parameters in Job File:
- Max speed [km/h].
- Min ICE-On Time [s]
- Activation Delay [s]
If Start/Stop is enabled the fuel consumption is corrected for not-considered auxiliary energy consumption during engine stop. See Start/Stop FC Correction.
Fuel Consumption Calculation
The base FC value is interpolated from the stationary FC map. If necessary the base value is corrected to compensate for unconsidered auxiliary energy consumption for vehicles with Start/Stop. In Declaration Mode additionally the WHTC correction is applied, see below.
The CO2 result for the actual mission profile is directly derived from the fuel consumption using a gravimetric CO2/FC factor.
Fuel Map Interpolation
The interpolation is based on Delaunay Triangulation 
and works as follows:
- Triangulate the given rpm/torque/fuel points (= x,y,z) to create a grid of triangles with each point of the map being part of at least one triangle.
- Find the triangle where the to-be-interpolated load point (x,y) is inside. If no triangle meets the criterion the calculation will be aborted.
- Calculate the z-value (= fuel) of the given x,y-point in the plane of the triangle
Delaunay Triangulation Example
Auxiliary - Start/Stop Correction
For vehicles with Start/Stop the fuel consumption needs to be corrected to consider the wrong auxiliary energy balance caused by engine stops because VECTO uses a constant power demand for auxiliaries for the whole mission profile. The correction consists of the following steps:
- From all 1Hz data points of the VECTO simulation, a linear regression curve (y=k*x+d) for fuel consumption (unit: grams per hour) over engine power (unit: kilo-watt) is calculated (see figure below).
- From the difference between the energy consumed by the auxiliaries in the simulation with Start/Stop function and the target value (unit kilowatt-hours), a cycle average change in mechanical power “ΔPe” (unit kilowatt) of the internal combustion engine is calculated (using an average alternator efficiency and the cycle time with running engine).
- The correction of the fuel consumption is performed for all 1Hz time steps using: ΔFC (unit: grams per hour) = ΔPe * k where k = gradient in the regression. If the engine is running in motoring conditions ΔFC is set to zero.
Engine: Transient Full Load
The engine implements a PT1 behaviour to model transient torque build up.
VECTO 2 uses a PT1 function to model transient torque build up using this formula:
\(P_{fld\ dyn_{i}} = \frac{1}{T(n_{i})+1} \cdot \left(P_{fld\ stat}(n_{i})+T(n_{i}) \cdot P_{act_{i-1}}\right)\)
with:
- ni … current engine speed
- T(ni) … PT1 time constant at engine speed ni (col. 4 in .vfld file)
- Pfld stat(ni) … Static full load at engine speed ni (col. 2 in .vfld file)
- Pact i-1 … Engine power in previous time step
Vecto 3 uses basically the same PT1 behavior to model transient torque build up. However, due to the dynamic time steps the formula is implemented as follows:
\(P_{fld\ dyn_{i}} = P_{fld\ stat}(n_i) \cdot \left(1 - e^{-\frac{t_i^*}{\mathit{PT1}}}\right)\)
where t* is computed from the dynamic full-load power in the previous simulation interval:
\(t_i^* = t_{i-1}^* + dt\)
\(t_{i-1}^* = \mathit{PT1} \cdot ln\left(\frac{1}{1 - \frac{P_{eng_{i - 1}}}{P_{fld\ stat}(n_i)}}\right)\)
Engine: WHTC Correction
In declaration mode the fuel consumption is corrected as follows:
To prevent inconsistencies of regulated emissions and fuel consumption between the WHTC (hot part) test and the steady state fuel map as well as considering effects of transient engine behaviour a “WHTC correction factor” is used.
Based on the target engine operation points of the particular engine in WHTC the fuel consumption is interpolated from the steady state fuel map (“backward calculation”) in each of the three parts of the WHTC separately. The measured specific fuel consumption per WHTC part in [g/kWh] is then divided by the interpolated specific fuel consumption to obtain the “WHTC correction factors” CFurb (Urban), CFrur (Rural), CFmot (Motorway). For the interpolation the same method as for interpolation in VECTO is applied (Delauney triangulation).
All calculations regarding the brake specific fuel consumption from the interpolation as well as from the measurement and the three correction factors CFurb, CFrur, CFmot are fully implemented in the VECTO-Engine evaluation tool.
The total correction factor CFtotal depends on the mission profile and is produced in VECTO by mission profile specific weighting factors listed in the table below.
\(CF_{total} = CF_{urb} \cdot WF_{urb} + CF_{rur} \cdot WF_{rur} + CF_{mot} \cdot WF_{mot}\)
with the correction factor CFurb, CFrur, CFmot coming from the Engine, and weighting factors WFurb, WFrur, WFmot predefined in the declaration data:
| Long haul |
11% |
0% |
89% |
| Regional delivery |
17% |
30% |
53% |
| Urban delivery |
69% |
27% |
4% |
| Municipial utility |
98% |
0% |
2% |
| Construction |
62% |
32% |
6% |
| Citybus |
100% |
0% |
0% |
| Interurban bus |
45% |
36% |
19% |
| Coach |
0% |
22% |
78% |
The whtc fuel consumption is then calculated with: \(FC_{whtc} = FC \cdot CF_{total}\)
In engineering mode no WHTC correction is applied by Vecto. For an arbitrary cycle the weighting factors are not known, hence the total correction factor CFtotal can not be computed. WHTC correction can be applied manually as a post-processing step.
Gear Shift Model
The Gear Shift Model is based on shift curves that define the engine speed for up- and down- shifting as a function of engine torque. As soon as the engine operation point passes one of the shift curves a gear change is initiated.
Example shift polygons
Down-shift:
- As soon as the current engine speed falls below the down-shift cuve a down-shift is initiated
Up-shift:
- MT and AMT transmissions: Up-shift is initiated when the current engine speed is above the up-shift curve
- AT transmissions: Up-shift is initiated when the next-gear engine speed is above the up-shift curve
The shift polygons are saved in the Shift Polygons Input File (.vgbs) and have to be added to the Gearbox File when not in Declaration Mode.
In Declaration Mode the generic shift polygons are computed from the engine’s full-load curve. If the maximum torque is limited by the gearbox, the minimum of the current gear and engine maximum torque will be used to compute the generic shift polygons. Note: the computation of the shift polygons uses characteristic values from the engine such as n95h, npref, etc. which are also derived from the full-load curve.
In the Gearbox File two additional parameters are defined:
- Torque Reserve [%] - Required for the “Early Upshift” and “Skip Gears” options, see below.
- Minimum shift time [s] - Limits the time between two gear shifts in whole seconds. This rule will be ignored if rpms are too high or too low. Note that high values may cause high rpms during acceleration.
Gear Skipping
Gear Skipping can be enabled in the Gearbox File. By default it is enabled for AMT and MT. Whenever a gear change is initiated (by crossing the up- or down-shift line) VECTO may skip one or several gears as long as the required torque reserve is provided.
Early Upshift
Early Upshift can be enabled in the Gearbox File (Allow shift-up inside polygons). By default it is enabled for AMT only. If the next higher gear provides the required torque reserve and it’s rpm is still above down-shift-rpm VECTO will shift up.
Torque Converter Model
!!! The Torque Converter Model is still in development and at the moment only available in Vecto 2.2 !!!
The torque converter is defined as (virtual) separate gear. While TC active: Iterative calculation of engine torque and speed based on TC characteristic. Creeping: Engine speed set to idling. Brakes engaged to absorb surplus torque.
Torque converter characteristics file (.vtcc)
The file is described here.
This file defines the torque converter characteristics as described in VDI 2153:
- Speed Ratio (ν) = Output Speed / Input Speed
- Torque Ratio (μ) = Output Torque / Input Torque
- Input Torque (Tref(ν)) is the input torque (over ν) for a specific reference engine speed (see below).
The Input Torque at reference engine speed is needed to calculate the actual engine torque using this formula:
\(T_{in} = T_{ref}(v) \cdot ( \frac{n_{in}}{n_{ref}} )^{2}\)
with:
- Tin = engine torque [Nm]
- Tref(ν) = reference torque at reference rpm (form .vtcc file) [Nm]
- nin = engine speed [1/min]
- nref = reference rpm [1/min] (see below)
The torque converter characteristics must also be defined for speed ratios of more than one (ν>1) in order to calculate overrun conditions (torque<0).
Setup for Conventional AT gearboxes
Torque converter file is defined for torque converter only
- Define TC gear with ratio of first (mechanical) gear
- Set transmission losses of first gear (map or constant efficiency)
Setup for Power-distributed AT gearboxes
Torque converter file is defined for the whole gearbox
- Define TC gear with ratio = 1
- Set transmission efficiency to 1 (= 100%) because losses are covered by the .vtcc file.
Auxiliaries
In VECTO a generic map-based approach was implemented to consider all types of auxiliaries. The supply power demand for each single auxiliary is defined in the driving cycle. Hence a time/distance-dependent power demand can be defined. Based on the supply power and a pre-defined efficiency map the auxiliary input power is calculated. A constant efficiency determines the losses between auxiliary and engine.
For each auxiliary the power demand is calculated using the following steps:
Auxiliary speed: naux = nEng * TransRatio
Auxiliary output power: PauxOut = Psupply/EffToSply
Auxiliary input power: PauxIn = EffMap(nAux, PAuxOut)
Auxiliary power consumption: Paux = PauxIn/EffToEng
Paux is added to the engine’s power demand
Each auxiliary must be defined in the Job File and each driving cycle used with this vehicle must include supply power for each auxiliary. To link the supply power in the driving cycle to the correct auxiliary in the Job File an ID is used. The corresponding supply power is then named “<Aux_ID>”.
Example: The Auxiliary with the ID “ALT” (in the Job File) is linked to the supply power in the column “<Aux_ALT>” in the driving cylce.
Input and Output
Vecto uses data files for input and output of data. These are stored in different formats which are listed here.
Input:
Output:
CSV
Many data files in Vecto use CSV (Comma Separated Values) as common file format. They consist of a header which defines the columns and data entries which are separated by a comma (“,”).
In Vecto 3 the order of the columns is arbitrary if the column header matches the header definitions described in this user manual. If the column header does not match, a warning is written to the log file and the columns are parsed in the sequence as described in this manual as a fall-back.
Definition
| Header: |
Vecto CSV needs exactly one header line with the definition of the columns at the beginning of the file.
Columns can be surrounded with “<” and “>” to mark them as identifiers (which makes them position independent). In Vecto 3.x every column is seen as identifier, regardless of “<>”.
Columns may be succeded with unit information (enclosed in “[" and “]”) for documentation purposes. |
| Column Separator: |
, (Comma. Separates the columns of a data line.) |
| Decimal-Mark: |
. (Dot. Splits numbers into integer part and decimal part.) |
| Thousand-Separator: |
Vecto CSV does not allow a thousand-separator. |
| Comments: |
# (Number sign. Declares text coming afterwards in the current line as comment.) |
| Whitespace: |
Whitespaces between columns will be stripped away. Therefore it is possible to align the columns for better readability, if desired. |
Following files use the csv:
Notes: The Auxiliary Input File (.vaux) uses a modified csv format with some special headers.
Examples
Exampl 1: Acceleration Limiting File
v [km/h],acc [m/s^2] ,dec [m/s^2]
0 ,1.01570922360353,-0.231742702878269
5 ,1.38546581120225,-0.45346198022574
10 ,1.34993329755465,-0.565404125020508
15 ,1.29026714002479,-0.703434814668512
Example 2: Driving Cycle
<s>,<v>,<grad> ,<stop>,<Padd>,<Aux_ALT1>,<Aux_ALT2>,<Aux_ALT3>
0 ,0 ,-0.020237973,2 ,6.1 ,0.25 ,0.25 ,0.25
1 ,64 ,-0.020237973,0 ,6.1 ,0.25 ,0.25 ,0.25
2 ,64 ,-0.020237973,0 ,6.1 ,0.25 ,0.25 ,0.25
3 ,64 ,-0.020237973,0 ,6.1 ,0.25 ,0.25 ,0.25
Example 3: Transmission Loss Map
Input Speed [rpm],Input Torque [Nm],Torque Loss [Nm]
0 ,-2500 ,77.5
0 ,-1500 ,62.5
0 ,-500 ,47.5
0 ,500 ,47.5
JSON
Configuration and component files in Vecto use JSON as common file format.
Following files use JSON:
Job File
File for the definition of an job in vecto. A job contains everything what is needed to run a simulation. Can be created with the Job Editor.
- File format is JSON.
- Filetype ending is “.vecto”
Refers to other files:
Example:
{
"Header": {
"CreatedBy": "Michael Krisper (Graz University of Technology)",
"Date": "2016-03-18T14:37:05+01:00",
"AppVersion": "3.0.2",
"FileVersion": 2
},
"Body": {
"SavedInDeclMode": false,
"VehicleFile": "Vehicle.vveh",
"EngineFile": "Engine.veng",
"GearboxFile": "Gearbox.vgbx",
"Cycles": [
"DrivingCycle_Rural.vdri",
"DrivingCycle_Urban.vdri"
],
"Aux": [
{
"ID": "ALT",
"Type": "Alternator",
"Path": "Alternator.vaux",
"Technology": ""
},
{
"ID": "PN",
"Type": "PneumaticSystem",
"Path": "Pneumatic System.vaux",
"Technology": ""
},
{
"ID": "HVAC",
"Type": "HVAC",
"Path": "AirCondition.vaux",
"Technology": ""
}
],
"VACC": "Driver.vacc",
"EngineOnlyMode": true,
"StartStop": {
"Enabled": false,
"MaxSpeed": 5.0,
"MinTime": 0.0,
"Delay": 0
},
"LAC": {
"Enabled": true,
"Dec": -0.5,
"MinSpeed": 50.0
},
"OverSpeedEcoRoll": {
"Mode": "OverSpeed",
"MinSpeed": 70.0,
"OverSpeed": 5.0,
"UnderSpeed": 5.0
}
}
}
Vehicle File
File for the definition of a vehicle in vecto. Can be created with the Vehicle Editor.
- File format is JSON.
- Filetype ending is “.vveh”
Refers to other files:
Example:
{
"Header": {
"CreatedBy": "Michael Krisper (Graz University of Technology)",
"Date": "2016-03-18T14:42:45+01:00",
"AppVersion": "3.0.2",
"FileVersion": 7
},
"Body": {
"SavedInDeclMode": false,
"VehCat": "RigidTruck",
"CurbWeight": 6000.0,
"CurbWeightExtra": 0.0,
"Loading": 0.0,
"MassMax": 11.9,
"CdA": 4.5,
"rdyn": 450,
"Rim": "15° DC Rims",
"CdCorrMode": "CdOfVeng",
"CdCorrFile": "CrossWindCorrection.vcdv",
"Retarder": {
"Type": "Secondary",
"Ratio": 1.0,
"File": "Retarder.vrlm"
},
"AxleConfig": {
"Type": "4x2",
"Axles": [
{
"Inertia": 6.0,
"Wheels": "245/70 R19.5",
"AxleWeightShare": 0.0,
"TwinTyres": false,
"RRCISO": 0.008343465,
"FzISO": 20800.0
},
{
"Inertia": 6.0,
"Wheels": "245/70 R19.5",
"AxleWeightShare": 0.0,
"TwinTyres": true,
"RRCISO": 0.00943769,
"FzISO": 20800.0
}
]
}
}
}
Engine File
File for the definition of an engine in Vecto. Can be created with the Engine Editor.
- File format is JSON.
- Filetype ending is “.veng”
Refers to other files:
Example:
{
"Header": {
"CreatedBy": "Michael Krisper (Graz University of Technology",
"Date": "2016-03-18T14:48:38+01:00",
"AppVersion": "3.0.2",
"FileVersion": 3
},
"Body": {
"SavedInDeclMode": false,
"ModelName": "Engine",
"Displacement": 7700.0,
"IdlingSpeed": 600.0,
"Inertia": 3.789,
"FullLoadCurve": "EngineFullLoadCurve.vfld",
"FuelMap": "FuelConsumptionMap.vmap",
"WHTC-Urban": 0.97,
"WHTC-Rural": 0.99,
"WHTC-Motorway": 1.05
}
}
Full Load and Drag Curves (.vfld)
This file contains the full load and drag curves and the PT1 values for the transient full load calculation. The file uses the VECTO CSV format.
- Filetype: .vfld
- Header: engine speed [1/min], full load torque [Nm], motoring torque [Nm], PT1 [s]
- engine speed [1/min]: the engine speed in rpm.
- full load torque [Nm]: the maximum possible full load for the engine speed.
- motoring torque [Nm]: the minimum possible drag load in motoring for the engine speed.
- PT1 [s]: the PT1 constant for the transient full load calculation.
- Requires at least 2 data entries
Example:
engine speed [1/min],full load torque [Nm],motoring torque [Nm],PT1 [s]
560 ,1180 ,-149 ,0.6
600 ,1282 ,-148 ,0.6
800 ,1791 ,-149 ,0.6
...
Fuel Consumption Map (.vmap)
The FC map is used to interpolate the base fuel consumption before corrections are applied. For details see Fuel Consumption Calculation. The file uses the VECTO CSV format.
- Filetype: .vmap
- Header: engine speed [rpm], torque [Nm], fuel consumption [g/h]
- Requires at least 3 data entries
- The map must cover the full engine range between full load and motoring curve.
Extrapolation of fuel consumption map is not possible.
Extrapolation of fuel consumption map is possible in Engineering Mode (with warnings!). In Declaration Mode it is not allowed.
Example:
engine speed [rpm],torque [Nm],fuel consumption [g/h]
600 ,-45 ,0
600 ,0 ,767
600 ,100 ,1759
600 ,200 ,2890
600 ,300 ,4185
600 ,400 ,5404
600 ,500 ,6535
600 ,600 ,7578
...
Gearbox File
File for the definition of a gearbox in Vecto. Can be created with the Gearbox Editor.
- File format is JSON.
- Filetype ending is “.vgbx”
Refers to other files:
Example:
{
"Header": {
"CreatedBy": "Michael Krisper (Graz University of Technology)",
"Date": "2016-03-18T14:37:18+01:00",
"AppVersion": "3.0.2",
"FileVersion": 5
},
"Body": {
"SavedInDeclMode": false,
"ModelName": "Generic 8 Gears",
"Inertia": 0.0,
"TracInt": 1.0,
"Gears": [
{
"Ratio": 3.2,
"LossMap": "Axle.vtlm"
},
{
"Ratio": 6.4,
"LossMap": "Indirect Gear.vtlm",
"TCactive": false,
"ShiftPolygon": "ShiftPolygon.vgbs",
"FullLoadCurve": "<NOFILE>"
},
{
"Ratio": 4.6,
"LossMap": "Indirect Gear.vtlm",
"TCactive": false,
"ShiftPolygon": "ShiftPolygon.vgbs",
"FullLoadCurve": "<NOFILE>"
},
{
"Ratio": 3.4,
"LossMap": "Indirect Gear.vtlm",
"TCactive": false,
"ShiftPolygon": "ShiftPolygon.vgbs",
"FullLoadCurve": "<NOFILE>"
},
{
"Ratio": 2.6,
"LossMap": "Indirect Gear.vtlm",
"TCactive": false,
"ShiftPolygon": "ShiftPolygon.vgbs",
"FullLoadCurve": "<NOFILE>"
},
{
"Ratio": 1.9,
"LossMap": "Indirect Gear.vtlm",
"TCactive": false,
"ShiftPolygon": "ShiftPolygon.vgbs",
"FullLoadCurve": "<NOFILE>"
},
{
"Ratio": 1.3,
"LossMap": "Indirect Gear.vtlm",
"TCactive": false,
"ShiftPolygon": "ShiftPolygon.vgbs",
"FullLoadCurve": "<NOFILE>"
},
{
"Ratio": 1,
"LossMap": "Direct Gear.vtlm",
"TCactive": false,
"ShiftPolygon": "ShiftPolygon.vgbs",
"FullLoadCurve": "<NOFILE>"
},
{
"Ratio": 0.75,
"LossMap": "Indirect Gear.vtlm",
"TCactive": false,
"ShiftPolygon": "ShiftPolygon.vgbs",
"FullLoadCurve": "<NOFILE>"
}
],
"TqReserve": 20.0,
"SkipGears": true,
"ShiftTime": 2,
"EaryShiftUp": true,
"StartTqReserve": 20.0,
"StartSpeed": 2.0,
"StartAcc": 0.6,
"GearboxType": "AMT",
"TorqueConverter": {
"Enabled": false,
"File": "<NOFILE>",
"RefRPM": 0.0,
"Inertia": 0.0
}
}
}
Transmission Loss Map
This file defines losses in gearbox and axle transmission and must be provided for each gear in the Gearbox File. The file uses the VECTO CSV format.
- Filetype: .vtlm
- Header: Input Speed [rpm], Input Torque [Nm], Torque Loss [Nm]
- Requires at least 3 data entries
Input speed and input torque are meant at the engine-side.
Example:
Input Speed [rpm],Input Torque [Nm],Torque Loss [Nm]
0 ,-350 ,6.81
0 ,-150 ,5.81
0 ,50 ,5.31
0 ,250 ,6.31
0 ,450 ,7.31
0 ,650 ,8.31
Sign of torque values
- Input Torque >0 means normal driving operation.
- Input Torque <0 means motoring operation. The Torque Loss Map must include negative torque values for engine motoring operation!
- Torque Loss is always positive!
Calculation of Output Torque
VECTO calculates the output torque using this formula, independent from the current operation mode (driving/braking):
\(T_{output} = (T_{input} - T_{loss}) * r_{gear}\)
with:
- Toutput … Output torque
- Tinput … Input torque
- Tloss … Torque loss
- rgear … The tranmission ratio for the gurrent gear
Torque Converter Characteristics (.vtcc)
!!! The Torque Converter Model is still in development !!!
The file uses the VECTO CSV format.
- Filetype: .vtlm
- Header: Speed Ratio, Torque Ratio, Input Torque at reference rpm
- Requires at least 2 data entries
See Torque Converter Model for more information about the component model.
Driving Cycles
A Driving Cycle defines the parameters of a simulated route in Vecto. It is either time-based or distance-based and has different fields depending on the driving cycle type. The basic file format is Vecto-CSV and the file type ending is “.vdri”. A Job must have at least one driving cycle (except in Declaration mode, where the driving cycles are predefined).
Driving Cycle Types
- Distance-based cycles must have at least a resolution of 1[m].
- Time-based cycles must have exactly a resolution of 1[s].
- Distance-based cycles can be defined in any distance resolution, including variable distance steps.
- Time-based cycles can be defined in any time resolution, including variable time steps.
Declaration Mode Cycles
In Declaration Mode driving cycles are automatically chosen depending on vehicle category and cannot be changed by the user. These predefined cycles are of type target-speed, distance-based.
- Coach: 275km
- Construction: 21km
- Heavy Urban: 30km
- Inter Urban: 123km
- Long Haul: 100km
- Municipal Utility: 10km
- Regional Delivery: 26km
- Sub Urban: 23km
- Urban: 40km
- Urban Delivery: 28km
Engineering Mode: Target-Speed, Distance-Based Cycle
This driving cycle defines the target speed over distance. Vecto tries to achieve and maintain this target speed.
Header: <s>, <v>, <stop>[, <Padd>][, <grad>][, <vair_res>, <vair_beta>][, <Aux_ID>]
| s |
[m] |
Traveled distance. Must always be increasing. |
| v |
[km/h] |
The target vehicle velocity. Must be >= 0 km/h. |
| stop |
[s] |
Stopping Time. Defines the time span the vehicle is standing still (time the vehicle spending in a stop phase). After this time, the vehicle tries to accelerate to <v>. |
| Padd |
[kW] |
Additional auxiliary power demand. This power demand will be directly added to the engine power in addition to possible other auxiliaries. Must be >= 0 kW. |
| grad |
[%] |
The road gradient. |
| vair_res |
[km/h] |
Air speed relative to vehicle for cross wind correction. Only required if Cross Wind Correction is set to Vair & Beta Input. |
| vair_beta |
[°] |
Wind Yaw Angle for cross wind correction. Only required if Cross Wind Correction is set to Vair & Beta Input. |
| Aux_ID |
[kW] |
Auxiliary Supply Power. Can be defined multiple times with different Identifiers. The supply power input for each auxiliary defined in the .vecto file with the corresponding ID. ID’s are not case sensitive and must only contain letters and numbers [a-z,A-Z,0-9]. Must be >= 0 kW. |
Example:
| 0 |
10 |
10 |
2.95 |
1.5 |
| 1 |
20 |
0 |
2.97 |
1.3 |
| 2 |
35 |
0 |
3.03 |
1.3 |
| 3 |
50 |
0 |
2.99 |
1.3 |
Engineering Mode: Measured-Speed, Time-Based Cycle
This driving cycle defines the actual measured speed over time. Vecto tries to simulate the vehicle model using this speed as the actual vehicle speed. Due to differences in the real and simulated shift strategies a short difference in speed could occur, but Vecto immediately tries to catch up after the gear is engaged again.
Header: <t>, <v>[, <grad>][, <Padd>][, <vair_res>, <vair_beta>][, <Aux_ID>]
| t |
[s] |
The absolute time. Must always be increasing. |
| v |
[km/h] |
The actual velocity of the vehicle. Must be >= 0 km/h. |
| Padd |
[kW] |
Additional auxiliary power demand. This power demand will be directly added to the engine power in addition to possible other auxiliaries. Must be >= 0 kW. |
| grad |
[%] |
The road gradient. |
| vair_res |
[km/h] |
Air speed relative to vehicle for cross wind correction. Only required if Cross Wind Correction is set to Vair & Beta Input. |
| vair_beta |
[°] |
Wind Yaw Angle for cross wind correction. Only required if Cross Wind Correction is set to Vair & Beta Input. |
| Aux_ID |
[kW] |
Auxiliary Supply Power. Can be defined multiple times with different Identifiers. The supply power input for each auxiliary defined in the .vecto file with the corresponding ID. ID’s are not case sensitive and must only contain letters and numbers [a-z,A-Z,0-9]. Must be >= 0 kW. |
Example:
| 0 |
0 |
2.95 |
1.5 |
| 1 |
0.6 |
2.97 |
1.3 |
| 2 |
1.2 |
3.03 |
1.3 |
| 3 |
2.4 |
2.99 |
1.3 |
Engineering Mode: Measured-Speed With Gear, Time-Based Cycle
This driving cycle defines the actual measured speed of the vehicle, the gear, and the engine speed over time. It overrides the shift strategy of Vecto and also directly sets the engine speed.
Header: <t>, <v>, <n>, <gear>[, <grad>][, <Padd>][, <vair_res>, <vair_beta>][, <Aux_ID>]
| t |
[s] |
The absolute time. Must always be increasing. |
| v |
[km/h] |
The actual velocity of the vehicle. Must be >= 0 km/h. |
| n |
[rpm] |
The actual engine speed. Must always be >= 0 rpm. |
| gear |
[-] |
The current gear. Must be >= 0 (0 is neutral). |
| Padd |
[kW] |
Additional auxiliary power demand. This power demand will be directly added to the engine power in addition to possible other auxiliaries. Must be >= 0 kW. |
| grad |
[%] |
The road gradient. |
| vair_res |
[km/h] |
Air speed relative to vehicle for cross wind correction. Only required if Cross Wind Correction is set to Vair & Beta Input. |
| vair_beta |
[°] |
Wind Yaw Angle for cross wind correction. Only required if Cross Wind Correction is set to Vair & Beta Input. |
| Aux_ID |
[kW] |
Auxiliary Supply Power. Can be defined multiple times with different Identifiers. The supply power input for each auxiliary defined in the .vecto file with the corresponding ID. ID’s are not case sensitive and must only contain letters and numbers [a-z,A-Z,0-9]. Must be >= 0 kW. |
Example:
| 0 |
0 |
600 |
0 |
2.95 |
1.5 |
| 1 |
0.6 |
950 |
3 |
2.97 |
1.3 |
| 2 |
1.2 |
1200 |
3 |
3.03 |
1.3 |
| 3 |
2.4 |
1400 |
3 |
2.99 |
1.3 |
Engineering Mode: Pwheel (SiCo), Time-Based
This driving cycle defines the power measured at the wheels over time. Vecto tries to simulate the vehicle with this power requirement.
Header: <t>, <Pwheel>, <gear>, <n>[, <Padd>]
| t |
[s] |
The absolute time. Must always be increasing. |
| Pwheel |
[kW] |
Power at the wheels. |
| gear |
[-] |
The current gear. Must be >= 0 (0 is neutral). |
| n |
[rpm] |
The actual engine speed. Must be >= 0 rpm. |
| Padd |
[kW] |
Additional auxiliary power demand. This power demand will be directly added to the engine power. Must be >= 0 kW. |
Example:
| 0 |
0 |
0 |
600 |
1.5 |
| 1 |
4.003 |
3 |
950 |
1.3 |
| 2 |
15.333 |
3 |
1200 |
1.3 |
| 3 |
50.56 |
3 |
1400 |
1.3 |
Engine Only Mode: Engine Only Driving Cycle
This driving cycle directly defines the power or torque at the output shaft of the engine over time. Vecto add the engine’s inertia to the given power demand and simulates the engine.
Header: <t>, <n>, (<Pe>|<Me>)[, <Padd>]
| t |
[s] |
The absolute time. Must always be increasing. |
| n |
[rpm] |
The actual engine speed. Must be >= 0 rpm. |
| Pe |
[kW] |
The power at the output shaft of the engine. Either <Pe> or <Me> must be defined. |
| Me |
[Nm] |
The torque at the output shaft of the engine. Either <Pe> or <Me> must be defined. |
| Padd |
[kW] |
Additional auxiliary power demand. This power demand will be directly added to the engine power. Must be >= 0 kW. |
Example:
| 0 |
600 |
0 |
1.5 |
| 1 |
950 |
25.3 |
1.3 |
| 2 |
1200 |
65.344 |
1.3 |
| 3 |
1400 |
110.1 |
1.3 |
To explicitly define motoring operation use the <DRAG> keyword as power demand (column <Pe> or <Me>). VECTO v2 replaces the keyword with the corresponding motoring torque/power from the drag curve during calculation (see Full Load and Drag Curve File).
Modal Results (.vmod)
Modal results are only created if enabled in the Options tab. One file is created for each calculation and stored in the same directory as the .vecto file.
Quantities:
| time |
[s] |
Time step. |
| dist |
[km] |
Travelled distance. |
| v_act |
[km/h] |
Actual vehicle speed. |
| v_targ |
[km/h] |
Target vehicle speed. |
| acc |
[m/s²] |
Vehicle acceleration. |
| grad |
[%] |
Road gradient. |
| n |
[1/min] |
Engine speed. |
| Tq_eng |
[Nm] |
Engine torque. |
| Tq_clutch |
[Nm] |
Torque at clutch (before clutch, engine-side) |
| Tq_full |
[Nm] |
Full load torque |
| Tq_drag |
[Nm] |
Motoring torque |
| Pe_eng |
[kW] |
Engine power. |
| Pe_full |
[kW] |
Engine full load power. |
| Pe_drag |
[kW] |
Engine drag power. |
| Pe_clutch |
[kW] |
Engine power at clutch (equals Pe minus loss due to rotational inertia Pa Eng). |
| Gear |
[-] |
Gear. “0” = clutch opened / neutral. |
| Ploss GB |
[kW] |
Gearbox losses. |
| Ploss Diff |
[kW] |
Losses in differential / axle transmission. |
| Ploss Retrader |
[kW] |
Retarder losses. |
| Pa Eng |
[kW] |
Rotational acceleration power: Engine. |
| Pa GB |
[kW] |
Rotational acceleration power: Gearbox. |
| Pa Veh |
[kW] |
Vehicle acceleration power. |
| Proll |
[kW] |
Rolling resistance power demand. |
| Pair |
[kW] |
Air resistance power demand. |
| Pgrad |
[kW] |
Power demand due to road gradient. |
| Paux |
[kW] |
Total auxiliary power demand. |
| Pwheel |
[kW] |
Total power demand at wheel = sum of rolling, air, acceleration and road gradient resistance. |
| Pbrake |
[kW] |
Brake power. Drag power is included in Pe. |
| Paux_xxx |
[kW] |
Power demand of Auxiliary with ID xxx. See also Aux Dialog and Driving Cycle. |
| FC-Map |
[g/h] |
Fuel consumption interpolated from FC map. |
| FC-AUXc |
[g/h] |
Fuel consumption after Auxiliary-Start/Stop Correction. (Based on FC.) |
| FC-WHTCc |
[g/h] |
Fuel consumption after WHTC Correction. (Based on FC-AUXc.) |
| TCv |
[-] |
Torque converter speed ratio |
| TCµ |
[-] |
Torque converter torque ratio |
| TC_M_Out |
[Nm] |
Torque converter output torque |
| TC_n_Out |
[1/min] |
Torque converter output speed |
In Vecto 3.0.2 the structure of the modal data output has been revised and re-structured. Basicaly for every powertrain component the .vmod file contains the power at the input shaft and the individual power losses for every component. For the engine the power, torque and engine speed at the output shaft is given along with the internal power and torque used for computing the fuel consumption. The following table lists the columns in the .vmod file:
Quantities:
| time |
[s] |
Absolute time. Timestamp at the middle of the current simulation interval [time - dt/2, time + dt/2] |
| dt |
[s] |
Length of the current simulation interval |
| dist |
[m] |
Distance the vehicle traveled at the end of the current simulation interval |
| v_act |
[km/h] |
Average vehicle speed in the current simulation interval |
| v_targ |
[km/h] |
Target speed |
| acc |
[m/s^2] |
Vehicle’s acceleration, constant during the current simulation interval |
| grad |
[%] |
Road gradient |
| Gear |
[-] |
Gear. “0” = clutch opened / neutral |
| n_eng_avg |
[1/min] |
Average engine speed in the current simulation interval. Used for interpolation of the engine’s fuel consumption |
| T_eng_fcmap |
[Nm] |
Engine torque used for interpolation of the engine’s fuel consumption. T_eng_fcmap is the sum of torque demand on the output shaft, torque demand of the auxiliaries, and engine’s inertia torque |
| Tq_full |
[Nm] |
Engine’s transient maximum torque (see transient full load) |
| Tq_drag |
[Nm] |
Engine’s drag torque, interpolated from the full-load curve |
| P_eng_fcmap |
[kW] |
Total power the engine has to provide, computed from n_eng_avg and T_eng_fcmap |
| P_eng_full |
[kW] |
Engine’s transient maximum power (see transient full load) |
| P_eng_drag |
[kW] |
Engine’s drag power |
| P_eng_inertia |
[kW] |
Power loss/gain due to the engine’s inertia |
| P_eng_out |
[kW] |
Power provided at the engine’s output shaft |
| P_clutch_loss |
[kW] |
Power loss in the clutch due to slipping when driving off |
| P_clutch_out |
[kW] |
Power at the clutch’s out shaft. P_clutch_out = P_eng_out - P_clutch_loss |
| P_aux |
[kW] |
Total power demand by the auxiliaries |
| P_gbx_in |
[kW] |
Power at the gearbox’ input shaft |
| P_gbx_loss |
[kW] |
Power loss at the gerbox, interpolated from the loss-map |
| P_gbx_inertia |
[kW] |
Power loss due to the gearbox’ inertia |
| P_ret_in |
[kW] |
Power at the retarder’s input shaft. P_ret_in = P_gbx_in - P_gbx_loss - P_gbx_inertia |
| P_ret_loss |
[kW] |
Power loss at the retarder, interpolated from the loss-map |
| P_axle_in |
[kW] |
Power at the axle-gear input shaft. P_axle_in = P_ret_in - P_ret_loss |
| P_axle_loss |
[kW] |
Power loss at the axle gear, interpolated from the loss-map |
| P_brake_in |
[kW] |
Power at the brake input shaft (definition: serially mounted into the drive train between wheels and axle). P_brake_in = P_axle_in - P_axle_loss |
| P_brake_loss |
[kW] |
Power loss due to braking |
| P_wheel_in |
[kW] |
Power at the driven wheels. P_wheel_in = P_brake_in - P_brake_loss |
| P_wheel_inertia |
[kW] |
Power loss due to the wheels’ inertia |
| P_trac |
[kW] |
Vehicle’s traction power. P_trac = P_wheel_in - P_wheel_inertia |
| P_slope |
[kW] |
Power loss/gain due to the road’s slope |
| P_air |
[kW] |
Power loss due to air drag |
| P_roll |
[kW] |
Rolling resistance power loss |
| P_veh_inertia |
[kW] |
Power loss due to the vehicle’s inertia |
| FC-Map |
[g/h] |
Fuel consumption interpolated from FC map. |
| FC-AUXc |
[g/h] |
Fuel consumption after Auxiliary-Start/Stop Correction (based on FC) |
| FC-WHTCc |
[g/h] |
Fuel consumption after WHTC Correction (based on FC-AUXc) |
Summary Results (.vsum)
The .vsum file includes total / average results for each calculation run in one execution (ie. click of START Button). The file is located in the directory of the fist run .vecto file.
Quantities:
| Job |
[-] |
Job number in the format “X-Y” (with X as filenumber, and Y as cycle number) |
| Input File |
[-] |
Name of the input job file (.vecto) |
| Cycle |
[-] |
Name of the cycle file (or cycle name in declaration mode) |
| Mass |
[kg] |
Vehicle mass (Curb Weight Vehicle + Curb Weight Extra Trailer/Body, see Vehicle Editor) |
| Loading |
[kg] |
Vehicle loading (see Vehicle Editor) |
| Status |
[-] |
The result status of the run (Success, Aborted) |
| time |
[s] |
Total simulation time |
| distance |
[km] |
Total traveled distance |
| speed |
[km/h] |
Average vehicle speed |
| altitudeDelta |
[m] |
Altitude difference between start and end of cycle |
| FC-Map |
[g/h], [g/km] |
Average fuel consumption before all corrections, interpolated from Fuel Map, based on torque and engine speed. |
| FC-AUXc |
[g/h], [g/km] |
Average fuel consumption after Auxiliary-Start/Stop Correction (Based on FC-Map) |
| FC-WHTCc |
[g/h], [g/km] |
Average fuel consumption after WHTC Correction (Based on FC-AUXc) |
| FC-AAUX |
[g/h], [g/km] |
Average fuel consumption after Smart Auxiliary Correction (still in development) (Based on FC-WHTCc) |
| FC-Final |
[g/h], [g/km], [l/100km], [l/100tkm] |
Final average fuel consumption after ALL corrections. Value for calculation of CO2 value. Output for [l/100tkm] is empty when Loading = 0[kg]. |
| CO2 |
[g/km], [g/tkm] |
Average CO2 emissions (based on FC-Final value). Output for [l/100tkm] is empty when Loading = 0[kg]. |
| P_wheel_in_pos |
[kW] |
Average positive power at the wheels |
| P_brake_loss |
[kW] |
Average brake power losses (not including engine drag) |
| P_eng_out_pos |
[kW] |
Average positive engine power (all non-negative values averaged over the whole cycle duration) |
| P_eng_out_neg |
[kW] |
Average negative engine power (all non-positive values averaged over the whole cycle duration) |
| E_aux_xxx |
[kWh] |
Total energy demand of auxiliary with ID xxx. See also Aux Dialog and Driving Cycle. In Declaration Mode the following auxiliaries always exists: E_aux_FAN (Fan), E_aux_PS (Pneumatic System), E_aux_STP (Steering Pump), E_aux_ES (Electrical System), E_aux_AC (Air Condition) |
| E_aux_sum |
[kWh] |
Total energy demand of all auxiliaries |
| E_air |
[kWh] |
Total work of air resistance |
| E_roll |
[kWh] |
Total work of rolling resistance |
| E_grad |
[kWh] |
Total work of gradient resistance |
| E_inertia |
[kWh] |
Total work of gearbox and engine inertia |
| E_brake |
[kWh] |
Total work dissipated in mechanical braking (sum of service brakes, retader and additional engine exhaust brakes) |
| E_gbx_axl_loss |
[kWh] |
Total transmission energy losses at gearbox and axlegear |
| E_ret_loss |
[kWh] |
Total retarder energy loss |
| E_tc_loss |
[kWh] |
Total torque converter energy loss |
| E_eng_out_pos |
[kWh] |
Total positive engine work |
| E_eng_out_neg |
[kWh] |
Total negative engine work (engine drag) |
| a |
[m/s2] |
Average acceleration |
| a_pos |
[m/s2] |
Average acceleration in acceleration phases (a3s > 0.125 [m/s2], a3s = 3-seconds-averaged acceleration) |
| a_neg |
[m/s2] |
Average deceleration in deceleration phases (a3s < 0.125 [m/s2], a3s = 3-seconds-averaged acceleration) |
| AccelerationTimeShare |
[%] |
Time share of acceleration phases (a3s > 0.125 [m/s2], a3s = 3-seconds-averaged acceleration) |
| DecelerationTimeShare |
[%] |
Time share of deceleration phases (a3s < 0.125 [m/s2], a3s = 3-seconds-averaged acceleration) |
| CruiseTimeShare |
[%] |
Time share of cruise phases (-0.125 ≤ a3s ≤ 0.125 [m/s2]) |
| StopTimeShare |
[%] |
Time share of stop phases (v < 0.1 [m/s]) |
Application Files
VECTO uses a numbers of files to save GUI settings and file lists. All files are text-based and can be changed outside of VECTO if VECTO is not running.
Settings.json
This file is located in VECTO’s config folder. Here all parameters of the Settings Dialog are saved. The file uses the JSON format.
Job / Cycle lists
The job and cycle lists in the Main Form are saved in the joblist.txt / cyclelist.txt files of the config folder.
Both files save the full file paths separated by line breaks. Additionally it is saved whether each file’s checkbox is checked or not. “?1” after a file path means the file is checked (otherwise “?0”). However, this information can be omitted in which case the file will be loaded in checked state.
LOG.txt
The tabulator-separated log file saves all messages of the Main Form’s Message List and is located in VECTO’s program directory. The file is restarted whenever the Logfile Size Limit is reached.One backup is always stored as LOG_backup.txt.
License file
The license file license.dat is located in VECTO’s program directory. Without a valid lisence file VECTO won’t run.
It no valid license file is provided with your VECTO version please contact vecto@jrc.ec.europa.eu.
All
Add files to Job List
Remove selected files from List
Move selected files up or down in list
START Button
New Job File
Open existing Job or Input File
Tools
Help
button.
Save and close dialog
Close without saving
Save current Job File
Save Job File as…
Send current file to Job List in 
Open 
Open 
Open 
Browse for vehicle/engine/gearbox files
Open a new Graph Window
Reload the currently open file
