prepare for derivedParam auto dependencies

engine/anisotropy.go

@@ -20,35 +20,41 @@ var (
 	B_anis     = NewVectorField("B_anis", "T", "Anisotropy filed", AddAnisotropyField)
 	Edens_anis = NewScalarField("Edens_anis", "J/m3", "Anisotropy energy density", AddAnisotropyEnergyDensity)
 	E_anis     = NewScalarValue("E_anis", "J", "total anisotropy energy", GetAnisotropyEnergy)
+)
 
-	ku1_red, ku2_red          derivedParam // K / Msat
-	kc1_red, kc2_red, kc3_red derivedParam // K / Msat
-	zero                      param        // utility zero parameter
+var (
+	ku1_red DerivedParam
+	ku2_red DerivedParam
+	kc1_red DerivedParam
+	kc2_red DerivedParam
+	kc3_red DerivedParam
 )
 
+var zero param // utility zero parameter
+
 func init() {
 	registerEnergy(GetAnisotropyEnergy, AddAnisotropyEnergyDensity)
 	zero.init(1, "_zero", "", nil)
 
 	//ku1_red = Ku1 / Msat
-	ku1_red.init(SCALAR, []updater{Ku1, Msat}, func(p *derivedParam) {
+	ku1_red.init(SCALAR, []parent{Ku1, Msat}, func(p *DerivedParam) {
 		paramDiv(p.cpu_buf, Ku1.cpuLUT(), Msat.cpuLUT())
 	})
 	//ku2_red = Ku2 / Msat
-	ku2_red.init(SCALAR, []updater{Ku2, Msat}, func(p *derivedParam) {
+	ku2_red.init(SCALAR, []parent{Ku2, Msat}, func(p *DerivedParam) {
 		paramDiv(p.cpu_buf, Ku2.cpuLUT(), Msat.cpuLUT())
 	})
 
 	//kc1_red = Kc1 / Msat
-	kc1_red.init(SCALAR, []updater{Kc1, Msat}, func(p *derivedParam) {
+	kc1_red.init(SCALAR, []parent{Kc1, Msat}, func(p *DerivedParam) {
 		paramDiv(p.cpu_buf, Kc1.cpuLUT(), Msat.cpuLUT())
 	})
 	//kc2_red = Kc2 / Msat
-	kc2_red.init(SCALAR, []updater{Kc2, Msat}, func(p *derivedParam) {
+	kc2_red.init(SCALAR, []parent{Kc2, Msat}, func(p *DerivedParam) {
 		paramDiv(p.cpu_buf, Kc2.cpuLUT(), Msat.cpuLUT())
 	})
 	//kc3_red = Kc3 / Msat
-	kc3_red.init(SCALAR, []updater{Kc3, Msat}, func(p *derivedParam) {
+	kc3_red.init(SCALAR, []parent{Kc3, Msat}, func(p *DerivedParam) {
 		paramDiv(p.cpu_buf, Kc3.cpuLUT(), Msat.cpuLUT())
 	})
 }

engine/demag.go

@@ -12,7 +12,7 @@ import (
 var (
 	Msat = NewScalarParam("Msat", "A/m", "Saturation magnetization",
 		[]derived{&Bsat, &lex2, &din2, &dbulk2, &ku1_red, &ku2_red, &kc1_red, &kc2_red, &kc3_red, &temp_red})
-	Bsat        derivedParam
+	Bsat        DerivedParam
 	M_full      = NewVectorField("m_full", "A/m", "Unnormalized magnetization", SetMFull)
 	B_demag     = NewVectorField("B_demag", "T", "Magnetostatic field", SetDemagField)
 	Edens_demag = NewScalarField("Edens_demag", "J/m3", "Magnetostatic energy density", AddEdens_demag)
@@ -35,7 +35,7 @@ func init() {
 	registerEnergy(GetDemagEnergy, AddEdens_demag)
 
 	//Bsat = Msat * mu0
-	Bsat.init(SCALAR, []updater{Msat}, func(p *derivedParam) {
+	Bsat.init(SCALAR, []parent{Msat}, func(p *DerivedParam) {
 		Ms := Msat.cpuLUT()
 		for i, ms := range Ms[0] {
 			p.cpu_buf[0][i] = mag.Mu0 * ms

engine/parameter.go

@@ -35,6 +35,11 @@ func (p *param) Name() string     { return p.name }
 func (p *param) Unit() string     { return p.unit }
 func (p *param) Mesh() *data.Mesh { return Mesh() }
 
+func (p *param) addChild(c derived) {
+	// TODO: no duplicates
+	p.children = append(p.children, c)
+}
+
 func (p *param) update() {
 	if p.timestamp != Time {
 		changed := false
@@ -125,9 +130,9 @@ func (p *param) IsUniform() bool {
 func (p *param) average() []float64 { return qAverageUniverse(p) }
 
 // parameter derived from others (not directly settable). E.g.: Bsat derived from Msat
-type derivedParam struct {
+type DerivedParam struct {
 	lut                          // GPU storage
-	updater  func(*derivedParam) // called to update my value
+	updater  func(*DerivedParam) // called to update my value
 	uptodate bool                // cleared if parents' value change
 	parents  []updater           // parents updated before I'm updated
 }
@@ -137,17 +142,34 @@ type derived interface {
 	invalidate()
 }
 
-func (p *derivedParam) init(nComp int, parents []updater, updater func(*derivedParam)) {
+type parent interface {
+	update()
+	addChild(derived)
+}
+
+func NewDerivedParam(nComp int, parents []parent, updater func(*DerivedParam)) *DerivedParam {
+	p := new(DerivedParam)
 	p.lut.init(nComp, p) // pass myself to update me if needed
 	p.updater = updater
-	p.parents = parents
+	for _, P := range parents {
+		p.parents = append(p.parents, P)
+	}
+	return p
+}
+
+func (p *DerivedParam) init(nComp int, parents []parent, updater func(*DerivedParam)) {
+	p.lut.init(nComp, p) // pass myself to update me if needed
+	p.updater = updater
+	for _, P := range parents {
+		p.parents = append(p.parents, P)
+	}
 }
 
-func (p *derivedParam) invalidate() {
+func (p *DerivedParam) invalidate() {
 	p.uptodate = false
 }
 
-func (p *derivedParam) update() {
+func (p *DerivedParam) update() {
 	for _, par := range p.parents {
 		par.update() // may invalidate me
 	}
@@ -159,7 +181,7 @@ func (p *derivedParam) update() {
 }
 
 // Get value in region r.
-func (p *derivedParam) GetRegion(r int) []float64 {
+func (p *DerivedParam) GetRegion(r int) []float64 {
 	lut := p.cpuLUT() // updates me if needed
 	v := make([]float64, p.NComp())
 	for c := range v {

engine/temperature.go

@@ -10,7 +10,7 @@ import (
 
 var (
 	Temp        = NewScalarParam("Temp", "K", "Temperature", []derived{&temp_red})
-	temp_red    derivedParam // reduced temperature = (alpha * Temp) / (mu0 * Msat)
+	temp_red    DerivedParam // reduced temperature = (alpha * Temp) / (mu0 * Msat)
 	E_therm     = NewScalarValue("E_therm", "J", "Thermal energy", GetThermalEnergy)
 	Edens_therm = NewScalarField("Edens_therm", "J/m3", "Thermal energy density", AddThermalEnergyDensity)
 	B_therm     thermField // Thermal effective field (T)
@@ -34,7 +34,7 @@ func init() {
 	DeclROnly("B_therm", &B_therm, "Thermal field (T)")
 
 	// reduced temperature = (alpha * T) / (mu0 * Msat)
-	temp_red.init(1, []updater{Alpha, Temp, Msat}, func(p *derivedParam) {
+	temp_red.init(1, []parent{Alpha, Temp, Msat}, func(p *DerivedParam) {
 		dst := temp_red.cpu_buf
 		alpha := Alpha.cpuLUT()
 		T := Temp.cpuLUT()