diff --git a/README.md b/README.md
index bf267c46e18f252f28cb66a788c08af445ebac11..c1869f1f1d92d035fac176f475e81d0e7af5f2e2 100644
--- a/README.md
+++ b/README.md
@@ -351,6 +351,47 @@ The IFOs included in `gwinc.ifo` provide examples of the use of the
budget interface (e.g. [gwinc.ifo.aLIGO](gwinc/ifo/aLIGO)).
+### "precomp" functions
+
+`BudgetItems` support "precomp" functions that are calculated during
+the `update()` method call and can be used to cache common derived
+values in the `ifo` struct for later use. The execution state of
+these functions is cached at the Budget level, to prevent needlessly
+re-calculating them in multiple BudgetItems. When they are calculated
+they are provided with the `freq` and `ifo` attributes as arguments.
+For example, take the following budget definition:
+```python
+
+class Noise0(Noise):
+ precomp = [
+ precomp_foo,
+ ]
+ ...
+
+class Noise1(Noise):
+ precomp = [
+ precomp_foo,
+ precomp_bar,
+ ]
+ ...
+
+class MyBudget(Budget):
+ noises = [
+ Noise0,
+ Noise1,
+ ]
+```
+When the `MyBudget.update()` method is called, all the `precomp`
+functions will be execute:
+```python
+precomp_foo(self.freq, self.ifo)
+precomp_bar(self.freq, self.ifo)
+```
+But the `precomp_foo` function will only be calculated once per budget
+update() call, even though it's specified as needed by both `Noise0`
+and `Noise1`.
+
+
### extracting single noise terms
There are various way to extract single noise terms from the Budget
diff --git a/gwinc/ifo/__main__.py b/gwinc/ifo/__main__.py
index 84f5f1b08ad11303ad7d5ec278757c863394f251..1da5c7c0a65ce61ce665c1d3af6b6d40324c01fd 100644
--- a/gwinc/ifo/__main__.py
+++ b/gwinc/ifo/__main__.py
@@ -35,6 +35,7 @@ def main():
range_pad = max(len(name), range_pad)
for name, budget in budgets.items():
+ budget.update()
data = budget.calc()
try:
import inspiral_range
diff --git a/gwinc/ifo/noises.py b/gwinc/ifo/noises.py
index 06770cf4b3aba292d9872717078f286903fc27ea..88c701559312aa325bd249825e605da9c88a1dcd 100644
--- a/gwinc/ifo/noises.py
+++ b/gwinc/ifo/noises.py
@@ -127,15 +127,6 @@ def precomp_mirror(f, ifo):
* ifo.Materials.Substrate.MassDensity
-def precomp_gwinc(f, ifo):
- ifo.gwinc = Struct()
- pbs, parm, finesse, prfactor, Tpr = ifo_power(ifo)
- ifo.gwinc.pbs = pbs
- ifo.gwinc.parm = parm
- ifo.gwinc.finesse = finesse
- ifo.gwinc.prfactor = prfactor
-
-
def precomp_suspension(f, ifo):
if 'VHCoupling' not in ifo.Suspension:
ifo.Suspension.VHCoupling = Struct()
@@ -146,6 +137,31 @@ def precomp_suspension(f, ifo):
ifo.Suspension.hTable = hTable
ifo.Suspension.vTable = vTable
+
+def precomp_coating(f, ifo):
+ ifo.Optics.ITM.dOpt = coating_thickness(ifo, 'ITM')
+ ifo.Optics.ETM.dOpt = coating_thickness(ifo, 'ETM')
+
+
+def precomp_power(f, ifo):
+ if 'gwinc' not in ifo:
+ ifo.gwinc = Struct()
+ pbs, parm, finesse, prfactor, Tpr = ifo_power(ifo)
+ ifo.gwinc.pbs = pbs
+ ifo.gwinc.parm = parm
+ ifo.gwinc.finesse = finesse
+ ifo.gwinc.gPhase = finesse * 2/np.pi
+ ifo.gwinc.prfactor = prfactor
+
+
+def precomp_cavity(f, ifo):
+ if 'gwinc' not in ifo:
+ ifo.gwinc = Struct()
+ w0, wBeam_ITM, wBeam_ETM = arm_cavity(ifo)
+ ifo.gwinc.w0 = w0
+ ifo.gwinc.wBeam_ITM = wBeam_ITM
+ ifo.gwinc.wBeam_ETM = wBeam_ETM
+
##################################################
class Strain(nb.Calibration):
@@ -164,9 +180,12 @@ class QuantumVacuum(nb.Noise):
color='#ad03de',
)
+ precomp = [
+ precomp_mirror,
+ precomp_power,
+ ]
+
def calc(self):
- precomp_mirror(self.freq, self.ifo)
- precomp_gwinc(self.freq, self.ifo)
return noise.quantum.shotrad(self.freq, self.ifo)
@@ -193,8 +212,11 @@ class Seismic(nb.Noise):
color='#855700',
)
+ precomp = [
+ precomp_suspension,
+ ]
+
def calc(self):
- precomp_suspension(self.freq, self.ifo)
if 'PlatformMotion' in self.ifo.Seismic:
if self.ifo.Seismic.PlatformMotion == 'BSC':
nt, nr = noise.seismic.seismic_BSC_ISI(self.freq)
@@ -275,8 +297,11 @@ class SuspensionThermal(nb.Noise):
color='#0d75f8',
)
+ precomp = [
+ precomp_suspension,
+ ]
+
def calc(self):
- precomp_suspension(self.freq, self.ifo)
n = noise.suspensionthermal.suspension_thermal(self.freq, self.ifo.Suspension)
return n * 4
@@ -290,16 +315,20 @@ class CoatingBrownian(nb.Noise):
color='#fe0002',
)
+ precomp = [
+ precomp_cavity,
+ precomp_coating,
+ ]
+
def calc(self):
wavelength = self.ifo.Laser.Wavelength
materials = self.ifo.Materials
- w0, wBeam_ITM, wBeam_ETM = arm_cavity(self.ifo)
- dOpt_ITM = coating_thickness(self.ifo, 'ITM')
- dOpt_ETM = coating_thickness(self.ifo, 'ETM')
nITM = noise.coatingthermal.coating_brownian(
- self.freq, materials, wavelength, wBeam_ITM, dOpt_ITM)
+ self.freq, materials, wavelength,
+ self.ifo.gwinc.wBeam_ITM, self.ifo.Optics.ITM.dOpt)
nETM = noise.coatingthermal.coating_brownian(
- self.freq, materials, wavelength, wBeam_ETM, dOpt_ETM)
+ self.freq, materials, wavelength,
+ self.ifo.gwinc.wBeam_ETM, self.ifo.Optics.ETM.dOpt)
return (nITM + nETM) * 2
@@ -313,16 +342,20 @@ class CoatingThermoOptic(nb.Noise):
linestyle='--',
)
+ precomp = [
+ precomp_cavity,
+ precomp_coating,
+ ]
+
def calc(self):
wavelength = self.ifo.Laser.Wavelength
materials = self.ifo.Materials
- w0, wBeam_ITM, wBeam_ETM = arm_cavity(self.ifo)
- dOpt_ITM = coating_thickness(self.ifo, 'ITM')
- dOpt_ETM = coating_thickness(self.ifo, 'ETM')
nITM, junk1, junk2, junk3 = noise.coatingthermal.coating_thermooptic(
- self.freq, materials, wavelength, wBeam_ITM, dOpt_ITM[:])
+ self.freq, materials, wavelength,
+ self.ifo.gwinc.wBeam_ITM, self.ifo.Optics.ITM.dOpt[:])
nETM, junk1, junk2, junk3 = noise.coatingthermal.coating_thermooptic(
- self.freq, materials, wavelength, wBeam_ETM, dOpt_ETM[:])
+ self.freq, materials, wavelength,
+ self.ifo.gwinc.wBeam_ETM, self.ifo.Optics.ETM.dOpt[:])
return (nITM + nETM) * 2
@@ -336,13 +369,15 @@ class ITMThermoRefractive(nb.Noise):
linestyle='--',
)
+ precomp = [
+ precomp_power,
+ precomp_cavity,
+ ]
+
def calc(self):
- finesse = ifo_power(self.ifo)[2]
- gPhase = finesse * 2/np.pi
- w0, wBeam_ITM, wBeam_ETM = arm_cavity(self.ifo)
n = noise.substratethermal.substrate_thermorefractive(
- self.freq, self.ifo.Materials, wBeam_ITM)
- return n * 2 / gPhase**2
+ self.freq, self.ifo.Materials, self.ifo.gwinc.wBeam_ITM)
+ return n * 2 / self.ifo.gwinc.gPhase**2
class ITMCarrierDensity(nb.Noise):
@@ -355,13 +390,15 @@ class ITMCarrierDensity(nb.Noise):
linestyle='--',
)
+ precomp = [
+ precomp_power,
+ precomp_cavity,
+ ]
+
def calc(self):
- finesse = ifo_power(self.ifo)[2]
- gPhase = finesse * 2/np.pi
- w0, wBeam_ITM, wBeam_ETM = arm_cavity(self.ifo)
n = noise.substratethermal.substrate_carrierdensity(
- self.freq, self.ifo.Materials, wBeam_ITM)
- return n * 2 / gPhase**2
+ self.freq, self.ifo.Materials, self.ifo.gwinc.wBeam_ITM)
+ return n * 2 / self.ifo.gwinc.gPhase**2
class SubstrateBrownian(nb.Noise):
@@ -374,12 +411,15 @@ class SubstrateBrownian(nb.Noise):
linestyle='--',
)
+ precomp = [
+ precomp_cavity,
+ ]
+
def calc(self):
- w0, wBeam_ITM, wBeam_ETM = arm_cavity(self.ifo)
nITM = noise.substratethermal.substrate_brownian(
- self.freq, self.ifo.Materials, wBeam_ITM)
+ self.freq, self.ifo.Materials, self.ifo.gwinc.wBeam_ITM)
nETM = noise.substratethermal.substrate_brownian(
- self.freq, self.ifo.Materials, wBeam_ETM)
+ self.freq, self.ifo.Materials, self.ifo.gwinc.wBeam_ETM)
return (nITM + nETM) * 2
@@ -393,12 +433,15 @@ class SubstrateThermoElastic(nb.Noise):
linestyle='--',
)
+ precomp = [
+ precomp_cavity,
+ ]
+
def calc(self):
- w0, wBeam_ITM, wBeam_ETM = arm_cavity(self.ifo)
nITM = noise.substratethermal.substrate_thermoelastic(
- self.freq, self.ifo.Materials, wBeam_ITM)
+ self.freq, self.ifo.Materials, self.ifo.gwinc.wBeam_ITM)
nETM = noise.substratethermal.substrate_thermoelastic(
- self.freq, self.ifo.Materials, wBeam_ETM)
+ self.freq, self.ifo.Materials, self.ifo.gwinc.wBeam_ETM)
return (nITM + nETM) * 2
diff --git a/gwinc/nb.py b/gwinc/nb.py
index 437baea5b52d911730f86694d7c21edbfb47c4e4..2680862aceeb7c2e751672a0f352674c0d14e749 100644
--- a/gwinc/nb.py
+++ b/gwinc/nb.py
@@ -31,15 +31,44 @@ class BudgetItem:
"""
return None
- def update(self, **kwargs):
- """Overload method for updating data.
+ def update(self, _precomp=None, **kwargs):
+ """Update parameters and execute precomp functions.
- By default any keyword arguments provided are written directly
- as attribute variables (as with __init__).
+ The method does two things. First, any keyword arguments
+ provided are written directly as attribute variables to the
+ class (as with __init__).
+
+ Second, after attribute update, all functions listed in the
+ `precomp` attribute are executed, supplied with the `freq` and
+ `ifo` attributes. So if the `precomp` attribute is defined
+ as:
+
+ precomp = [precomp_foo, precomp_bar]
+
+ then this method will execute the following after attribute
+ update:
+
+ precomp_foo(self.freq, self.ifo)
+ precomp_bar(self.freq, self.ifo)
+
+ These functions are intended to update the `ifo` Struct
+ attribute with derived values cached for later usage. If the
+ `_precomp` argument is provided to this method then it is
+ assumed to be a set of previously executed precomp functions,
+ and any function already listed there will not be re-executed,
+ and it will be updated with any newly executed functions.
"""
for key, val in kwargs.items():
setattr(self, key, val)
+ for func in getattr(self, 'precomp', []):
+ if _precomp is None:
+ _precomp = set()
+ if func in _precomp:
+ continue
+ logger.debug("precomp {}".format(func))
+ func(self.freq, self.ifo)
+ _precomp.add(func)
def calc(self):
"""Overload method for final PSD calculation.
@@ -361,13 +390,15 @@ class Budget(Noise):
logger.debug("load {}".format(item))
item.load()
- def update(self, **kwargs):
+ def update(self, _precomp=None, **kwargs):
"""Update all noise and cal objects with supplied kwargs."""
+ if _precomp is None:
+ _precomp = set()
for name, item in itertools.chain(
self._cal_objs.items(),
self._noise_objs.items()):
logger.debug("update {}".format(item))
- item.update(**kwargs)
+ item.update(_precomp=_precomp, **kwargs)
def calc_noise(self, name):
"""Return calibrated individual noise term.