def test_list_ordering(self):
a = num.random.rand(10).reshape((5, 2))
b = num.random.rand(5).reshape((5, 1))
c = num.random.rand(1).reshape((1, 1))
ta = tt.matrix('a')
tb = tt.matrix('b')
tc = tt.matrix('c')
ta.tag.test_value = a
tb.tag.test_value = b
tc.tag.test_value = c
tvars = [ta, tb, tc]
with self.assertRaises(KeyError):
ordering = utility.ListArrayOrdering(tvars)
ordering['b']
lordering = utility.ListArrayOrdering(tvars, 'tensor')
lordering['b'].slc
for var in ordering:
print var
lpoint = [a, b, c]
lij = utility.ListToArrayBijection(lordering, lpoint)
ref_point = {'a': a, 'b': b, 'c': c}
array = lij.l2a(lpoint)
point = lij.l2d(lpoint)
print 'arr', array
#print 'point, ref_point', point, ref_point
print lij.l2d(lij.a2l(array))
def __init__(self, vars, out_vars, shared, blocked=True):
self.vars = vars
self.ordering = ArrayOrdering(vars)
self.lordering = utility.ListArrayOrdering(out_vars, intype='tensor')
lpoint = [var.tag.test_value for var in out_vars]
self.shared = {var.name: shared for var, shared in shared.items()}
self.blocked = blocked
self.bij = DictToArrayBijection(self.ordering, self.population[0])
self.lij = utility.ListToArrayBijection(self.lordering, lpoint)
def test_list_ordering(self):
a = num.random.rand(10).reshape((5, 2))
b = num.random.rand(5).reshape((5, 1))
c = num.random.rand(1).reshape((1, 1))
ta = tt.matrix('a')
tb = tt.matrix('b')
tc = tt.matrix('c')
ta.tag.test_value = a
tb.tag.test_value = b
tc.tag.test_value = c
tvars = [ta, tb, tc]
with self.assertRaises(KeyError):
ordering = utility.ListArrayOrdering(tvars)
ordering['b']
lordering = utility.ListArrayOrdering(tvars, 'tensor')
lordering['b'].slc
for var in ordering:
print(var)
def __init__(self, config):
logger.info('... Initialising Geometry Optimizer ... \n')
pc = config.problem_config
super(GeometryOptimizer, self).__init__(pc)
# Load event
if config.event is None:
if self._seismic_flag:
self.event = model.load_one_event(
os.path.join(
config.seismic_config.datadir, 'event.txt'))
else:
logger.warn('Found no event information!')
else:
self.event = config.event
# Init sources
self.sources = []
for i in range(pc.n_faults):
if self.event:
source = heart.RectangularSource.from_pyrocko_event(self.event)
# hardcoded inversion for hypocentral time
source.stf.anchor = -1.
else:
source = heart.RectangularSource()
self.sources.append(source)
dsources = utility.transform_sources(self.sources, pc.datasets)
if self._seismic_flag:
logger.debug('Setting up seismic structure ...\n')
sc = config.seismic_config
self.engine = gf.LocalEngine(
store_superdirs=[sc.gf_config.store_superdir])
seismic_data_path = os.path.join(
config.project_dir, bconfig.seismic_data_name)
stations, data_traces = utility.load_objects(
seismic_data_path)
stations = utility.apply_station_blacklist(stations, sc.blacklist)
self.stations = utility.weed_stations(
stations, self.event, distances=sc.distances)
self.data_traces = utility.weed_data_traces(
data_traces, self.stations)
target_deltat = 1. / sc.gf_config.sample_rate
if self.data_traces[0].deltat != target_deltat:
utility.downsample_traces(
self.data_traces, deltat=target_deltat)
self.stargets = heart.init_targets(
self.stations,
channels=sc.channels,
sample_rate=sc.gf_config.sample_rate,
crust_inds=[0], # always reference model
interpolation='multilinear')
self.ns_t = len(self.stargets)
logger.info('Number of seismic datasets: %i ' % self.ns_t)
if sc.calc_data_cov:
logger.info('Estimating seismic data-covariances ...\n')
cov_ds_seismic = cov.get_seismic_data_covariances(
data_traces=self.data_traces,
filterer=sc.filterer,
sample_rate=sc.gf_config.sample_rate,
arrival_taper=sc.arrival_taper,
engine=self.engine,
event=self.event,
targets=self.stargets)
else:
logger.info('No data-covariance estimation ...\n')
cov_ds_seismic = []
at = sc.arrival_taper
n_samples = int(num.ceil(
(num.abs(at.a) + at.d) * sc.gf_config.sample_rate))
for tr in self.data_traces:
cov_ds_seismic.append(
num.power(bconfig.default_seis_std, 2) * \
num.eye(n_samples))
self.sweights = []
for s_t in range(self.ns_t):
if self.stargets[s_t].covariance.data is None:
logger.debug(
'No data covariance given. Seting default: sigma2 * I')
self.stargets[s_t].covariance.data = cov_ds_seismic[s_t]
icov = self.stargets[s_t].covariance.inverse
self.sweights.append(shared(icov))
# syntetics generation
logger.debug('Initialising synthetics functions ... \n')
self.get_seis_synths = theanof.SeisSynthesizer(
engine=self.engine,
sources=dsources['seismic'],
targets=self.stargets,
event=self.event,
arrival_taper=sc.arrival_taper,
filterer=sc.filterer)
self.chop_traces = theanof.SeisDataChopper(
sample_rate=sc.gf_config.sample_rate,
traces=self.data_traces,
arrival_taper=sc.arrival_taper,
filterer=sc.filterer)
if self._geodetic_flag:
logger.debug('Setting up geodetic structure ...\n')
gc = config.geodetic_config
geodetic_data_path = os.path.join(
config.project_dir, bconfig.geodetic_data_name)
self.gtargets = utility.load_objects(geodetic_data_path)
self.ng_t = len(self.gtargets)
logger.info('Number of geodetic datasets: %i ' % self.ng_t)
# geodetic data
_disp_list = [self.gtargets[i].displacement
for i in range(self.ng_t)]
_lons_list = [self.gtargets[i].lons for i in range(self.ng_t)]
_lats_list = [self.gtargets[i].lats for i in range(self.ng_t)]
_odws_list = [self.gtargets[i].odw for i in range(self.ng_t)]
_lv_list = [self.gtargets[i].update_los_vector()
for i in range(self.ng_t)]
if gc.calc_data_cov:
logger.info('Using data covariance!')
else:
logger.info('No data-covariance estimation ...\n')
for g_t in self.gtargets:
g_t.covariance.data = num.power(
bconfig.default_geo_std, 2) * \
num.eye(g_t.lats.size)
self.gweights = []
for g_t in range(self.ng_t):
icov = self.gtargets[g_t].covariance.inverse
self.gweights.append(shared(icov))
# merge geodetic data to call pscmp only once each forward model
ordering = utility.ListArrayOrdering(_disp_list, intype='numpy')
self.Bij = utility.ListToArrayBijection(ordering, _disp_list)
odws = self.Bij.fmap(_odws_list)
lons = self.Bij.fmap(_lons_list)
lats = self.Bij.fmap(_lats_list)
logger.info('Number of geodetic data points: %i ' % lats.shape[0])
self.wdata = shared(self.Bij.fmap(_disp_list) * odws)
self.lv = shared(self.Bij.f3map(_lv_list))
self.odws = shared(odws)
# syntetics generation
logger.debug('Initialising synthetics functions ... \n')
self.get_geo_synths = theanof.GeoLayerSynthesizerStatic(
lats=lats,
lons=lons,
store_superdir=gc.gf_config.store_superdir,
crust_ind=0, # always reference model
sources=dsources['geodetic'])
self.config = config