Beispiel #1
0
// Integrate integrates key along direction "x", "y", or "z"
//  idxI -- index in TimeInds slice corresponding to selected output time; use -1 for the last item.
//          If alias defines a single point, the whole time series is returned and idxI is ignored.
func Integrate(key, alias, along string, idxI int) float64 {
	if idxI < 0 {
		idxI = len(TimeInds) - 1
	}
	y := GetRes(key, alias, idxI)
	var x []float64
	switch along {
	case "x":
		x, _, _ = GetXYZ(key, alias)
	case "y":
		_, x, _ = GetXYZ(key, alias)
	case "z":
		_, _, x = GetXYZ(key, alias)
	}
	var err error
	_, x, y, _, err = utl.SortQuadruples(nil, x, y, nil, "x")
	if err != nil {
		chk.Panic("%q: cannot integrate %q along %q:\n%v\n", alias, key, along, err)
	}
	return num.Trapz(x, y)
}
Beispiel #2
0
// CheckEigenprojs checks eigen projectors
func CheckEigenprojs(a []float64, tolP, tolS float64, ver bool) (λsorted []float64) {

	// compute eigenvalues and eigenprojectors
	ncp := len(a)
	λ := make([]float64, 3)
	P := la.MatAlloc(3, ncp)
	err := M_EigenValsProjsNum(P, λ, a)
	if err != nil {
		chk.Panic("eigenprojs.go: CheckEigenprojs failed:\n %v", err.Error())
	}

	// print projectors
	if ver {
		la.PrintVec("P0", P[0], "%14.6e", false)
		la.PrintVec("P1", P[1], "%14.6e", false)
		la.PrintVec("P2", P[2], "%14.6e", false)
	}

	// check P dot P
	PdotP := make([]float64, ncp)
	Z := make([]float64, ncp)
	for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			err := M_Dot(PdotP, P[i], P[j], 1e-14)
			if err != nil {
				chk.Panic("%v", err)
			}
			if i == j {
				diff := la.VecMaxDiff(PdotP, P[i])
				if diff > tolP {
					chk.Panic("eigenprojs.go: CheckEigenprojs failed: P%d dot P%d != P%d (diff=%g)", i, j, i, diff)
				} else if ver {
					io.Pf("P%d dot P%d == P%d OK (diff=%g)\n", i, j, i, diff)
				}
			} else {
				diff := la.VecMaxDiff(PdotP, Z)
				if diff > tolP {
					chk.Panic("eigenprojs.go: CheckEigenprojs failed: P%d dot P%d !=  0 (diff=%g)", i, j, diff)
				} else if ver {
					io.Pf("P%d dot P%d ==  0 OK (diff=%g)\n", i, j, diff)
				}
			}
		}
	}

	// check sum of eigenprojectors
	sumP := make([]float64, ncp)
	for k := 0; k < 3; k++ {
		for i := 0; i < ncp; i++ {
			sumP[i] += P[k][i]
		}
	}
	diff := la.VecMaxDiff(sumP, Im[:ncp])
	if diff > tolP {
		chk.Panic("eigenprojs.go: CheckEigenprojs failed: sumP != I (diff=%g)", diff)
	} else if ver {
		io.Pf("sum(P) OK (diff=%g)\n", diff)
	}

	// check spectral decomposition
	as := make([]float64, len(a))
	for k := 0; k < 3; k++ {
		for i := 0; i < len(a); i++ {
			as[i] += λ[k] * P[k][i]
		}
	}
	diff = la.VecMaxDiff(as, a)
	if diff > tolS {
		chk.Panic("eigenprojs.go: CheckEigenprojs failed: a(spectral) != a (diff=%g)", diff)
	} else if ver {
		io.Pf("a(spectral) == a OK (diff=%g)\n", diff)
	}

	// sort eigenvalues
	λsorted = make([]float64, 3)
	I := []int{0, 1, 2}
	I, λsorted, _, _, err = utl.SortQuadruples(I, λ, nil, nil, "x")
	if err != nil {
		chk.Panic("%v", err)
	}
	return
}