Exemplo n.º 1
0
 def loadJobItemResults(self, paramNameFile=None, bestfit=True, bestfitonly=False, noconverge=False, silent=False):
     self.result_converge = None
     self.result_marge = None
     self.result_likemarge = None
     self.result_bestfit = self.chainBestfit(paramNameFile)
     if not bestfitonly:
         marge_root = self.distRoot
         if self.getDistExists():
             if not noconverge: self.result_converge = ResultObjs.convergeStats(marge_root + '.converge')
             self.result_marge = ResultObjs.margeStats(marge_root + '.margestats', paramNameFile)
             self.result_likemarge = ResultObjs.likeStats(marge_root + '.likestats')
             if self.result_bestfit is not None and bestfit: self.result_marge.addBestFit(self.result_bestfit)
         elif not silent: print 'missing: ' + marge_root
Exemplo n.º 2
0
def compareTable(jobItems, titles=None):
    for jobItem in jobItems:
        jobItem.loadJobItemResults(paramNameFile=args.paramNameFile, bestfit=not args.nobestfit, bestfitonly=args.bestfitonly)
        print jobItem.name
    if titles is None: titles = [jobItem.datatag for jobItem in jobItems if jobItem.result_marge is not None]
    else: titles = titles.split(';')
    return ResultObjs.resultTable(1, [jobItem.result_marge for jobItem in jobItems if jobItem.result_marge is not None],
               formatter=formatter, limit=args.limit, titles=titles, blockEndParams=args.blockEndParams, paramList=args.paramList).lines
Exemplo n.º 3
0
def margeParamTex(rootname, params=None, limit=1, paramNameFile=None):
    """ Get tex snipped for constraint on parameters in params """
    if not '.margestats' in rootname: rootname += '.margestats'
    marge = ResultObjs.margeStats(rootname , paramNameFile)
    if not params: params = marge.list()

    formatter = ResultObjs.noLineTableFormatter()
    texs = []
    labels = []
    for par in params:
        tex = marge.texValues(formatter, par, limit=limit)
        if tex is not None:
            texs.append(tex[0])
            labels.append(marge.parWithName(par).label)
        else:
            texs.append(None)
            labels.append(None)

    return params, labels, texs
Exemplo n.º 4
0
def loadFiles(pat, max_files=400, cl_ix=1, calParam=None, rescale=1):
    d, name = os.path.split(pat + '_?_*')
    pars = []
    cls = []
    ls = None
    for f in os.listdir(d):
        if fnmatch.fnmatch(f, name + '.theory_cl'):
            fname = f.replace('.theory_cl', '')
            params = ResultObjs.bestFit(os.path.join(d, fname + '.pars'))
            pars.append(params)
            cl = loadtxt(os.path.join(d, fname + '.theory_cl'))
            if calParam:
                cal = params.parWithName(calParam).best_fit
            else:
                cal = 1
            cls.append(cl[:, cl_ix] / cal ** 2 * rescale)
            if ls is None: ls = cl[:, 0]
            if len(pars) == max_files: break
    if not len(pars): raise Exception('No files found: ' + pat)
    return ls, pars, cls
Exemplo n.º 5
0
Opts = batchJobArgs.batchArgs('Compare parameter constraints over set of models')
Opts.parser.add_argument('--params', nargs='+')
Opts.parser.add_argument('--chain_name_params', nargs='+')

Opts.parser.add_argument('--compare', nargs='+', default=None)
Opts.parser.add_argument('--nobestfits', action='store_true')
Opts.parser.add_argument('--single_extparam', action='store_true')
Opts.parser.add_argument('--limit', type=int, default=2)
Opts.parser.add_argument('--latex_filename', default=None)
Opts.parser.add_argument('--mathColumns', action='store_true')
Opts.parser.add_argument('--endline', default='\\cr')
Opts.parser.add_argument('--paramNameFile', default='clik_latex.paramnames')


(batch, args) = Opts.parseForBatch()
formatter = ResultObjs.tableFormatter()

names = paramNames.paramNames(args.paramNameFile)

if args.chain_name_params is None: args.chain_name_params = args.params

if args.compare: args.compare = [batch.normalizeDataTag(dat) for dat in args.compare]

table = dict()
paramtag_for_param = dict()
for par in args.params:
    paramtag_for_param[par] = []

for jobItem in Opts.filteredBatchItems():
    if (args.compare is None or jobItem.matchesDatatag(args.compare)) and (not args.single_extparam or
                                len(jobItem.param_set) == 1  and jobItem.hasParam(args.chain_name_params)):
Exemplo n.º 6
0
    sys.exit()

root = os.path.abspath(sys.argv[1])

pars = {'ombh2':'omegabh2', 'omch2':'omegach2', 'omnuh2':'omeganuh2', 'hubble':'H0', 'w':'w',
        'helium_fraction':'yheused', 'scalar_amp(1)':'A' , 'scalar_spectral_index(1)':'ns', 'scalar_nrun(1)':'nrun', 'initial_ratio(1)':'r',
        're_optical_depth':'tau', 're_delta_redshift':'deltazrei', 'massless_neutrinos':'nnu'}

ini = iniFile.iniFile()

ini.params['re_use_optical_depth'] = True
ini.params['temp_cmb'] = 2.7255
ini.params['CMB_outputscale'] = 2.7255e6 ** 2.
ini.defaults.append('params.ini')

bf = ResultObjs.bestFit(root + '.minimum', setParamNameFile=root + '.paramnames', want_fixed=True)

for camb, cosmomc in pars.items():
    par = bf.parWithName(cosmomc)
    if par is not None: ini.params[camb] = par.best_fit

ini.params['scalar_amp(1)'] = float(ini.params['scalar_amp(1)']) / 1e9

nmassive = 1
neffstandard = 3.046 / 3
ini.params['massless_neutrinos'] = float(ini.params['massless_neutrinos']) - neffstandard * nmassive
ini.params['massive_neutrinos'] = int(round(neffstandard * nmassive))
ini.params['nu_mass_degeneracies'] = neffstandard * nmassive
ini.params['share_delta_neff'] = False
ini.params['tensor_spectral_index(1)'] = -float(ini.params['initial_ratio(1)']) / 8
Exemplo n.º 7
0
 def R(self):
     if self.result_converge is None:
         fname = self.distRoot + '.converge'
         if not nonEmptyFile(fname): return None
         self.result_converge = ResultObjs.convergeStats(fname)
     return float(self.result_converge.worstR())
Exemplo n.º 8
0
 def chainBestfit(self, paramNameFile=None):
     bf_file = self.chainRoot + '.minimum'
     if nonEmptyFile(bf_file):
         return ResultObjs.bestFit(bf_file, paramNameFile)
     return None
Exemplo n.º 9
0
def getTableLines(content, referenceDataJobItem=None):
    if referenceDataJobItem is not None: refResults = referenceDataJobItem.result_marge
    else: refResults = None
    return ResultObjs.resultTable(args.columns, [content], blockEndParams=args.blockEndParams, formatter=formatter,
                                  paramList=args.paramList, limit=args.limit,
                                  refResults=refResults, shiftSigma_indep=args.shift_sigma_indep, shiftSigma_subset=args.shift_sigma_subset).lines
Exemplo n.º 10
0
                    elif args.changes_replacing is not None:
                        referenceDataJobItem = None
                        for replace in args.changes_replacing[1:]:
                            if replace in jobItem.data_set.names:
                                referenceDataJobItem = baseJobItems.get(
                                    batch.normalizeDataTag(jobItem.data_set.tagReplacing(replace, args.changes_replacing[0])), None)
                                break
                        referenceJobItem = referenceDataJobItem
                        if args.changes_only and not referenceDataJobItem: continue
                    else: referenceJobItem = baseJobItems.get(dataIndex(jobItem), None)
                    if args.changes_from_paramtag is not None:
                        referenceDataJobItem = referenceJobItem
                    if not args.forpaper: lines.append('\\subsection{ ' + texEscapeText(jobItem.name) + '}')
                    try:
                        tableLines = paramResultTable(jobItem, referenceJobItem, referenceDataJobItem)
                        if args.separate_tex: ResultObjs.textFile(tableLines).write(jobItem.distRoot + '.tex')
                        lines += tableLines
                    except Exception  as e:
                        print 'ERROR: ' + jobItem.name
                        print "Index Error:" + e.message

    if not args.forpaper: lines.append('\\end{document}')

    (outdir, outname) = os.path.split(outfile)
    if len(outdir) > 0 and not os.path.exists(outdir): os.makedirs(outdir)
    ResultObjs.textFile(lines).write(outfile)
    (root, _) = os.path.splitext(outfile)

    if not args.forpaper:
        print 'Now converting to PDF...'
        delext = ['aux', 'log', 'out', 'toc']
Exemplo n.º 11
0
 def formatTitle(self, title):
     return ResultObjs.texEscapeText(title)