Commit 7778ae29 authored by Theo Steininger's avatar Theo Steininger

Adapted IMAGINE to newest version of HamX.

parent 1a2cb14e
......@@ -41,14 +41,9 @@ ENV HEALPIX /home/Downloads/Healpix_3.31
RUN pip install healpy
#Hammurabi
# RUN wget https://sourceforge.net/code-snapshots/svn/h/ha/hammurabicode/code/hammurabicode-code-41-trunk.zip
# RUN unzip hammurabicode-code-41-trunk.zip
# WORKDIR hammurabicode-code-41-trunk
RUN wget https://sourceforge.net/code-snapshots/svn/h/ha/hammurabicode/code/hammurabicode-code-60-trunk.zip
RUN unzip hammurabicode-code-60-trunk.zip
WORKDIR hammurabicode-code-60-trunk
COPY hammurabi_Makefile Makefile
RUN [ -r /root/.healpix/3_31_Linux/config ] && . /root/.healpix/3_31_Linux/config && make hammurabi && make clean
RUN git clone https://bitbucket.org/ricphy/hamx -b generic_makefile
WORKDIR hamx
RUN make
WORKDIR ..
#(Py)MultiNest
......@@ -101,5 +96,12 @@ WORKDIR ..
#hampy
RUN pip install jupyter pandas
#IMAGINE
RUN git clone https://gitlab.mpcdf.mpg.de/ift/IMAGINE.git -b master
WORKDIR IMAGINE
RUN python setup.py install
WORKDIR ..
#--------------------------------------------------------
#--------------------------------------------------------
#
# This is the hammurabi Makefile. The first part needs to be configured for your system.
#
# You can choose to build:
#
# hammurabi: by default, the basic hammurabi, pure C++, for constant or grid TEs and simple analytic models for CREs
# hammurabi.ne2001: including linking to the (smooth) NE2001 Fortran code using cfortran.h
# hammurabi.galprop: including both NE2001 and Galprop to simulate the CRE propagation with the hammurabi magnetic field first.
# hammurabi.debug: including all code, debug flags.
# all: builds all of these.
#
#--------------------------------------------------------
#--------------------------------------------------------
#
# Give the locations of the various libraries. Should containt include and lib subdirectories.
#
#BASE_DIR = $(HOME)/space/sw/
#HAMMURABI_HOME = $(BASE_DIR)/hammurabi/branches/mine
#GSL = $(BASE_DIR)/gsl/gsl-1.13/build/
#FFTW = $(BASE_DIR)/fftw/fftw-3.2.2/build/
#CFITSIO = $(BASE_DIR)/cfitsio/cfitsio/build/
BASE_DIR = /home/Downloads/hammurabicode-code
HAMMURABI_HOME = $(BASE_DIR)
GSL = /usr/local
FFTW = /usr/local
CFITSIO = /usr/local
#
# These are needed if you build with Galprop
#
GALPROP = $(BASE_DIR)/galprop/galprop/build
CCFITS = $(BASE_DIR)/ccfits/CCfits//build/
CLHEP = $(BASE_DIR)/clhep/clhep/build/
#
# What c++ compiler you are using?
#
CXX = g++
#
# On OSX, maybe
#CXX = g++-mp-5
#
# Compile options? 64bit system (-m64), optimization (-O2), openMP (-fopenmp), warnings (-Wall), etc.
#
CXXFLAGS = -m64 -O2 -fopenmp -Wall
#
# With OSX g++-mp-4.3
#CXXFLAGS = -fopenmp -O2 -g -fno-inline-functions -Wall -Wextra -Wno-unknown-pragmas -ansi
#
# Which Fortran compiler you are using? Only if compiling with NE2001 and/or Galprop
#
FC = gfortran
#
# On OSX, maybe
#FC = gfortran-mp-5
# For gfortran
FCFLAGS = -O2 -ffixed-form -ffixed-line-length-132 -c
#
# For ifort
#FCFLAGS =-O -extend-source -c
#
# For f77 ?
#FCFLAGS =
#
# For linking to C++ with gcc
#
LFORTFLAGS= -Df2cFortran
#
# Additional options depending on how you want to run:
#
# Use openMP. Right now, this is mandatory. (Contact
# trjaffe@gmail.com for help compiling without if for some reason you
# need it.)
LFLAGS_CUSTOM = -fopenmp
#
# OSX with gfortran-mp-4.3
#LFLAGS_CUSTOM = -fopenmp -lgcc_s.1
#
#
#
# For J. West using f77 and gcc 4.1.2?
#
#LFORTFLAGS += -L/usr/lib/gcc/x86_64-redhat-linux/3.4.6/ -lgcc -lg2c
#LFLAGS_CUSTOM += -lgcc_s
#------------------------------------------------------------
#------------------------------------------------------------
#
# From here onwards, nothing should need to be changed.
#
#------------------------------------------------------------
#------------------------------------------------------------
hammurabi.debug: CXXFLAGS=-m64 -g -Wall
hammurabi: ALL_INC = -I$(CFITSIO)/include -I$(GSL)/include -I. -I$(FFTW)/include -I$(HEALPIX)/src/cxx/$(HEALPIX_TARGET)/include/
hammurabi.ne2001: ALL_INC = -I$(CFITSIO)/include -I$(GSL)/include -I. -I$(FFTW)/include -I$(HEALPIX)/src/cxx/$(HEALPIX_TARGET)/include/
hammurabi.galprop: ALL_INC = -I$(CFITSIO)/include -I$(GALPROP)/.. -I$(GALPROP)/include/ -I$(CCFITS)/include/ -I$(CLHEP)/include -I$(GSL)/include -I. -I$(FFTW)/include -I$(HEALPIX)/src/cxx/$(HEALPIX_TARGET)/include/
hammurabi.debug: ALL_INC = -I$(CFITSIO)/include -I$(GALPROP)/.. -I$(GALPROP)/include/ -I$(CCFITS)/include/ -I$(CLHEP)/include -I$(GSL)/include -I. -I$(FFTW)/include -I$(HEALPIX)/src/cxx/$(HEALPIX_TARGET)/include/
libhamprop.a: ALL_INC = -I$(CFITSIO)/include -I$(GALPROP)/.. -I$(GALPROP)/include/ -I$(GSL)/include -I. -I$(FFTW)/include -I$(HEALPIX)/src/cxx/$(HEALPIX_TARGET)/include/
hammurabi: ALL_L = -L$(CFITSIO)/lib -L$(GSL)/lib -L$(FFTW)/lib -L$(HEALPIX)/src/cxx/$(HEALPIX_TARGET)/lib/ -L.
hammurabi.ne2001: ALL_L = -L$(CFITSIO)/lib -L$(GSL)/lib -L$(FFTW)/lib -L$(HEALPIX)/src/cxx/$(HEALPIX_TARGET)/lib/ -L.
hammurabi.galprop: ALL_L = -L$(CFITSIO)/lib -L$(GALPROP)/lib/ -L$(CCFITS)/lib/ -L$(CLHEP)/lib -L$(GSL)/lib -L$(FFTW)/lib -L$(HEALPIX)/src/cxx/$(HEALPIX_TARGET)/lib/ -L.
hammurabi.debug: ALL_L = -L$(CFITSIO)/lib -L$(GALPROP)/lib/ -L$(CCFITS)/lib/ -L$(CLHEP)/lib -L$(GSL)/lib -L$(FFTW)/lib -L$(HEALPIX)/src/cxx/$(HEALPIX_TARGET)/lib/ -L.
hammurabi : CXXFLAGS+= $(ALL_INC) -c
hammurabi.ne2001: CXXFLAGS+= $(ALL_INC) -c -DNE2001
hammurabi.galprop: CXXFLAGS+= $(ALL_INC) -c -DGALDEF_PATH=\"./GALDEF\" -DFITSDATA_PATH=\"./FITS/\" -DDATA_PATH=\"./DATA\" -DGALPROP -DNE2001
hammurabi.debug : CXXFLAGS+= $(ALL_INC) -c -DGALDEF_PATH=\"./GALDEF\" -DFITSDATA_PATH=\"./FITS/\" -DDATA_PATH=\"./DATA\" -DGALPROP -DNE2001 -g -Wall
# Turns off sanity check to avoid some circularity. See Galprop README.tess
libhamprop.a: CXXFLAGS+= $(ALL_INC) -c -DGALDEF_PATH=\"./GALDEF\" -DFITSDATA_PATH=\"./FITS/\" -DDATA_PATH=\"./DATA\" -DLIBHAMPROP -DGALPROP -DNE2001
hammurabi: LFLAGS = $(ALL_L) -lhammurabi -lhealpix_cxx -lcxxsupport -lc_utils -lfftpack -lcfitsio -lgsl -lgslcblas -lm -lfftw3 -lfftw3_omp $(LFLAGS_CUSTOM)
hammurabi.ne2001: LFLAGS = $(ALL_L) -lhammurabi -lNE2001 -lhealpix_cxx -lcxxsupport -lc_utils -lfftpack -lcfitsio -lgsl -lgslcblas -lm -lfftw3 -lfftw3_omp -lgfortran $(LFLAGS_CUSTOM)
hammurabi.debug: LFLAGS = $(ALL_L) -lhammurabi -lNE2001 -lhealpix_cxx -lcxxsupport -lc_utils -lfftpack -lcfitsio -lgsl -lgslcblas -lm -lfftw3 -lfftw3_omp -lgfortran -lgalprop -lskymap -lCCfits -lCLHEP $(LFLAGS_CUSTOM)
hammurabi.galprop: LFLAGS = $(ALL_L) -lhammurabi -lNE2001 -lhealpix_cxx -lcxxsupport -lc_utils -lfftpack -lcfitsio -lgsl -lgslcblas -lm -lfftw3 -lfftw3_omp -lgfortran -lgalprop -lskymap -lCCfits -lCLHEP $(LFLAGS_CUSTOM)
default:
make hammurabi
all:
make clean ; make hammurabi ; make clean ; make hammurabi.ne2001; make clean; make hammurabi.galprop ; make clean ; make hammurabi.debug
%.o : %.cpp
$(CXX) $(CXXFLAGS) -o $@ $<
%.o : %.cc
$(CXX) $(CXXFLAGS) -o $@ $<
%.o : %.c
$(CXX) $(CXXFLAGS) -o $@ $<
%.o : %.f
$(FC) $(FCFLAGS) -o $@ $<
class_TE_density.o: class_TE_density.cpp
$(CXX) $(CXXFLAGS) $(LFORTFLAGS) -o $@ $<
NE2001_OBJ = dmdsm.NE2001.o density.NE2001.o neclumpN.o nevoidN.o neLISM.NE2001.o
HAMMURABI_OBJ = class_Integrator.o class_List.o class_B_field2.o tess_tools.o class_TE_density.o class_CRE.o namespace_Vec_Handling.o class_Dust.o
run:
mkdir run
$(HAMMURABI_OBJ): hammurabi.h CGS_units_file.h proto*.h tess_tools.h
libNE2001.a: $(NE2001_OBJ)
ar rc $@ $(NE2001_OBJ)
ranlib $@
hammurabi: $(HAMMURABI_OBJ) libhammurabi.a run hammurabi.o
$(CXX) -o run/hammurabi hammurabi.o $(LFLAGS) $(LFORTFLAGS)
hammurabi.ne2001: $(HAMMURABI_OBJ) $(NE2001_OBJ) $(NE2001_DATA) libNE2001.a libhammurabi.a run hammurabi.o
$(CXX) -o run/hammurabi.ne2001 hammurabi.o $(LFLAGS) $(LFORTFLAGS)
hammurabi.galprop: $(HAMMURABI_OBJ) $(NE2001_OBJ) $(NE2001_DATA) libNE2001.a libhammurabi.a run hammurabi.o
$(CXX) -o run/hammurabi.galprop hammurabi.o $(LFLAGS) $(LFORTFLAGS)
hammurabi.debug: $(HAMMURABI_OBJ) $(NE2001_DATA) libNE2001.a libhammurabi.a run hammurabi.o
$(CXX) -o run/hammurabi.debug hammurabi.o $(LFLAGS) $(LFORTFLAGS)
ifeq ($(OSTYPE),darwin)
install_name_tool -change "@rpath/libCLHEP-2.3.3.1.dylib" "$(CLHEP)/lib/libCLHEP-2.3.3.1.dylib" run/hammurabi.debug
endif
print_constants: print_constants.o
$(CXX) -o run/print_constants print_constants.o
# To link in B_field to galprop, use this:
libhamprop.a: class_B_field2.o tess_tools.o namespace_Vec_Handling.o
ar cru libhamprop.a class_B_field2.o tess_tools.o namespace_Vec_Handling.o
libhammurabi.a: $(HAMMURABI_OBJ)
ar cru libhammurabi.a $(HAMMURABI_OBJ)
clean:
rm *.a *.o
test:
(cd unit_test; ./test.csh)
test_big:
(cd unit_test; ./test.csh big)
tarfile:
tar cvzf hammurabi.tgz *cpp *h Makefile *.f README hampy
unittar:
tar cvzf hammurabi_unit_test_inputs.tgz unit_test/inputs unit_test/GALDEF unit_test/FITS unit_test/negrid_n400.bin
tar cvzf hammurabi_unit_test_ref.tgz unit_test/ref unit_test/ref.big
tar cvzf hammurabi_unit_test_ref.mini.tgz unit_test/ref.mini
tar cvzf hammurabi_unit_test_ref.big.tgz unit_test/ref.big
......@@ -50,14 +50,16 @@ class EnsembleLikelihood(Likelihood):
u_val = obs_val - obs_mean
# compute quantities for OAS estimator
mu = np.vdot(u_val, u_val)*weight/n
mu = np.vdot(u_val, u_val)*weight/k
self.logger.debug("mu: %f" % mu)
alpha = (np.einsum(u_val, [0, 1], u_val, [2, 1])**2).sum()
# correct the volume factor: one factor comes from the internal scalar
# product and one from the trace
alpha *= weight**2
numerator = alpha + mu**2
denominator = (k + 1) * (alpha - (mu**2)/n)
numerator = (1 - 2./n)*alpha + mu**2
denominator = (k + 1 - 2./n) * (alpha - (mu**2)/n)
if denominator == 0:
rho = 1
......@@ -77,7 +79,7 @@ class EnsembleLikelihood(Likelihood):
"DiagonalOperator.")
A_bare_diagonal = data_covariance_operator.diagonal(bare=True)
A_bare_diagonal.val += rho*mu
A_bare_diagonal.val += rho*mu/n
A = DiagonalOperator(
domain=data_covariance_operator.domain,
diagonal=A_bare_diagonal,
......
......@@ -8,13 +8,13 @@ class WMAP3yrMagneticField(MagneticField):
@property
def descriptor_lookup(self):
lookup = \
{'b0': ('./Galaxy/MagneticField/Regular/WMAP/b0', 'value'),
'psi0': ('./Galaxy/MagneticField/Regular/WMAP/psi0', 'value'),
'psi1': ('./Galaxy/MagneticField/Regular/WMAP/psi1', 'value'),
'chi0': ('./Galaxy/MagneticField/Regular/WMAP/chi0', 'value'),
'random_rms': ('./Galaxy/MagneticField/Random/Iso/rms', 'value'),
'random_rho': ('./Galaxy/MagneticField/Random/Anisoglob/rho',
'value')}
{'b0': ['./Galaxy/MagneticField/Regular/WMAP/b0', 'value'],
'psi0': ['./Galaxy/MagneticField/Regular/WMAP/psi0', 'value'],
'psi1': ['./Galaxy/MagneticField/Regular/WMAP/psi1', 'value'],
'chi0': ['./Galaxy/MagneticField/Regular/WMAP/chi0', 'value'],
'random_rms': ['./Galaxy/MagneticField/Random/Iso/rms', 'value'],
'random_rho': ['./Galaxy/MagneticField/Random/Anisoglob/rho',
'value']}
return lookup
def _create_field(self):
......
This diff is collapsed.
# -*- coding: utf-8 -*-
from magnetic_field_model import MagneticFieldModel
from wmap3yr_mixin import WMAP3yrMixin
# -*- coding: utf-8 -*-
import abc
class MagneticFieldModel(object):
def update_parameter_xml(self, root):
pass
@abc.abstractproperty
def magnetic_field_class(self):
raise NotImplementedError
# -*- coding: utf-8 -*-
from .magnetic_field_model import MagneticFieldModel
from imagine.magnetic_fields.wmap3yr_magnetic_field import WMAP3yrMagneticField
class WMAP3yrMixin(object):
__parameter_dict = {('./Galaxy/MagneticField/Regular', 'type'): 'WMAP',
('./Galaxy/MagneticField/Random', 'cue'): '1',
('./Galaxy/MagneticField/Random', 'type'): 'Anisoglob',
}
class WMAP3yrMixin(MagneticFieldModel):
def update_parameter_xml(self, root):
custom_parameters = [
['./Galaxy/MagneticField/Regular', 'type', 'WMAP'],
['./Galaxy/MagneticField/Random', 'cue', '1'],
['./Galaxy/MagneticField/Random', 'type', 'Anisoglob']]
for parameter in custom_parameters:
root.find(parameter[0]).set(parameter[1], str(parameter[2]))
@property
def magnetic_field_class(self):
return WMAP3yrMagneticField
def _build_parameter_dict(self, parameter_dict, magnetic_field,
local_ensemble_index):
parameter_dict.update(self.__parameter_dict)
super(WMAP3yrMixin, self)._build_parameter_dict(parameter_dict,
magnetic_field,
local_ensemble_index)
# -*- coding: utf-8 -*-
from observable_mixin import ObservableMixin
from dm_mixin import DMMixin
from fd_mixin import FDMixin
from sync_mixin import SyncMixin
# -*- coding: utf-8 -*-
from mixin_base import MixinBase
import xml.etree.ElementTree as et
from .observable_mixin import ObservableMixin
class DMMixin(MixinBase):
class DMMixin(ObservableMixin):
@property
def __config_dict(self):
return {'obs_name': 'dm',
'component_names': ['dm'],
'parameter_dict_update': {('./Output/DM', 'cue'): '1'},
}
def obs_name(self):
return 'dm'
def _initialize_observable_dict(self, observable_dict, magnetic_field):
self._initialize_observable_dict_helper(observable_dict,
magnetic_field,
self.__config_dict)
super(DMMixin, self)._initialize_observable_dict(
observable_dict, magnetic_field)
def _build_parameter_dict(self, parameter_dict, magnetic_field,
local_ensemble_index):
parameter_dict.update(self.__config_dict['parameter_dict_update'])
super(DMMixin, self)._build_parameter_dict(parameter_dict,
magnetic_field,
local_ensemble_index)
@property
def component_names(self):
return ['dm']
def _fill_observable_dict(self, observable_dict, working_directory,
local_ensemble_index):
self._fill_observable_dict_helper(observable_dict,
working_directory,
local_ensemble_index,
self.__config_dict)
super(DMMixin, self)._fill_observable_dict(observable_dict,
working_directory,
local_ensemble_index)
def update_parameter_xml(self, root):
element = et.Element('DM', {'cue': '1',
'filename': self.obs_name+'.fits'})
output = root.find('Output')
output.append(element)
# -*- coding: utf-8 -*-
from mixin_base import MixinBase
import xml.etree.ElementTree as et
from .observable_mixin import ObservableMixin
class FDMixin(MixinBase):
class FDMixin(ObservableMixin):
@property
def __config_dict(self):
return {'obs_name': 'fd',
'component_names': ['fd'],
'parameter_dict_update': {('./Output/Faraday', 'cue'): '1'},
}
def obs_name(self):
return 'fd'
def _initialize_observable_dict(self, observable_dict, magnetic_field):
self._initialize_observable_dict_helper(observable_dict,
magnetic_field,
self.__config_dict)
super(FDMixin, self)._initialize_observable_dict(
observable_dict, magnetic_field)
def _build_parameter_dict(self, parameter_dict, magnetic_field,
local_ensemble_index):
parameter_dict.update(self.__config_dict['parameter_dict_update'])
super(FDMixin, self)._build_parameter_dict(parameter_dict,
magnetic_field,
local_ensemble_index)
@property
def component_names(self):
return ['fd']
def _fill_observable_dict(self, observable_dict, working_directory,
local_ensemble_index):
self._fill_observable_dict_helper(observable_dict,
working_directory,
local_ensemble_index,
self.__config_dict)
super(FDMixin, self)._fill_observable_dict(observable_dict,
working_directory,
local_ensemble_index)
def update_parameter_xml(self, root):
element = et.Element('Faraday', {'cue': '1',
'filename': self.obs_name+'.fits'})
output = root.find('Output')
output.append(element)
# -*- coding: utf-8 -*-
from nifty import HPSpace
from imagine.observables import Observable
class MixinBase(object):
def __init__(self, hammurabi_executable, input_directory='./input',
working_directory_base='.', nside=64):
self.__hpSpace = HPSpace(nside=int(nside))
super(MixinBase, self).__init__(hammurabi_executable,
input_directory,
working_directory_base,
nside)
@property
def __config_dict(self):
return {'obs_name': '',
'component_names': [],
'parameter_dict_update': {},
}
def _initialize_observable_dict(self, observable_dict, magnetic_field):
super(MixinBase, self)._initialize_observable_dict(
observable_dict, magnetic_field)
def _initialize_observable_dict_helper(self, observable_dict,
magnetic_field, config_dict):
component_names = config_dict['component_names']
ensemble_space = magnetic_field.domain[0]
for component in component_names:
# It is important to initialize the Observables with an explicit
# value. Otherwise the d2o will not instantaneuosly be created
# (c.f. lazy object creation).
observable_dict[component] = Observable(
val=0,
domain=(ensemble_space, self.__hpSpace),
distribution_strategy='equal')
def _build_parameter_dict(self, parameter_dict, magnetic_field,
local_ensemble_index):
super(MixinBase, self)._build_parameter_dict(parameter_dict,
magnetic_field,
local_ensemble_index)
def _fill_observable_dict(self, observable_dict, working_directory,
local_ensemble_index):
super(MixinBase, self)._fill_observable_dict(observable_dict,
working_directory,
local_ensemble_index)
def _fill_observable_dict_helper(self, observable_dict, working_directory,
local_ensemble_index, config_dict):
obs_name = config_dict['obs_name']
component_names = config_dict['component_names']
self.logger.debug('Reading %s-map.' % obs_name)
map_list = self._read_fits_file(path=working_directory,
name=obs_name + '.fits',
nside=self.nside)
for i, map_component in enumerate(map_list):
temp_obs = observable_dict[component_names[i]]
temp_obs.val.data[local_ensemble_index] = map_component
# -*- coding: utf-8 -*-
import abc
import os
import healpy
from keepers import Loggable
class ObservableMixin(Loggable, object):
@abc.abstractproperty
def obs_name(self):
raise NotImplementedError
@abc.abstractproperty
def component_names(self):
raise NotImplementedError
def update_parameter_xml(self):
raise NotImplementedError
def fill_observable_dict(self, observable_dict, working_directory,
local_ensemble_index, nside):
self.logger.debug('Reading %s-map.' % self.obs_name)
map_list = self._read_fits_file(path=working_directory,
name=self.obs_name + '.fits',
nside=nside)
for i, map_component in enumerate(map_list):
temp_obs = observable_dict[self.component_names[i]]
temp_obs.val.data[local_ensemble_index] = map_component
def _read_fits_file(self, path, name, nside):
map_path = os.path.join(path, name)
result_list = []
i = 0
while True:
try:
loaded_map = healpy.read_map(map_path, verbose=False,
field=i)
# loaded_map = healpy.ud_grade(loaded_map, nside_out=nside)
result_list += [loaded_map]
i += 1
except IndexError:
break
return result_list
# -*- coding: utf-8 -*-
from mixin_base import MixinBase
import xml.etree.ElementTree as et
from .observable_mixin import ObservableMixin
class SyncMixin(MixinBase):
@property
def __config_dict(self):
return {'obs_name': 'sync',
'component_names': ['sync_I', 'sync_Q', 'sync_U'],
'parameter_dict_update': {('./Output/Sync', 'cue'): '1'},
}
class SyncMixin(ObservableMixin):
def __init__(self, frequency='23'):
self.frequency = str(frequency)
def _initialize_observable_dict(self, observable_dict, magnetic_field):
self._initialize_observable_dict_helper(observable_dict,
magnetic_field,
self.__config_dict)
super(SyncMixin, self)._initialize_observable_dict(
observable_dict, magnetic_field)
@property
def obs_name(self):
return 'sync_' + self.frequency
def _build_parameter_dict(self, parameter_dict, magnetic_field,
local_ensemble_index):
parameter_dict.update(self.__config_dict['parameter_dict_update'])
super(SyncMixin, self)._build_parameter_dict(parameter_dict,
magnetic_field,
local_ensemble_index)
@property
def component_names(self):
return ['sync_I_' + self.frequency,
'sync_Q_' + self.frequency,
'sync_U_' + self.frequency]
def _fill_observable_dict(self, observable_dict, working_directory,
local_ensemble_index):
self._fill_observable_dict_helper(observable_dict,
working_directory,
local_ensemble_index,
self.__config_dict)
super(SyncMixin, self)._fill_observable_dict(observable_dict,
working_directory,
local_ensemble_index)
def update_parameter_xml(self, root):
element = et.Element('Sync', {'cue': '1',
'freq': self.frequency,
'filename': self.obs_name+'.fits'})
output = root.find('Output')
output.append(element)
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment