MODULAR FUEL SYSTEM INFORMATION

At its most basic the Modular Fuel System can be thought of as a series of "components" connected by "lines", with the simplest setup being a tank, a fuel line, and an engine. However you can create far more complex fuel system definitions that include multiple components like pumps, junctions, valves, etc... and multiple line connections between them. The system is also dynamic and can be set to respond to certain "trigger" conditions. For example, should a tank become empty, you can trigger an event to close the valve to that tank and open the valve to another tank.

NOTE: You can only connect components to lines and lines to components... You cannot connect two components or two lines together. Also note that the ONLY components that can take more than 2 lines are the Tanks and Junctions.

These different parts of the system are all setup using the appropriate values within the hash maps required by each of the parameters listed here.

IMPORTANT: Connections between the different components are made using the "Name" key in the various hash maps that are associated with each parameter, and so you should try and ensure a clear and consistent naming methodology to help keep the way that the different components connect as clear as possible.

Burner.N

This parameter is used to define one or more burner consumers for a balloon SimObject. If this is included then you must also have a corresponding Burner.N setup in the [Burner_System] section, since that section defines the actual burner, and this section simply defines the way that the burner consumes the fuel.

IMPORTANT! Burners require that the fuel_type be set to 6 (Liquid Propane).

A burner is defined as a hash map comprised of multiple key:value pairs - separated by the # symbol - and has the following structure:

Burner.N = Name:<Burner_name> #Index:<Burner_Index>

Note that you may have more than one Burner, in which case you would increment the N index, starting from 1. A typical example of a single Burner definition would be like this:

Burner.1 = Name:BurnerOne #Index:1

APU.N

This parameter is used to define one or more APU components to be used in the fuel system. This APU is defined as a hash map comprised of multiple key:value pairs - separated by the # symbol - and has the following structure:

APU.N = Name:<apu_name> #Title:<apu_title> #FuelBurnRate:<burn_rate>

Note that you may have more than one APU, in which case you would increment the N index, starting from 1. A typical example of a single APU definition would be like this:

APU.1 = Name:MainAPU #FuelBurnRate:33

Engine.N

This parameter is used to define one or more engine components to be used in the fuel system. This engine is defined as a hash map comprised of multiple key:value pairs - separated by the # symbol - and has the following structure:

Engine.N = Name:<engine_name> # Title:<engine_title> # Index:<engine_index>

Note that you may have more than one engine, in which case you would increment the N index, starting from 1 and up to a maximum of 4. A typical example for defining engines would look like this:

Engine.1 = Name:LeftEngine#Index:1
Engine.2 = Name:RightEngine#Index:2

The following SimVar is available for this component:

1. FUELSYSTEM_ENGINE_PRESSURE

Tank.N

This parameter is used to define one or more fuel tank components to be used in the fuel system. This tank is defined as a hash map comprised of multiple key:value pairs - separated by the # symbol - and has the following structure:

Tank.N = Name:<tank_name> #Title:<tank_title> #Capacity:<tank_capacity> #UnusableCapacity:tank_unusable_capacity> #Position:<Z>,<X>,<Y> #InputOnlyLines:<line1_name>,<line2_name>,<etc...> #OutputOnlyLines:<line1_name>,<line2_name>,<etc...> #DropTimer:<tank_timer> #Priority:<tank_priority> #WearAndTearCollision:<damage_profile_name1>,<damage_profile_name2>,<etc...>

Note that you may have more than one fuel tanks, in which case you would increment the N index, starting from 1. Also note that tanks can have more than one line coming in or going out (unlike all other components except junctions).

A typical example of a single tank definition would be like this:

Tank.1 = Name:LeftWing #Capacity:20 #UnusableCapacity:0 #Position:-1.6,-3,-1.5 #Priority:1 #WearAndTearCollision:LeftWingHeavy

volume:psi, volume:psi, volume:psi, etc...

The following SimVars are available for this component:

1. FUELSYSTEM_TANK_CAPACITY
2. FUELSYSTEM_TANK_LEVEL
3. FUELSYSTEM_TANK_QUANTITY
4. FUELSYSTEM_TANK_TOTAL_QUANTITY
5. FUELSYSTEM_TANK_WEIGHT

Line.N

This parameter is used to define one or more fuel lines to be used in the fuel system. This line is defined as a hash map comprised of multiple key:value pairs - separated by the # symbol - and has the following structure:

Line.N = Name:<line_name> #Title:<line_title> #Source:<source_name> #Destination:<destination_name> #FuelFlowAt1PSI:<psi_value> #Volume:<volume_value> #GravityBasedFuelFlow:<gravity_flow_value>

Note that you may have more than one fuel line, in which case you would increment the N index, starting from 1. A typical example of a single line definition would be like this:

Line.1 = Name:TankRightToRightTankPump1 #Source:RightInner #Destination:RightInnerTankPump1

The following SimVars are available for this component:

1. FUELSYSTEM_LINE_FUEL_FLOW
2. FUELSYSTEM_LINE_FUEL_LEVEL
3. FUELSYSTEM_LINE_FUEL_PRESSURE

Junction.N

This parameter is used to define one or more junction components to be used in the fuel system. This junction is defined as a hash map comprised of multiple key:value pairs - separated by the # symbol - and has the following structure:

Junction.N = Name:<junction_name> #Title:<title> #Option:<option>,<option>,<etc> #InputOnlyLines:<line>,<line>,<etc> #OutputOnlyLines:<line>,<line>,<etc>

Note that you may have more than one junction, in which case you would increment the N index, starting from 1. Also note that junctions can have more than one line coming in or going out (unlike all other components except tanks).

A typical example of a single junction definition would be like this:

Junction.1 = Name:FuelSelector #InputOnlyLines:LeftInnerToFuelSelector,RightInnerToFuelSelector #OutputOnlyLines:FuelSelectorToPumpsJunction #Option:LeftInnerToFuelSelector,FuelSelectorToPumpsJunction #Option:RightInnerToFuelSelector,FuelSelectorToPumpsJunction #Option:CenterAftToFuelSelector,FuelSelectorToPumpsJunction #Option:FuelSelectorToPumpsJunction

The following SimVar is available for this component:

1. FUELSYSTEM_JUNCTION_SETTING

The following key Event is also available:

1. FUELSYSTEM_JUNCTION_SET

Valve.N

This parameter is used to define one or more valve components to be used in the fuel system. This valve is defined as a hash map comprised of multiple key:value pairs - separated by the # symbol - and has the following structure:

Valve.N = Name:<valve_name> #Title:<valve_title> #DestinationLine:<destination_name> #OpeningTime:<time_value> #Circuit:<circuit_index>

Note that you may have more than one valve, in which case you would increment the N index, starting from 1. A typical example of a single valve definition would be like this:

Valve.1 = Name:LeftEngineValve #OpeningTime:3 #Circuit:1

circuit.15 = Type:CIRCUIT_FUEL_VALVE:4
#Connections:bus.2
#Power:3,5,20
#Name:Fuel_P_R2

Valve.2 = Name:Right2Valve
#OpeningTime:3
#Circuit:4

The following SimVars are available for this component:

1. FUELSYSTEM_VALVE_OPEN
2. FUELSYSTEM_VALVE_SWITCH

The following key Events are also available:

1. FUELSYSTEM_VALVE_CLOSE
2. FUELSYSTEM_VALVE_OPEN
3. FUELSYSTEM_VALVE_SET
4. FUELSYSTEM_VALVE_TOGGLE

Pump.N

This parameter is used to define one or more fuel pump components to be used in the fuel system. This pump is defined as a hash map comprised of multiple key:value pairs - separated by the # symbol - and has the following structure:

Pump.N = Name:<pump_name> #Title:<pump_title> #Pressure:<pressure_value> #PressureCurve:<curve_index> #TankFuelRequired:<tank_name> #DestinationLine:<line_name> #Type:<type_string> #index:<value> #AutoCondition:<engine_psi_threshold> #PressureDecreaseRate:<decrease_value>

Note that you may have more than one fuel pump, in which case you would increment the N index, starting from 1. A typical example of a single pump definition would be like this:

Pump.1 = Name:HandPump #Pressure:6 #DestinationLine:HandPumpToHandPumpValve #Type:Manual #PressureDecreaseRate:0.05

The following SimVars are available for this component:

1. FUELSYSTEM_PUMP_ACTIVE
2. FUELSYSTEM_PUMP_SWITCH

The following key Events are also available:

1. FUELSYSTEM_PUMP_OFF
2. FUELSYSTEM_PUMP_ON
3. FUELSYSTEM_PUMP_SET
4. FUELSYSTEM_PUMP_TOGGLE

Trigger.N

This parameter is used to define one or more triggers to be used in the fuel system. Triggers are used to listen for - and react to - specific conditions and events that will affect the way the fuel system operates. Triggers are defined as a hash map comprised of multiple key:value pairs - separated by the # symbol - and have the following structure:

Trigger.N = Name:<trigger_name> #Title:<trigger_title> #Target:<target_name> #Threshold:<value> #Index:<target_index> #DelayTrue:<seconds_value> #DelayFalse:<seconds_value> #Condition:<string> #EffectTrue:<effect_list> #EffectFalse:<effect_list> #iParam:<param>

Note that you may have more than one trigger, in which case you would increment the N index, starting from 1. A basic example of a single trigger definition would be like this:

Trigger.1 = Condition:Autostart_Enabled #EffectTrue:OpenValve.LeftEngValve, OpenValve.RightEngValve, OpenValve.CrossFeedValve, StartPump.LeftTankPump, StartPump.RightTankPump

The following SimVar is available for this component:

1. FUELSYSTEM_TRIGGER_STATUS

The following key Events are also available:

1. FUELSYSTEM_TRIGGER_OFF
2. FUELSYSTEM_TRIGGER_ON
3. FUELSYSTEM_TRIGGER_SET
4. FUELSYSTEM_TRIGGER_TOGGLE

Trigger Conditions And Events

When creating triggers for the fuel system, the hash map has an entry for "Condition". This can be any one of the following strings:

The result of the condition can be checked as either TRUE or FALSE, triggering an "event". These events are defined as a comma separated list in the EffectTrue and EffectFalse keys of the trigger hash map, where each entry in the list is comprised of an event and a target component, for example:

#EffectTrue:<event>.<target_name>, <event>.<target_name>, etc...

The available event types are:

Curve.N

The curve parameter is defined as a list of paired values, and the parameter is appended with a number that corresponds to its unique id (starting at 1). The exact number of paired values that are in the curve will depend on the use the curve is going to get, since curves are used by other parameters to store information. For example, you may have defined a fuel pump like this:

Pump.2 = Name:EngineDrivenPump #Pressure:6 #PressureCurve:1 #DestinationLine:EngineDrivenPumpToEngineJunction #Type:EngineDriven #Index:1

In this case, PressureCurve:1 references a fuel pressure curve table that would have been defined like this:

Curve.1 = 0:0, 0.2:0.5, 0.62:0.62, 0.88:0.63, 0.98:0.66, 1.0:1.0