hd

type BeamProp struct {
	// Start and end point index
	//
	//	[0] - start of beam
	//	[1] - end of beam
	//
	N [2]int

	// A cross-section area
	// Unit : sq. meter.
	A float64

	// J is moment inertia
	// Unit : meter^4
	J float64

	// E is modulus of elasticity
	// Unit : Pa
	E float64
}

type BucklingResult struct {
	// Buckling factor
	// Return data.
	Factor float64

	// Point displacement in global system coordinate.
	// Return data.
	//
	// first index is point index
	//
	//	[0] - X
	//	[1] - Y
	//	[2] - M
	//
	// Unit: relative
	PointDisplacementGlobal [][3]float64
}

type ErrorBeam struct {
	BeamIndex int
	Detail    string
	Err       error
}

type ErrorLoad struct {
	LoadPos int
	Err     error
}

type ErrorModal struct {
	ModalPos int
	Err      error
}

type ErrorPin struct {
	Beam int
	Err  error
}

type ErrorPoint struct {
	PointIndex int
	CoordIndex int
	Err        error
}

type LoadCase struct {
	// LoadNodes is node loads in global system coordinate
	LoadNodes []LoadNode

	// Point displacement in global system coordinate.
	// Return data.
	//
	// first index is point index
	//
	//	[0] - X
	//	[1] - Y
	//	[2] - M
	//
	// Unit: meter and rad.
	PointDisplacementGlobal [][3]float64

	// BeamForces is beam forces in local system coordinate.
	// Return data.
	//
	// first index is beam index
	//
	//	[0] - Fx on start point
	//	[1] - Fy on start point
	//	[2] - M  on start point
	//	[3] - Fx on end point
	//	[4] - Fy on end point
	//	[5] - M  on end point
	//
	// Unit: N and N*m
	BeamForces [][6]float64

	// Reactions is reaction loads in support points.
	// Return data.
	//
	// first index is point index
	//
	//	[0] - Fx
	//	[1] - Fy
	//	[2] - M
	//
	// Unit: N and N*m
	Reactions [][3]float64

	// Amount of calculated forms.
	// If Amount is zero or less zero, then no calculate.
	// LinearBuckling is linear buckling calculation
	AmountLinearBuckling uint16

	// Result of linear buckling calculation
	LinearBucklingResult []BucklingResult
}

type LoadNode struct {
	// N is point index
	N int

	// Forces is node loads on each direction
	//
	//	[0] - X , Unit: N. Positive direction from left to right.
	//	[1] - Y , Unit: N. Positive direction from down to top.
	//	[2] - M , Unit: N*m. Positive direction is counter-clockwise direction.
	//
	Forces [3]float64
}

type ModalCase struct {
	// ModalMasses is modal masses
	ModalMasses []ModalMass

	// Result of modal calculation
	Result []ModalResult
}

type ModalMass struct {
	// N is point index
	N int

	// Mass of point
	// Unit: N
	Mass float64
}

type ModalResult struct {
	// Natural frequency
	Hz float64

	// Modal displacement in global system coordinate
	//
	// first index is point index
	//
	//	[0] - X direction
	//	[1] - Y direction
	//	[2] - M direction
	//
	// Unit: Dimensionless
	ModalDisplacement [][3]float64
}

type Model struct {
	// Points is slice of point coordinate
	//
	//	[0] - X coordinate
	//	[1] - Y coordinate
	//
	Points [][2]float64

	// Beams is slice of point index and beam property
	Beams []BeamProp

	// Pins is slice of pins for beams in local system coordinate.
	// Len of support must be same amount of beam.
	// Or if len is zero, then all DoF(degree of freedom) is rigid.
	//
	// first index is point index
	//
	//	[0] - X on start point
	//	[1] - Y on start point
	//	[2] - M on start point
	//	[3] - X on end point
	//	[4] - Y on end point
	//	[5] - M on end point
	//
	// if `true` then free degree of freedom
	Pins [][6]bool

	// Supports is slice of fixed supports.
	// Len of support must be same amount of Points
	//
	// first index is point index
	//
	//	[0] - X
	//	[1] - Y
	//	[2] - M
	//
	Supports [][3]bool
}