def main():
numpy.seterr(all="ignore")
A = parseargs()
if A.serial:
sharedmem.set_debug(True)
fullname = "commands." + A.command
module = __import__(fullname, fromlist=["main"])
module.main(A)
def main(config):
global cov
DB = BootstrapDB(config)
MASK = DB.dummy.imesh >= 0
MASK &= DB.dummy.rmesh <= config.rmax
MASK &= DB.dummy.rmesh >= config.rmin
print "dof in fitting", MASK.sum()
# create a dummy to test the fitting
p0 = [-0.2, 3.5, 1.5, 1.5]
eigenmodes = DB.eigenmodes
dummy = eigenmodes(p0)
covfull = numpy.load(config.CovarianceMatrixOutput)["cov"]
cov = covfull[MASK][:, MASK]
print "inverting"
INV = linalg.inv(covfull[MASK][:, MASK])
print "inverted"
x, chi = fit1(dummy, eigenmodes, INV, MASK)
print "x =", x
print "p0 = bF, bQ, BF, BQ", p0
error = poles_err(dummy, covfull)
fitted = sharedmem.empty((len(DB), len(p0)))
chi = sharedmem.empty((len(DB)))
samples, models = [], []
sharedmem.set_debug(True)
def work(i):
sample = DB(i)
print "fitting", i
fitted[i], chi[i] = fit1(sample, eigenmodes, INV, MASK)
model = eigenmodes(fitted[i])
print zip(sample[0].monopole, model[0].monopole)
return i, sample, model
def reduce(rt):
i, s, m = rt
samples.append((i, s))
models.append((i, m))
chunkmap(work, range(len(DB)), 100, reduce=reduce)
samples = [s for i, s in sorted(samples)]
models = [s for i, s in sorted(models)]
numpy.savez("fit.npz", samples=samples, models=models, fittedparameters=fitted, chi=chi, error=error)
def test_wordcount():
"""
An example word counting program. The parallelism is per line.
In reality, the parallelism shall be at least on a file level to
benefit from sharedmem / multiprocessing.
"""
word_count = {
'sharedmem': 0,
'pool': 0,
}
with sharedmem.MapReduce() as pool:
def work(line):
# create a fresh local counter dictionary
my_word_count = dict([(word, 0) for word in word_count])
for word in line.replace('.', ' ').split():
if word in word_count:
my_word_count[word] += 1
return my_word_count
def reduce(her_word_count):
for word in word_count:
word_count[word] += her_word_count[word]
pool.map(work, file(__file__, 'r').readlines(), reduce=reduce)
parallel_result = dict(word_count)
# establish the ground truth from the sequential counter
sharedmem.set_debug(True)
for word in word_count:
word_count[word] = 0
pool.map(work, file(__file__, 'r').readlines(), reduce=reduce)
sharedmem.set_debug(False)
for word in word_count:
assert word_count[word] == parallel_result[word]
def test_wordcount():
"""
An example word counting program. The parallelism is per line.
In reality, the parallelism shall be at least on a file level to
benefit from sharedmem / multiprocessing.
"""
word_count = {
'sharedmem': 0,
'pool': 0,
}
with sharedmem.MapReduce() as pool:
def work(line):
# create a fresh local counter dictionary
my_word_count = dict([(word, 0) for word in word_count])
for word in line.replace('.', ' ').split():
if word in word_count:
my_word_count[word] += 1
return my_word_count
def reduce(her_word_count):
for word in word_count:
word_count[word] += her_word_count[word]
pool.map(work, open(__file__, 'r').readlines(), reduce=reduce)
parallel_result = dict(word_count)
# establish the ground truth from the sequential counter
sharedmem.set_debug(True)
for word in word_count:
word_count[word] = 0
pool.map(work, open(__file__, 'r').readlines(), reduce=reduce)
sharedmem.set_debug(False)
for word in word_count:
assert word_count[word] == parallel_result[word]
