greet

package
v1.7.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 14, 2020 License: GPL-3.0 Imports: 17 Imported by: 0

Documentation

Index

Constants

View Source 
const DefaultNonCombustionSCC slca.SCC = "0028888801" // TODO: Perhaps figure out a way to do better.

DefaultNonCombustionSCC is used for everything we don't have an SCC for.

Variables

View Source 
var DebugLevel = 0

DebugLevel sets the amount of debugging output that is written to the console. Higher numbers lead to more output.

Functions

func GetEmissionFactor 

func GetEmissionFactor(emissions []*Emission, i int, fuel *Resource,
	db *DB) *unit.Unit

GetEmissionFactor returns the emissions factor for emission corresponding to index i in emissions. fuel is used to calculate some emissions factors based on fuel properties. It should be safe to pass a nil value for fuel for non-combustion emissions.

Types

type BasicParameters 

type BasicParameters struct {
	YearSelected Expression `xml:"year_selected,attr"`
	LHV          bool       `xml:"lhv,attr"`
}

BasicParameters holds the GREET database basic parameters.

type Compatibility 

type Compatibility struct {
	MatID ResourceID `xml:"mat_id,attr"`
}

Compatibility gives another resource this resource is compatible with.

type Coproduct 

type Coproduct struct {
	ID                   slca.OutputID `xml:"id,attr"`
	Ref                  ResourceID    `xml:"ref,attr"`
	AmountYears          []*ValueYear  `xml:"amount>year"`
	Method               string        `xml:"method,attr"` // either "allocation" or "displacement"
	ConventionalProducts []*Product    `xml:"conventional_products>product"`
}

Coproduct is a holder for information about a single coproduct.

func (*Coproduct) CalcAllocationAmount 

func (cp *Coproduct) CalcAllocationAmount(outputUnits unit.Dimensions,
	AllocationMethod string, db *DB) *unit.Unit

CalcAllocationAmount calculates the amount of this coproduct to be used when allocating resource use and emissions. If AllocationMethod is "", it allocates all emissions to the main output and none to the coproducts.

func (*Coproduct) GetAmount 

func (cp *Coproduct) GetAmount(db *DB) *unit.Unit

GetAmount returns the amount of this coproduct that is produced.

func (*Coproduct) GetAmountBeforeLoss 

func (cp *Coproduct) GetAmountBeforeLoss(db *DB) *unit.Unit

GetAmountBeforeLoss calculates the amount of this coproduct is produced. Because coproducts do not have losses, it gives the same result as GetAmount().

func (*Coproduct) GetID 

func (cp *Coproduct) GetID() slca.OutputID

GetID returns the ID of this coproduct.

func (*Coproduct) GetLossEmissions 

func (cp *Coproduct) GetLossEmissions(_ *DB) ([]*Gas, []*unit.Unit)

GetLossEmissions is required to fulfill the OutputLike interface, but coproducts don't have any loss emissions.

func (*Coproduct) GetName 

func (cp *Coproduct) GetName(db *DB) string

GetName gets the name associated with the resource produced by this coproduct.

func (*Coproduct) GetProcess 

func (cp *Coproduct) GetProcess(path *Pathway, db *DB) slca.Process

GetProcess returns the process associated with this Coproduct.

func (*Coproduct) GetResource 

func (cp *Coproduct) GetResource(db slca.LCADB) slca.Resource

GetResource returns the resource associated with this coproduct.

func (*Coproduct) IsCoproduct 

func (cp *Coproduct) IsCoproduct() bool

IsCoproduct is for implementing the OutputLike interface and is always true.

type Coproducts 

type Coproducts struct {
	// Either "Mass", "Energy", "Market", "Volume" or ""
	AllocationMethod string `xml:"allocation_method,attr"`

	Coprods []*Coproduct `xml:"coproduct"`
}

Coproducts is a holder for data about the coproducts of a process and how to deal with them.

func (*Coproducts) Displacement 

func (cps *Coproducts) Displacement(r *slca.OnsiteResults, db *DB)

Displacement calculates the amounts of different processes that are displaced by this process. The results are returned as negative numbers.

type DB 

type DB struct {
	Version         string           `xml:"version,attr"`
	BasicParameters *BasicParameters `xml:"basic_parameters"`
	Data            *Data            `xml:"data"`

	// SpatialSCCs are all the SCC codes used by this database
	// for spatialization. SCC codes that are not
	// used for spatialization are not included here.
	SpatialSCC []slca.SCC
	// contains filtered or unexported fields
}

DB is a holder for the GREET database.

func Load 

func Load(dbFile io.Reader) *DB

Load loads the GREET database from an XML file.

func (*DB) AddSCCs 

func (db *DB) AddSCCs(stationaryProcessFile, vehicleFile, technologyFile io.Reader) error

AddSCCs adds SCC codes to the greet database by matching information in sscFile.

func (*DB) EditByID 

func (db *DB) EditByID(changes *DB)

EditByID makes changes to db as specified by "changes". Edits are made by matching ID numbers in db and changes. Only existing objects can be edited. This function has not been exhaustively tested, so use at your own risk.

func (*DB) EditExpressionByID 

func (db *DB) EditExpressionByID(ID string, newValue float64) error

EditExpressionByID finds the expression with an ID matching "ID" and sets the value to newValue. It returns an error if "ID" is not found or if there is more than one expression matching "ID" in the database.

func (*DB) EndUseFromID 

func (db *DB) EndUseFromID(ID string) (slca.Pathway, error)

EndUseFromID returns the pathway mix, or vehicle with the given id.

func (*DB) EndUses 

func (db *DB) EndUses() ([]slca.Pathway, []string)

EndUses returns information about the pathways, mixes, and vehicles in this database.

func (*DB) GetGas 

func (db *DB) GetGas(name string) (*Gas, error)

GetGas returns the gas in the database with the specified name. It returns an error if there is no match.

func (*DB) GetMix 

func (db *DB) GetMix(ID ModelID) *Mix

GetMix returns the Mix with the given ID.

func (*DB) GetPathway 

func (db *DB) GetPathway(ID ModelID) *Pathway

GetPathway returns the pathway with the given id.

func (*DB) GetPathwayMixOrVehicleFromName 

func (db *DB) GetPathwayMixOrVehicleFromName(name string) (slca.Pathway, error)

GetPathwayMixOrVehicleFromName returns the pathway, mix, or vehicle with the given name.

func (*DB) GetResource 

func (db *DB) GetResource(id ResourceID, requester interface{}) *Resource

GetResource returns the resource with the specified ID. The requester input is only used for debugging if the resource is not found.

func (*DB) GetResourceFromName 

func (db *DB) GetResourceFromName(name string) *Resource

GetResourceFromName returns the resource with the specified name.

func (*DB) GetResultVars 

func (db *DB) GetResultVars() (ids, names []string)

GetResultVars returns the gases and resources that can be considered as model result types.

func (*DB) GetVariableValue 

func (db *DB) GetVariableValue(varName string) *unit.Unit

GetVariableValue finds the desired variable in the database, evaluates it, and returns the result.

func (*DB) GetVehicleFromID 

func (db *DB) GetVehicleFromID(ID ModelID) *Vehicle

GetVehicleFromID finds the vehicle in the database with the matching ID.

func (*DB) GetVehicleFromName 

func (db *DB) GetVehicleFromName(name string) *Vehicle

GetVehicleFromName finds the vehicle in the database with the matching ID.

func (*DB) GetYear 

func (db *DB) GetYear() float64

GetYear returns the analysis year for this database.

func (*DB) InterpolateValue 

func (db *DB) InterpolateValue(y []*ValueYear) *unit.Unit

InterpolateValue returns the value associated with the year set in the GREET database, interpolating if necessary.

func (*DB) InterpolateValueWithLag 

func (db *DB) InterpolateValueWithLag(y []*ValueYear, lag float64) *unit.Unit

InterpolateValueWithLag returns the value associated with the year set in the GREET database minus the specified lag (in years), interpolating if necessary.

func (*DB) SpatialSCCs 

func (db *DB) SpatialSCCs() []slca.SCC

SpatialSCCs returns all of the SCC codes used by this database for spatialization.

func (*DB) Write 

func (db *DB) Write(w io.Writer) (int, error)

Write writes out a database to w in indented XML format.

type Data 

type Data struct {
	Pathways                []*Pathway               `xml:"pathways>pathway"`
	ResourceGroups          []*ResourceGroup         `xml:"resources>groups>group"`
	Resources               []*Resource              `xml:"resources>resources>resource"`
	TransportationProcesses []*TransportationProcess `xml:"processes>transportation"`
	StationaryProcesses     []*StationaryProcess     `xml:"processes>stationary"`
	Technologies            []*Technology            `xml:"technologies>technology"`
	Modes                   []*Mode                  `xml:"modes>mode"`
	Locations               Locations                `xml:"locations"`
	GasGroups               []*GasGroup              `xml:"gases>groups>group"`
	Gases                   []*Gas                   `xml:"gases>gases>gas"`

	// VehicleTechnologyLag gives the lag in years between the current year
	// and the vehicle model year.
	VehicleTechnologyLag struct {
		Value Expression `xml:"value,attr"`
	} `xml:"vehicles>vehicle_technology_lag"`

	Vehicles    []*Vehicle    `xml:"vehicles>vehicle"`
	Mixes       []*Mix        `xml:"mixes>mix"`
	InputTables []*InputTable `xml:"inputs>input"`
}

Data is a holder for the LCA data within the GREET database.

type Edge 

type Edge struct {
	// The OutputVertexID references a vertex in the current Pathway.
	// It is the upstream vertex.
	OutputVertexID VertexID `xml:"output-vertex,attr"`

	// Output ID references an output. The actual location of the output
	// should be in a process or another pathway.
	OutputID slca.OutputID `xml:"output-id,attr"`

	// InputVertexID either references a vertex in the current pathway
	// (the downstream vertex), or it matches the ID of one of the outputs
	// from the pathway. If it matches a pathway output, then it means
	// that this edge is to a pathway output rather than another vertex.
	InputVertexID VertexID `xml:"input-vertex,attr"`

	// InputID either matches one of the inputs in the process associated
	// with InputVertexID, or it matches one of the pathway output IDs.
	// If it matches a pathway output, then it means
	// that this edge is to a pathway output rather than another vertex.
	InputID InputID `xml:"input-id,attr"`
}

An Edge connects two vertices in a pathway or one vertex in a pathway to a pathway output.

func (*Edge) GetInputVertex 

func (e *Edge) GetInputVertex(db *DB) *Vertex

GetInputVertex gets the input vertex for this edge.

func (*Edge) GetOutputVertex 

func (e *Edge) GetOutputVertex(db *DB) *Vertex

GetOutputVertex gets the output vertex for this edge.

type Emission 

type Emission struct {
	Ref        GasID      `xml:"ref,attr"`
	Factor     Expression `xml:"factor,attr"`
	Amount     Expression `xml:"amount,attr"`
	Calculated bool       `xml:"calculated,attr"`
}

Emission is a holder for emissions data in the GREET database.

func (*Emission) GetGas 

func (e *Emission) GetGas(db *DB) *Gas

GetGas returns the gas associated with this emission

type EmissionRatio 

type EmissionRatio struct {
	GasID GasID `xml:"gas_id,attr"`
	Rate  Param `xml:"rate"`
}

An EmissionRatio specifies the fraction of the total mass of an input that is emitted as a certain gas.

type EmissionYear 

type EmissionYear struct {
	Year      string      `xml:"value,attr"`
	Emissions []*Emission `xml:"emission"`
}

EmissionYear is a holder for emissions information for a specific year in the GREET database.

func (*EmissionYear) GetYear 

func (e *EmissionYear) GetYear() float64

GetYear converts the year of this emission from string to float format.

type EnergyIntensity 

type EnergyIntensity struct {
	EnergyIntensity Param      `xml:"ei"`
	Ref             ResourceID `xml:"ref,attr"`
	Name            string     `xml:"name,attr"`
}

EnergyIntensity specifies the energy intensity of a Mode. Only used for rail.

type EvaporationShare 

type EvaporationShare struct {
	Ref   GasID      `xml:"ref,attr"`
	Share Expression `xml:"share,attr"`
}

EvaporationShare gives the fraction of a given resource that evaporates as a given gas.

type Expression 

type Expression string

Expression is an expression that can be evaluated

type Fuel 

type Fuel struct {
	FuelRef    ResourceID   `xml:"fuel_ref,attr"`
	Pathway    ModelID      `xml:"pathway,attr"`
	Mix        ModelID      `xml:"mix,attr"`
	ShareStr   Expression   `xml:"share,attr"`
	TechToID   TechnologyID `xml:"tech_to,attr"`
	TechFromID TechnologyID `xml:"tech_from,attr"`
}

Fuel specifies a type of fuel used by a Mode.

func (*Fuel) GetFuel 

func (f *Fuel) GetFuel(db *DB) *Resource

GetFuel returns the fuel that is being provided.

func (*Fuel) GetPathway 

func (f *Fuel) GetPathway(db *DB) (slca.Process, *Pathway)

GetPathway returns the pathway or mix that provides the fuel.

func (*Fuel) GetShare 

func (f *Fuel) GetShare(db *DB) *unit.Unit

GetShare returns the fraction of use of this fuel.

func (*Fuel) GetTechFrom 

func (f *Fuel) GetTechFrom(db *DB) *Technology

GetTechFrom returns the technology that is providing inbound transportation

func (*Fuel) GetTechTo 

func (f *Fuel) GetTechTo(db *DB) *Technology

GetTechTo returns the technology that is providing outbound transportation

type FuelShare 

type FuelShare struct {
	Name  string      `xml:"name,attr"`
	ID    FuelShareID `xml:"id,attr"`
	Fuels []*Fuel     `xml:"fuel"`
}

FuelShare gives information on the different fuels used by a Mode.

type FuelShareID 

type FuelShareID string

FuelShareID holds the ID code for a FuelShare

type Gas 

type Gas struct {
	Ref                    string        `xml:"ref,attr"`
	Share                  string        `xml:"share,attr"`
	Name                   string        `xml:"name,attr"`
	ID                     GasID         `xml:"id,attr"`
	CRatio                 Expression    `xml:"c_ratio,attr"` // mass ratio
	SRatio                 Expression    `xml:"s_ratio,attr"` // mass ratio
	GlobalWarmingPotential string        `xml:"global_warming_potential,attr"`
	Membership             []*Membership `xml:"membership"`
}

Gas is a holder for emissions types in the GREET database.

func (*Gas) GetCRatio 

func (g *Gas) GetCRatio(db *DB) *unit.Unit

GetCRatio returns the fraction carbon in this gas.

func (*Gas) GetID 

func (g *Gas) GetID() string

GetID returns the ID number for this gas

func (*Gas) GetName 

func (g *Gas) GetName() string

GetName returns the gas name.

func (*Gas) GetSRatio 

func (g *Gas) GetSRatio(db *DB) *unit.Unit

GetSRatio returns the fraction sulfur in this gas.

type GasGroup 

type GasGroup struct {
	ID   string `xml:"id,attr"`
	Name string `xml:"name,attr"`
}

GasGroup is a holder for gas grouping information in the GREET database.

type GasID 

type GasID string

GasID holds the ID code for a gas

type Guid 

type Guid string

Guid is a globally unique ID

type IOCarbonInput 

type IOCarbonInput struct {
	ID    InputID `xml:"id,attr"`
	Ratio float64 `xml:"ratio,attr"`
}

IOCarbonInput is a holder for the fraction biogenic vs. fossil carbon.

type IOCarbonMap 

type IOCarbonMap struct {
	Outputs []*IOCarbonOutput `xml:"output"`
}

IOCarbonMap is a holder for information about biogenic and fossil carbon

type IOCarbonOutput 

type IOCarbonOutput struct {
	ID     slca.OutputID  `xml:"id,attr"`
	Inputs *IOCarbonInput `xml:"input"`
}

IOCarbonOutput is a holder for information about biogenic and fossil carbon

type Input 

type Input struct {
	ID InputID `xml:"id,attr"`

	// The Source of the input. Should either be Previous, Mix, Well, or Pathway.
	Source string `xml:"source,attr"`

	// The mix that is the source of this input if Source = "Mix"
	Mix ModelID `xml:"mix,attr"`

	// The pathway that is the source of this input if Source = "Pathway".
	Pathway ModelID `xml:"pathway,attr"`

	// Is this considered the main input?
	ConsideredAsMain bool `xml:"considered_as_main,attr"`

	// Whether requirements and resource use are counted in this input. If "False",
	// only count emissions.
	AccountedInEnergyBalance string `xml:"accounted_in_energy_balance,attr"`

	// The resource that is input.
	Ref ResourceID `xml:"ref,attr"`

	// The share of this input. Used in input groups.
	Share Param `xml:"share"`

	// Technologies that use this input as a fuel source or operate on it.
	TechnologyShares []*TechnologyShare `xml:"technology"`

	// The amount of this input. Used in non-grouped inputs.
	AmountYears []*ValueYear `xml:"amount>year"`

	// EmissionRatios specify fractions of the total mass of the input that
	// are emitted as different gases.
	EmissionRatios []EmissionRatio `xml:"emission_ratio"`
}

Input is a holder for the GREET Input data type.

func (*Input) EmissionsAndResourceUse 

func (in *Input) EmissionsAndResourceUse(r *slca.OnsiteResults, proc slca.Process,
	path *Pathway, noncombustion subprocess, db *DB)

EmissionsAndResourceUse calculates emissions caused and resources used by this input.

func (*Input) GetAmount 

func (in *Input) GetAmount(db *DB) *unit.Unit

GetAmount gets the amount of this input.

func (*Input) GetAmountDefaultUnits 

func (in *Input) GetAmountDefaultUnits(db *DB) *unit.Unit

GetAmountDefaultUnits gets the amount of this input in the default units for the input resource.

func (*Input) GetEmissionRatios 

func (in *Input) GetEmissionRatios(db *DB) ([]*Gas, []*unit.Unit)

GetEmissionRatios returns the emission ratios associated with this input.

func (*Input) GetResource 

func (in *Input) GetResource(db *DB) *Resource

GetResource gets the resource associated with this input.

func (*Input) GetShare 

func (in *Input) GetShare(db *DB) *unit.Unit

GetShare returns the share of this input (usually as part of an input group).

func (*Input) GetSource 

func (in *Input) GetSource(path *Pathway, db *DB) (slca.Process, *Pathway)

GetSource gets the source of the current input. It return the upstream process and the upstream pathway.

type InputColumn 

type InputColumn struct {
	Name       string      `xml:"name,attr"`
	ID         string      `xml:"id,attr"`
	Parameters []Parameter `xml:"param"`
}

InputColumn is a holder for a GREET input data table column.

type InputGroup 

type InputGroup struct {
	Type        string       `xml:"type,attr"` // This should be "efficiency" or "amount"
	Efficiency  []*ValueYear `xml:"efficiency>year"`
	Amount      []*ValueYear `xml:"amount>year"`
	InputShares []*Input     `xml:"shares>input"`
	Inputs      []*Input     `xml:"input"`
}

InputGroup is a holder for a group of inputs sharing a common efficiency or adding up to a single amount.

func (*InputGroup) EmissionsAndResourceUse 

func (ig *InputGroup) EmissionsAndResourceUse(r *slca.OnsiteResults, proc slca.Process,
	path *Pathway, output OutputLike, noncombustion subprocess, db *DB)

EmissionsAndResourceUse calculates emissions caused and resources used by this input group. The returned value is a pointer and is cached for future use, so be sure to clone the result before modifying it.

type InputID 

type InputID Guid

InputID holds the ID code for an input

type InputTable 

type InputTable struct {
	ID         string        `xml:"id,attr"`
	TabID      string        `xml:"tabid,attr"`
	Notes      string        `xml:"notes,attr"`
	ModifiedOn string        `xml:"modified_on,attr"`
	ModifiedBy string        `xml:"modified_by,attr"`
	Columns    []InputColumn `xml:"column"`
}

InputTable is a holder for a GREET input data table.

type Location 

type Location struct {
	Name       string                `xml:"name,attr"`
	Picture    string                `xml:"picture,attr"`
	ID         LocationID            `xml:"id,attr"`
	Notes      string                `xml:"notes,attr"`
	Membership []*LocationMembership `xml:"membership"`
}

Location holds information about a transportation source or destination location.

type LocationGroup 

type LocationGroup struct {
	Name  string          `xml:"name,attr"`
	ID    LocationGroupID `xml:"id,attr"`
	Notes string          `xml:"notes,attr"`
}

LocationGroup holds information about how different locations can be combined into groups.

type LocationGroupID 

type LocationGroupID string

LocationGroupID holds the ID code for a location group

type LocationID 

type LocationID string

LocationID holds the ID code for a location

type LocationMembership 

type LocationMembership struct {
	GroupID LocationGroupID `xml:"group_id,attr"`
}

LocationMembership gives information about which group a location belongs to.

type Locations 

type Locations struct {
	LocationGroups []LocationGroup `xml:"groups>group"`
	Locations      []*Location     `xml:"location"`
}

Locations is a holder for transportation source and destination locations.

type Membership 

type Membership struct {
	GroupID string `xml:"group_id"`
}

Membership gives a group that a resource is a member of.

type Mix 

type Mix struct {
	sync.RWMutex
	ID                      ModelID        `xml:"id,attr"`
	Name                    string         `xml:"name,attr"`
	UseDefaultValues        bool           `xml:"use_default_values,attr"`
	ShareType               string         `xml:"share_type,attr"` // "energy" or "mass"
	CreatedResource         ResourceID     `xml:"created_resource,attr"`
	PathwayRefs             []*MixPathway  `xml:"pathway"`
	MixRefs                 []*MixResource `xml:"resource"`
	PreferredFunctionalUnit *Unit          `xml:"prefered_functional_unit"`
	Outputs                 []*Output      `xml:"output"`
	// contains filtered or unexported fields
}

Mix is a holder for GREET data about pathway mixes.

func (*Mix) GetID 

func (m *Mix) GetID() ModelID

GetID returns the mix ID

func (*Mix) GetIDStr 

func (m *Mix) GetIDStr() string

GetIDStr returns the mix ID in string form.

func (*Mix) GetMainOutput 

func (m *Mix) GetMainOutput(db slca.LCADB) slca.Output

GetMainOutput returns the main output from this mix.

func (*Mix) GetName 

func (m *Mix) GetName() string

GetName returns the mix name.

func (*Mix) GetOutput 

func (m *Mix) GetOutput(r slca.Resource, db slca.LCADB) slca.Output

GetOutput returns the output of this mix that outputs the requested resource.

func (*Mix) GetOutputProcess 

func (m *Mix) GetOutputProcess(_ *Resource, _ slca.LCADB) slca.Process

GetOutputProcess returns the receiver.

func (*Mix) MainProcessAndOutput 

func (m *Mix) MainProcessAndOutput(db slca.LCADB) (slca.Process, slca.Output)

MainProcessAndOutput returns the process that outputs the main output of the receiver, and also returns that output.

func (*Mix) OnsiteResults 

func (m *Mix) OnsiteResults(_ slca.Pathway, o slca.Output, lcadb slca.LCADB) *slca.OnsiteResults

OnsiteResults is required for a mix to fulfill the slca.Process interface, but pathways don't directly create any emissions. The returned value is a pointer and is cached for future use, so be sure to clone the result before modifying it.

func (*Mix) SpatialRef 

func (m *Mix) SpatialRef(aqm string) *slca.SpatialRef

SpatialRef returns this spatial reference for this mix (which is NoSpatial).

func (*Mix) Type 

func (m *Mix) Type() slca.ProcessType

Type returns the type of the process.

type MixPathway 

type MixPathway struct {
	Ref      string        `xml:"ref,attr"`
	OutputID slca.OutputID `xml:"output,attr"`
	Shares   []*ValueYear  `xml:"shares>year"`
	Notes    string        `xml:"notes,attr"`
}

MixPathway is a holder for the corresponding GREET datatype. It defines the pathways that are upstream of the current mix.

type MixResource 

type MixResource struct {
	Mix    ModelID      `xml:"mix,attr"`
	Shares []*ValueYear `xml:"shares>year"`
	Notes  string       `xml:"notes,attr"`
}

MixResource is a holder for the corresponding GREET datatype. It defines the mixes that are upstream of the current mix.

type Mode 

type Mode struct {
	Name         string `xml:"name,attr"`
	Type         string `xml:"type,attr"`
	ID           ModeID `xml:"id,attr"`
	AverageSpeed Param  `xml:"average_speed"` // [length/time]

	// Load factor is the percentage of installed power that is used for the trip
	LoadFactorFrom Param `xml:"load_factor_from"` // [Dimless]
	LoadFactorTo   Param `xml:"load_factor_to"`   // [Dimless]

	FuelEconomyFrom Param `xml:"fuel_economy_from"`
	FuelEconomyTo   Param `xml:"fuel_economy_to"`

	// TypicalFC is the mass of fuel consumption per unit of output work
	// (Brake specific fuel consumption (BSFC)).
	TypicalFC Param `xml:"typical_fc"` // [mass/energy]

	// TypicalHP is the amount of power required when the vehicle is unloaded.
	TypicalHP Param `xml:"typical_hp"` // [power]

	// HPFactor is the amount of additional power required per unit mass of payload.
	HPFactor Param `xml:"hp_factor"` // [power/mass]

	// EnergyIntensity is energy used per unit distance per unit payload mass. It is only reported
	// directly for the rail mode.
	EnergyIntensity Param `xml:"ei"` // [energy/distance/mass]

	// BSFCAdjustment defines how (brake-specific) fuel consumption varies with
	// varying load factor.
	BSFCAdjustment Param `xml:"bsfc_adjustment"`

	FuelShares []*FuelShare `xml:"fuel_shares>share"`
	Payloads   []*Payload   `xml:"payload>material_transported"`

	// Energy intensity for pipelines
	EnergyIntensities []*EnergyIntensity `xml:"energy_intensity>material_transported"`
}

Mode is a holder for information about a transportation mode.

func (*Mode) CalculateEnergyIntensity 

func (m *Mode) CalculateEnergyIntensity(materialTransported *Resource,
	fuel *Fuel, db *DB) (from, to *unit.Unit)

CalculateEnergyIntensity returns the energy used per unit distance per unit payload mass for this mode, for both the outbound and inbound legs of the journey.

func (*Mode) GetAverageSpeed 

func (m *Mode) GetAverageSpeed(db *DB) *unit.Unit

GetAverageSpeed returns the average speed for this mode.

func (*Mode) GetBSFCAdjustment 

func (m *Mode) GetBSFCAdjustment(db *DB) *unit.Unit

GetBSFCAdjustment returns the brake-specific fuel consumption adjustment factor.

func (*Mode) GetFuelEconomyFrom 

func (m *Mode) GetFuelEconomyFrom(db *DB) *unit.Unit

GetFuelEconomyFrom returns the fuel economy in the from or inbound direction.

func (*Mode) GetFuelEconomyTo 

func (m *Mode) GetFuelEconomyTo(db *DB) *unit.Unit

GetFuelEconomyTo returns the fuel economy in the to or outbound direction.

func (*Mode) GetHPFactor 

func (m *Mode) GetHPFactor(db *DB) *unit.Unit

GetHPFactor gets the power adjustment factor.

func (*Mode) GetLoadFactorFrom 

func (m *Mode) GetLoadFactorFrom(db *DB) *unit.Unit

GetLoadFactorFrom returns the load factor in the from or inbound direction.

func (*Mode) GetLoadFactorTo 

func (m *Mode) GetLoadFactorTo(db *DB) *unit.Unit

GetLoadFactorTo returns the load factor in the to or outbound direction.

func (*Mode) GetPayload 

func (m *Mode) GetPayload(r *Resource, db *DB) *unit.Unit

GetPayload returns the payload for this mode carrying the specified resource.

func (*Mode) GetPipelineEnergyIntensity 

func (m *Mode) GetPipelineEnergyIntensity(r *Resource, db *DB) *unit.Unit

GetPipelineEnergyIntensity gets the energy intensity for the mode in transporting the given resource. It only works for pipelines.

func (*Mode) GetRailEnergyIntensity 

func (m *Mode) GetRailEnergyIntensity(db *DB) *unit.Unit

GetRailEnergyIntensity returns the energy intensity for the rail mode.

func (*Mode) GetTypicalFC 

func (m *Mode) GetTypicalFC(db *DB) *unit.Unit

GetTypicalFC returns the typical fuel consumption.

func (*Mode) GetTypicalHP 

func (m *Mode) GetTypicalHP(db *DB) *unit.Unit

GetTypicalHP returns the typical power consumption.

type ModeID 

type ModeID Guid

ModeID holds the ID code for a travel mode

type ModelID 

type ModelID string

ModelID holds the ID code for a Process model (TransportationProcess or StationaryProcess)

type NLoss 

type NLoss struct {
	Rate       Expression `xml:"rate,attr"`
	Dependency string     `xml:"dependency,attr"`
}

NLoss is a holder for product loss fraction during a transportation step.

type OtherEmission 

type OtherEmission struct {
	// TODO: What does MostRecent mean?
	MostRecent string       `xml:"mostRecent,attr"`
	Ref        GasID        `xml:"ref,attr"`
	ValueYears []*ValueYear `xml:"year"`
	Notes      string       `xml:"notes,attr"`
}

OtherEmission is a holder for "other" emissions from StationaryProcesses.

func (*OtherEmission) Amount 

func (e *OtherEmission) Amount(db *DB) *unit.Unit

Amount returns the amount of emission.

func (*OtherEmission) Gas 

func (e *OtherEmission) Gas(db *DB) *Gas

Gas returns the gas associated with this emission

type Output 

type Output struct {
	ID          slca.OutputID `xml:"id,attr"`
	ResourceID  ResourceID    `xml:"resource,attr"`
	Ref         ResourceID    `xml:"ref,attr"`
	AmountYears []*ValueYear  `xml:"amount>year"`
	NLoss       *NLoss        `xml:"nloss"`
}

Output is a holder for the type and amount of a resource that is output from a process or pathway.

func (*Output) CalcAllocationAmount 

func (o *Output) CalcAllocationAmount(outputUnit unit.Dimensions, AllocationMethod string,
	db *DB) *unit.Unit

CalcAllocationAmount calculates the amount of this output to be used when allocating resource use and emissions. If AllocationMethod is "", it allocates all emissions to the main output and none to the coproducts.

func (*Output) GetAmount 

func (o *Output) GetAmount(db *DB) *unit.Unit

GetAmount calculates the amount of this output after accounting for losses.

func (*Output) GetAmountBeforeLoss 

func (o *Output) GetAmountBeforeLoss(db *DB) *unit.Unit

GetAmountBeforeLoss calculates the amount of this output without accounting for losses.

func (*Output) GetID 

func (o *Output) GetID() slca.OutputID

GetID returns the ID of this output.

func (*Output) GetLossEmissions 

func (o *Output) GetLossEmissions(db *DB) ([]*Gas, []*unit.Unit)

GetLossEmissions calculates emissions through evaporation of a product (or other losses).

func (*Output) GetNLoss 

func (o *Output) GetNLoss(db *DB) *unit.Unit

GetNLoss returns the loss rate associated with this output.

func (*Output) GetName 

func (o *Output) GetName(db *DB) string

GetName returns the name out the resource output by this output.

func (*Output) GetProcess 

func (o *Output) GetProcess(path *Pathway, db *DB) slca.Process

GetProcess returns the process associated with this output.

func (*Output) GetResource 

func (o *Output) GetResource(db slca.LCADB) slca.Resource

GetResource returns the resource associated with this output.

func (*Output) IsCoproduct 

func (o *Output) IsCoproduct() bool

IsCoproduct returns whether this output is a coproduct. It is an output, not a coproduct, the the answer is always false.

type OutputLike 

type OutputLike interface {
	IsCoproduct() bool
	GetName(*DB) string
	GetAmount(*DB) *unit.Unit
	GetAmountBeforeLoss(*DB) *unit.Unit
	GetResource(slca.LCADB) slca.Resource
	GetProcess(*Pathway, *DB) slca.Process
	GetID() slca.OutputID
	CalcAllocationAmount(outputUnits unit.Dimensions,
		AllocationMethod string, db *DB) *unit.Unit
	GetLossEmissions(*DB) ([]*Gas, []*unit.Unit)
}

OutputLike is an interface that allows the use of outputs and coproducts together.

type Param 

type Param struct {
	// TODO: What does MostRecent mean?
	MostRecent string       `xml:"mostRecent,attr"`
	ValueYears []*ValueYear `xml:"year"`
}

Param is one type of variable parameter from the GREET database (different from Parameter).

type Parameter 

type Parameter struct {
	Name       string     `xml:"name,attr"`
	ID         string     `xml:"id,attr"`
	Value      Expression `xml:"value,attr"`
	ValueYears *Param     `xml:"values"`
}

Parameter is one type of variable parameter from the GREET database (different from Param). It holds the data in a GREET input table cell.

type Pathway 

type Pathway struct {
	sync.RWMutex
	ID         ModelID       `xml:"id,attr"`
	Name       string        `xml:"name,attr"`
	Notes      string        `xml:"notes,attr"`
	MainOutput slca.OutputID `xml:"main-output,attr"`
	Vertices   []*Vertex     `xml:"vertex"`
	Edges      []*Edge       `xml:"edge"`
	Outputs    []*Output     `xml:"output"`
}

Pathway is holder for a pathway in the GREET model. Refer to the GREET documentation for more information.

func (*Pathway) GetID 

func (path *Pathway) GetID() ModelID

GetID gets the pathway ID.

func (*Pathway) GetIDStr 

func (path *Pathway) GetIDStr() string

GetIDStr gets the pathway ID in string format

func (*Pathway) GetMainOutput 

func (path *Pathway) GetMainOutput(_ slca.LCADB) slca.Output

GetMainOutput returns the main output from this pathway.

func (*Pathway) GetName 

func (path *Pathway) GetName() string

GetName gets the name of this pathway.

func (*Pathway) GetOutput 

func (path *Pathway) GetOutput(rI slca.Resource, lcadb slca.LCADB) slca.Output

GetOutput returns the output from this pathway that outputs resource r.

func (*Pathway) GetOutputProcess 

func (path *Pathway) GetOutputProcess(r *Resource, lcadb slca.LCADB) slca.Process

GetOutputProcess returns the process that outputs resource r. It assumes only one process outputs resource r from this pathway.

func (*Pathway) MainProcessAndOutput 

func (path *Pathway) MainProcessAndOutput(lcadb slca.LCADB) (slca.Process, slca.Output)

MainProcessAndOutput returns the process that outputs the main output of the receiver, and also returns that output.

func (*Pathway) Type 

func (path *Pathway) Type() string

Type returns the type: "Pathway".

func (*Pathway) VertexForMainOutput 

func (path *Pathway) VertexForMainOutput() *Vertex

VertexForMainOutput returns the vertex associated with the main output of the pathway.

func (*Pathway) VertexForOutput 

func (path *Pathway) VertexForOutput(o *Output, db *DB) *Vertex

VertexForOutput returns the vertex associated with the given pathway output.

type PathwayLike 

type PathwayLike interface {
	GetName() string
	GetID() ModelID
	GetMainOutput(slca.LCADB) slca.Output
	GetOutput(slca.Resource, slca.LCADB) slca.Output
	GetOutputProcess(*Resource, slca.LCADB) slca.Process
}

PathwayLike is an interface for things that can be treated like a pathway.

type Payload 

type Payload struct {
	Payload Expression `xml:"payload,attr"`
	Ref     ResourceID `xml:"ref,attr"`
}

Payload specifies the amount of a given resource that a Mode can carry.

type Product 

type Product struct {
	Ref       ResourceID `xml:"ref,attr"`
	PathwayID ModelID    `xml:"pathway,attr"`
	MixID     ModelID    `xml:"mix,attr"`
	RatioStr  Expression `xml:"ratio,attr"`
}

Product is a holder for information about the product that is being displaced by a coproduct.

func (*Product) GetProcess 

func (p *Product) GetProcess(r *Resource, db *DB) (slca.Process, *Pathway)

GetProcess returns the process and pathway this coproduct is displacing.

func (*Product) GetRatio 

func (p *Product) GetRatio(db *DB) *unit.Unit

GetRatio returns the displacement ratio for this coproduct.

func (*Product) GetResource 

func (p *Product) GetResource(db slca.LCADB) *Resource

GetResource returns the resource associated with this product.

type Resource 

type Resource struct {
	HiddenAsMain    bool                `xml:"hidden_as_main,attr"`
	CanBePrimary    bool                `xml:"can_be_primary,attr"`
	MarketValue     Expression          `xml:"market_value,attr"`
	Density         Expression          `xml:"density,attr"`
	HeatingValueHHV Expression          `xml:"heating_value_hhv,attr"`
	HeatingValueLHV Expression          `xml:"heating_value_lhv,attr"`
	Temperature     string              `xml:"temperature,attr"`
	Pressure        string              `xml:"pressure,attr"`
	ID              ResourceID          `xml:"id,attr"`
	Name            string              `xml:"name,attr"`
	CRatio          Expression          `xml:"c_ratio,attr"`
	SRatioDefault   Expression          `xml:"s_ratio,attr"`
	SRatioYear      []*ValueYear        `xml:"s_ratio>year"`
	State           string              `xml:"state,attr"`
	Family          string              `xml:"family,attr"`
	NickName        []string            `xml:"nick_name"`
	Membership      []*Membership       `xml:"membership"`
	Compatibility   []*Compatibility    `xml:"compatibility"`
	Evaporation     []*EvaporationShare `xml:"evaporation>gas"`
}

Resource is a holder for the GREET model Resource type. Refer to the GREET documentation for more information.

func (*Resource) ConvertToDefaultUnits 

func (r *Resource) ConvertToDefaultUnits(amt *unit.Unit, dbI slca.LCADB) *unit.Unit

ConvertToDefaultUnits converts the amount of the resource to the default units for this resource: energy for resources in in the "energy" state and mass for all other states. If the resource doesn't contain enough information to make the conversion, however, the original value will be returned.

func (*Resource) ConvertToEnergy 

func (r *Resource) ConvertToEnergy(amt *unit.Unit, db *DB) *unit.Unit

ConvertToEnergy converts an amount of this resource to energy units.

func (*Resource) ConvertToMarketValue 

func (r *Resource) ConvertToMarketValue(amt *unit.Unit, db *DB) *unit.Unit

ConvertToMarketValue converts an amount of this resource to its market value

func (*Resource) ConvertToMass 

func (r *Resource) ConvertToMass(amt *unit.Unit, db *DB) *unit.Unit

ConvertToMass converts an amount of this resource to mass units.

func (*Resource) ConvertToVolume 

func (r *Resource) ConvertToVolume(amt *unit.Unit, db *DB) *unit.Unit

ConvertToVolume converts an amount of this resource to volume units.

func (*Resource) GetCRatio 

func (r *Resource) GetCRatio(db *DB) *unit.Unit

GetCRatio returns the fraction carbon in this resource.

func (*Resource) GetDensity 

func (r *Resource) GetDensity(db *DB) *unit.Unit

GetDensity returns the density of this resource.

func (*Resource) GetEvaporationShares 

func (r *Resource) GetEvaporationShares(db *DB) ([]*Gas, []*unit.Unit)

GetEvaporationShares returns the gas that this resource evaporates to, and the fraction that is evaporated.

func (*Resource) GetHeatingValueMass 

func (r *Resource) GetHeatingValueMass(db *DB) *unit.Unit

GetHeatingValueMass returns the mass-specific heating value for this resource.

func (*Resource) GetHeatingValueVolume 

func (r *Resource) GetHeatingValueVolume(db *DB) *unit.Unit

GetHeatingValueVolume returns the volume-specific heating value for this resource.

func (*Resource) GetID 

func (r *Resource) GetID() string

GetID gets the ID of this Resource.

func (*Resource) GetMarketValue 

func (r *Resource) GetMarketValue(db *DB) *unit.Unit

GetMarketValue returns the market value for this resource.

func (*Resource) GetName 

func (r *Resource) GetName() string

GetName gets the name of this resource.

func (*Resource) GetSRatio 

func (r *Resource) GetSRatio(db *DB) *unit.Unit

GetSRatio returns the fraction sulfur in this resource.

func (*Resource) IsCompatible 

func (r *Resource) IsCompatible(other *Resource) bool

IsCompatible returns true if two resources are compatible.

type ResourceGroup 

type ResourceGroup struct {
	ID        string `xml:"id,attr"`
	Name      string `xml:"name"`
	IncludeIn string `xml:"include_in"`
}

ResourceGroup is a group of resources.

type ResourceID 

type ResourceID string

ResourceID holds the ID code for a resource

type StationaryProcess 

type StationaryProcess struct {
	sync.RWMutex            `xml:"-"`
	ID                      ModelID          `xml:"id,attr"`
	Name                    string           `xml:"name,attr"`
	IOCarbonMap             *IOCarbonMap     `xml:"io-carbon-map"`
	PreferredFunctionalUnit *Unit            `xml:"prefered_functional_unit"`
	Outputs                 []*Output        `xml:"output"`
	Inputs                  []*Input         `xml:"input"`
	InputGroups             []*InputGroup    `xml:"group"`
	Coproducts              *Coproducts      `xml:"coproducts"`
	OtherEmissions          []*OtherEmission `xml:"other_emissions>emission"`
	Notes                   string           `xml:"notes,attr"`

	// Spatial reference information for this process
	SpatialReference *slca.SpatialRef

	// NoncombustionSCC is used for speciating non-combustion emissions.
	NoncombustionSCC slca.SCC
	// contains filtered or unexported fields
}

StationaryProcess is a holder for stationary process data from the GREET database.

func (*StationaryProcess) GetID 

func (p *StationaryProcess) GetID() ModelID

GetID returns the ID of this process.

func (*StationaryProcess) GetIDStr 

func (p *StationaryProcess) GetIDStr() string

GetIDStr returns the ID of this process in string format.

func (*StationaryProcess) GetMainOutput 

func (p *StationaryProcess) GetMainOutput(db slca.LCADB) slca.Output

GetMainOutput gets the main output of this process. It panics if there is more than one main output.

func (*StationaryProcess) GetName 

func (p *StationaryProcess) GetName() string

GetName returns the name of this process.

func (*StationaryProcess) GetOutput 

func (p *StationaryProcess) GetOutput(rI slca.Resource, db slca.LCADB) slca.Output

GetOutput gets the output (or coproduct) of this process that outputs the given resource. It assumes that there is only one output or coproduct for each resource. It panics if none of the outputs output the given resource.

func (*StationaryProcess) OnsiteResults 

func (p *StationaryProcess) OnsiteResults(pathI slca.Pathway, outputI slca.Output, lcadb slca.LCADB) *slca.OnsiteResults

OnsiteResults calculates the onsite emissions from and resource use of this process per unit output, where "output" is the output that is required from the process, "path" is the pathway the process is a part of.

func (*StationaryProcess) SpatialRef 

func (p *StationaryProcess) SpatialRef(aqm string) *slca.SpatialRef

SpatialRef returns the spatial reference for the receiver.

func (*StationaryProcess) Type 

func (p *StationaryProcess) Type() slca.ProcessType

Type returns the process type.

type Step 

type Step struct {
	DestRef      LocationID  `xml:"dest_ref,attr"`
	OriginRef    LocationID  `xml:"origin_ref,attr"`
	Ref          ModeID      `xml:"ref,attr"`
	Distance     Param       `xml:"distance"`
	Share        Param       `xml:"share"`
	FuelShareRef FuelShareID `xml:"fuel_share_ref,attr"`
	BackHaul     bool        `xml:"back_haul,attr"` // Is an empty backhaul required?
	ID           string      `xml:"id,attr"`
	NLoss        *NLoss      `xml:"nloss"`
}

Step is a holder for a step in a transportation process.

func (*Step) GetDistance 

func (s *Step) GetDistance(db *DB) *unit.Unit

GetDistance returns the distance traveled by this step.

func (*Step) GetLossAmount 

func (s *Step) GetLossAmount(res *Resource, amountTransported *unit.Unit,
	db *DB) *unit.Unit

GetLossAmount calculates the loss of the transported resource during this step.

func (*Step) GetLossEmissions 

func (s *Step) GetLossEmissions(res *Resource, amountTransported *unit.Unit, db *DB) (
	[]*Gas, []*unit.Unit)

GetLossEmissions calculates emissions through evaporation of a product (or other losses).

func (*Step) GetModeAndFuelShare 

func (s *Step) GetModeAndFuelShare(db *DB) (*Mode, *FuelShare)

GetModeAndFuelShare gets the mode and fuel share associated with this step

func (*Step) GetNLoss 

func (s *Step) GetNLoss(db *DB) *unit.Unit

GetNLoss returns the fraction of product that is lost during this step.

func (*Step) GetShare 

func (s *Step) GetShare(db *DB) *unit.Unit

GetShare gets the share of the product that is transported by this step.

type Technology 

type Technology struct {
	ID            TechnologyID    `xml:"id,attr"`
	Name          string          `xml:"name,attr"`
	InputRef      ResourceID      `xml:"inputRef,attr"`
	OutputRef     ResourceID      `xml:"outputRef,attr"`
	MassTransfer  string          `xml:"massTransfer,attr"`
	BaseTech      string          `xml:"basetech,attr"`
	EmissionsYear []*EmissionYear `xml:"year"`

	SCC slca.SCC
}

Technology is a holder for the GREET technology type. Refer to the GREET documentation for more information.

func (*Technology) GetEmissions 

func (t *Technology) GetEmissions(db *DB) ([]*Gas, []*unit.Unit)

GetEmissions returns the emissions associated with this technology

func (*Technology) GetID 

func (t *Technology) GetID() VertexID

GetID returns the ID of this Technology.

func (*Technology) GetInputResource 

func (t *Technology) GetInputResource(db *DB) *Resource

GetInputResource gets the resource used as an input for this technology

func (*Technology) GetName 

func (t *Technology) GetName() string

GetName returns the name of this technology.

func (*Technology) GetOutputResource 

func (t *Technology) GetOutputResource(db *DB) *Resource

GetOutputResource gets the resource output by this technology

func (*Technology) GetSCC 

func (t *Technology) GetSCC() slca.SCC

GetSCC returns the SCC code associated with this technology.

type TechnologyID 

type TechnologyID string

TechnologyID holds the ID code for a technology

type TechnologyShare 

type TechnologyShare struct {
	Ref              TechnologyID `xml:"ref,attr"`
	Share            Param        `xml:"share"`
	AccountInBalance bool         `xml:"account_in_balance,attr"`
}

TechnologyShare holds information about the fraction of work done by a technology.

func (*TechnologyShare) GetShare 

func (ts *TechnologyShare) GetShare(db *DB) *unit.Unit

GetShare returns the share associated with this TechnologyShare

func (*TechnologyShare) GetTechnology 

func (ts *TechnologyShare) GetTechnology(db *DB) *Technology

GetTechnology returns the Technology associated with this TechnologyShare

type TransportationProcess 

type TransportationProcess struct {
	sync.RWMutex            `xml:"-"`
	ID                      ModelID      `xml:"id,attr"`
	Name                    string       `xml:"name,attr"`
	IOCarbonMap             *IOCarbonMap `xml:"io-carbon-map"`
	PreferredFunctionalUnit *Unit        `xml:"prefered_functional_unit"`
	Outputs                 []*Output    `xml:"output"`
	Inputs                  []*Input     `xml:"input"`
	MoistureStr             Expression   `xml:"moisture,attr"`
	Steps                   []*Step      `xml:"step"`
	Notes                   string       `xml:"notes,attr"`
	// contains filtered or unexported fields
}

TransportationProcess is a holder for transportation process data from the GREET database.

func (*TransportationProcess) GetID 

func (p *TransportationProcess) GetID() ModelID

GetID returns the ID of this process.

func (*TransportationProcess) GetIDStr 

func (p *TransportationProcess) GetIDStr() string

GetIDStr returns the ID of this process in string format.

func (*TransportationProcess) GetInput 

func (p *TransportationProcess) GetInput() *Input

GetInput gets the single input to this process. It panics if there is more than one input.

func (*TransportationProcess) GetMainOutput 

func (p *TransportationProcess) GetMainOutput(db slca.LCADB) slca.Output

GetMainOutput gets the main output of this process. It panics if there is more than one main output.

func (*TransportationProcess) GetName 

func (p *TransportationProcess) GetName() string

GetName gets the name of this process.

func (*TransportationProcess) GetOutput 

func (p *TransportationProcess) GetOutput(res slca.Resource, db slca.LCADB) slca.Output

GetOutput gets the output of this process that outputs the given resource. Transportation processes should only have one output, so it panics if there is more or less than one output or if the output does not output the given resource.

func (*TransportationProcess) OnsiteResults 

func (p *TransportationProcess) OnsiteResults(pathI slca.Pathway, outputI slca.Output, lcadb slca.LCADB) *slca.OnsiteResults

OnsiteResults calculates the onsite emissions from and resource use of this process per unit output, where "output" is the output that is required from the process, "path" is the pathway the process is a part of. The returned value is a pointer and is cached for future use, so be sure to clone the result before modifying it.

func (*TransportationProcess) SpatialRef 

func (p *TransportationProcess) SpatialRef(aqm string) *slca.SpatialRef

SpatialRef returns the spatial reference for the receiver. TODO: Need to implement something for this.

func (*TransportationProcess) Type 

func (p *TransportationProcess) Type() slca.ProcessType

Type returns the process type.

type Unit 

type Unit struct {
	Unit    string  `xml:"unit,attr"`
	Amount  float64 `xml:"amount,attr"`
	Enabled bool    `xml:"enabled,attr"`
}

Unit is a holder for a value with units.

type ValueYear 

type ValueYear struct {
	Value Expression `xml:"value,attr"`
	Year  string     `xml:"year,attr"`
}

ValueYear is a holder for a value that applies to a specific year.

func (*ValueYear) GetValue 

func (v *ValueYear) GetValue(db *DB) *unit.Unit

GetValue returns the value.

func (*ValueYear) GetYear 

func (v *ValueYear) GetYear() float64

GetYear returns the year.

type Vehicle 

type Vehicle struct {
	sync.Mutex
	ID    ModelID `xml:"id,attr"`
	Name  string  `xml:"name,attr"`
	Notes string  `xml:"notes,attr"`

	// Modes gives information on the mode the vehicle is operating in.
	// Plug-in hybrid vehicles can operate in multiple modes.
	Modes []struct {
		Name string  `xml:"name,attr"`
		ID   ModelID `xml:"id,attr"`

		VMTShare []*ValueYear `xml:"vmtShare>year"`

		// Plant holds information about a vehicle power plant.
		Plant struct {
			Name  string `xml:"name,attr"`
			ID    Guid   `xml:"id,attr"`
			Notes string `xml:"notes,attr"`

			Fuel struct {
				Resource           ResourceID   `xml:"ref,attr"`
				Pathway            ModelID      `xml:"pathway,attr"`
				Consumption        []*ValueYear `xml:"consumption>year"`
				ChargingEfficiency []*ValueYear `xml:"charging_efficiency>year"`
			} `xml:"fuel"`

			Emissions []struct {
				Gas   GasID        `xml:"id,attr"`
				Value []*ValueYear `xml:"value_ts>year"`
			} `xml:"emission"`
		} `xml:"plant"`
	} `xml:"mode"`

	LifetimeVMT []*ValueYear `xml:"lifetime_vmt>year"`

	// Manufacturing holds information about
	// emissions and resource use from the manufacturing
	// of groups of vehicle components.
	Manufacturing []struct {
		Name string `xml:"name,attr"`

		// Materials holds information on materials
		// used in vehicle manufacturing.
		Materials []struct {
			Resource   ResourceID `xml:"resource_id,attr"`
			Source     ModelID    `xml:"entity_id,attr"`
			SourceType string     `xml:"source_type,attr"`

			// Quantity is the amount needed of this
			// pathway per unit.
			Quantity []*ValueYear `xml:"quantity>year"`

			// Replacements is the number of times each
			// unit will need to be replaced during
			// the vehicle lifetime.
			Replacements []*ValueYear `xml:"replacements>year"`

			// Units is the number of units per vehicle.
			Units []*ValueYear `xml:"units>year"`
		} `xml:"material"`
	} `xml:"manufacturing"`

	NonCombustionEmissions []struct {
		Gas    GasID        `xml:"id,attr"`
		Values []*ValueYear `xml:"year"`
	} `xml:"nonCombustionEmission"`

	// SCC is the SCC code for this vehicle.
	SCC slca.SCC
	// contains filtered or unexported fields
}

Vehicle is a holder for information about a vehicle in the GREET database.

func (*Vehicle) GetID 

func (v *Vehicle) GetID() ModelID

GetID returns the vehicle ID

func (*Vehicle) GetIDStr 

func (v *Vehicle) GetIDStr() string

GetIDStr returns the ID of this vehicle in string format

func (*Vehicle) GetMainOutput 

func (v *Vehicle) GetMainOutput(_ slca.LCADB) slca.Output

GetMainOutput always returns nil because vehicles have no process outputs.

func (*Vehicle) GetName 

func (v *Vehicle) GetName() string

GetName returns the name of this vehicle.

func (*Vehicle) GetOutput 

func (v *Vehicle) GetOutput(_ slca.Resource, _ slca.LCADB) slca.Output

GetOutput always returns nil because vehicles have no process outputs.

func (*Vehicle) MainProcessAndOutput 

func (v *Vehicle) MainProcessAndOutput(db slca.LCADB) (slca.Process, slca.Output)

MainProcessAndOutput returns the process that outputs the main output of the receiver, and also returns that output.

func (*Vehicle) OnsiteResults 

func (v *Vehicle) OnsiteResults(_ slca.Pathway, _ slca.Output, lcadb slca.LCADB) *slca.OnsiteResults

OnsiteResults calculates the from-vehicle emissions and vehicle resource use per unit output as part of a life cycle calculation, as well as requirements of other pathways. The returned results are emissions and resource use per meter driven by the vehicle.

func (*Vehicle) SpatialRef 

func (v *Vehicle) SpatialRef(aqm string) *slca.SpatialRef

SpatialRef returns the spatial reference for the receiver. TODO: Need to implement something for this.

func (*Vehicle) Type 

func (v *Vehicle) Type() slca.ProcessType

Type returns the type of this process.

type Vertex 

type Vertex struct {
	ID      VertexID `xml:"id,attr"`
	ModelID ModelID  `xml:"model-id,attr"`
	Type    string   `xml:"type,attr"` // 0=process; 1=pathway; 2=mix
}

Vertex is a holder for the Vertex datatype in the GREET database.

func (*Vertex) GetProcess 

func (this *Vertex) GetProcess(requestingPath *Pathway, resource *Resource,
	db *DB) (slca.Process, *Pathway)

GetProcess finds the corresponding process model for this vertex. It can be a *StationaryProcess, *TransportationProcess, *Pathway, or *Mix. If it is a stationary or transportation process, it is assumed to be part of the requestingPathway.

type VertexID 

type VertexID Guid

VertexID holds the ID code for a vertex

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.