load

Documentation

Overview

Package load contains definition of loads applied to structural members.

Index

• Constants
• func ConcentratedLoadsEqual(a, b []*ConcentratedLoad) bool
• func DistributedLoadsEqual(a, b []*DistributedLoad) bool
• func EnsureValidTerm(term Term)
• func IsValidTerm(term Term) bool
• type ConcentratedLoad
  • func MakeConcentrated(term Term, isInLocalCoords bool, t nums.TParam, value float64) *ConcentratedLoad
  • func (load *ConcentratedLoad) AsTorsor() *math.Torsor
  • func (load *ConcentratedLoad) AsTorsorProjectedTo(refFrame *g2d.RefFrame) *math.Torsor
  • func (load *ConcentratedLoad) Equals(other *ConcentratedLoad) bool
  • func (load *ConcentratedLoad) IsNodal() bool
  • func (load *ConcentratedLoad) LocalFx() float64
  • func (load *ConcentratedLoad) LocalFy() float64
  • func (load *ConcentratedLoad) LocalMz() float64
• type DistributedLoad
  • func MakeDistributed(term Term, isInLocalCoords bool, startT nums.TParam, startValue float64, ...) *DistributedLoad
  • func (load *DistributedLoad) AsTorsorAt(t nums.TParam) *math.Torsor
  • func (load *DistributedLoad) AsTorsorProjectedAt(t nums.TParam, refFrame *g2d.RefFrame) *math.Torsor
  • func (load *DistributedLoad) Equals(other *DistributedLoad) bool
  • func (load *DistributedLoad) ValueAt(t nums.TParam) float64
• type Term

Constants

const (
	// FX is a force in the direction of X
	FX = Term("fx")

	// FY is a force in the direction of Y
	FY = Term("fy")

	// MZ is a moment about Z
	MZ = Term("mz")
)

Functions

func ConcentratedLoadsEqual

func ConcentratedLoadsEqual(a, b []*ConcentratedLoad) bool

func DistributedLoadsEqual

func DistributedLoadsEqual(a, b []*DistributedLoad) bool

func EnsureValidTerm

func EnsureValidTerm(term Term)

EnsureValidTerm validates the load term and panics if an unknown term happens.

func IsValidTerm

func IsValidTerm(term Term) bool

IsValidTerm validates the load term, to make sure it represents a known term.

Types

type ConcentratedLoad

type ConcentratedLoad struct {
	Term            Term
	IsInLocalCoords bool
	T               nums.TParam
	Value           float64
}

A ConcentratedLoad is a load applied in a specific point.

func MakeConcentrated

func MakeConcentrated(
	term Term,
	isInLocalCoords bool,
	t nums.TParam,
	value float64,
) *ConcentratedLoad

MakeConcentrated creates a concentrated load for the given term (FX, FY or MZ) which may be defined localy to the element it will be applied to or referenced in global coordinates.

Concentrated loads are defined by a position - value tuple.

func (*ConcentratedLoad) AsTorsor

func (load *ConcentratedLoad) AsTorsor() *math.Torsor

AsTorsor returns a vector with the components of the load.

func (*ConcentratedLoad) AsTorsorProjectedTo

func (load *ConcentratedLoad) AsTorsorProjectedTo(refFrame *g2d.RefFrame) *math.Torsor

AsTorsorProjectedTo returns the concentrated load vector projected in a reference frame.

func (*ConcentratedLoad) Equals

func (load *ConcentratedLoad) Equals(other *ConcentratedLoad) bool

Equals tests whether the two loads are equal or not.

func (*ConcentratedLoad) IsNodal

func (load *ConcentratedLoad) IsNodal() bool

IsNodal returns true if the load is applied in extreme values of T. When `true`, this means that the load applied to an element is acting on one of its end nodes.

func (*ConcentratedLoad) LocalFx

func (load *ConcentratedLoad) LocalFx() float64

func (*ConcentratedLoad) LocalFy

func (load *ConcentratedLoad) LocalFy() float64

func (*ConcentratedLoad) LocalMz

func (load *ConcentratedLoad) LocalMz() float64

type DistributedLoad

type DistributedLoad struct {
	Term                 Term
	IsInLocalCoords      bool
	StartT, EndT         nums.TParam
	StartValue, EndValue float64
}

A DistributedLoad is a load which effect is distributed over a length. Distributed loads are linear: the start and end values are interpolated linearly.

A load is expressed as: - a term of application, which in 2D can be: Force in X, Force in Y or Moment about Z - a projection frame, which can be local to the element to which load is applied or global - start/end position and value

func MakeDistributed

func MakeDistributed(
	term Term,
	isInLocalCoords bool,
	startT nums.TParam,
	startValue float64,
	endT nums.TParam,
	endValue float64,
) *DistributedLoad

MakeDistributed creates a distributed load for the given term (FX, FY, MZ) which may be defined locally to the element it will be applied to or referenced in global coordinates.

Distributed loads are defined by a start position - value and an end position - value tuples.

func (*DistributedLoad) AsTorsorAt

func (load *DistributedLoad) AsTorsorAt(t nums.TParam) *math.Torsor

AsTorsorAt returns the the distributed load vector at a given position.

func (*DistributedLoad) AsTorsorProjectedAt

func (load *DistributedLoad) AsTorsorProjectedAt(t nums.TParam, refFrame *g2d.RefFrame) *math.Torsor

AsTorsorProjectedAt returns the distributed load vector at a given position projected in a reference frame.

func (*DistributedLoad) Equals

func (load *DistributedLoad) Equals(other *DistributedLoad) bool

Equals tests whether the two loads are equal or not.

func (*DistributedLoad) ValueAt

func (load *DistributedLoad) ValueAt(t nums.TParam) float64

ValueAt returns the value of the load at a given t Parameter value.

type Term

type Term string

Term represents the available terms for which loads can exist: - Force in X - Force in Y - Moment about Z