greet

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

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

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"`
}

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

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

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
}

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"`
}

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"`
}

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

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

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

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

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

type Expression string

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"`
}

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

type FuelShareID string

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"`
}

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

type GasID string

type Guid string

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

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

type IOCarbonOutput struct {
	ID     slca.OutputID  `xml:"id,attr"`
	Inputs *IOCarbonInput `xml:"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"`
}

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

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"`
}

type InputID Guid

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"`
}

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"`
}

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

type LocationGroupID string

type LocationID string

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

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

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

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
}

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

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

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"`
}

type ModeID Guid

type ModelID string

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

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"`
}

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"`
}

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)
}

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

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

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"`
}

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
}

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

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

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"`
}

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

type ResourceID string

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
}

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"`
}

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
}

type TechnologyID string

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

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
}

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

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

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
}

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
}

type VertexID Guid