def test_closure(self):
     clos = Closure(6, 16, 2)
     self.assertEqual(clos.len(), 6, "incorrect length of closure")
     self.assertEqual(clos[0], 6)
     self.assertEqual(clos[1], 8)
     self.assertEqual(clos[clos.len() - 1], 16)
     clos2 = Closure(None, 10, 2)
     self.assertEqual(clos2.len(), math.inf,
                      "incorrect length for unbounded closure")
     with self.assertRaises(Exception):
         a = clos[8]
     with self.assertRaises(Exception):
         a = clos2[1]
     closWrong = Closure(7, 6, 12)
     self.assertEqual(closWrong.len(), 1)
Esempio n. 2
0
 def eval_internal(self, defs):
     """
     Evaluates this expression
     :param defs: Scope
     :return: Value of this expresson
     """
     return Closure(self, defs)
Esempio n. 3
0
    def eval(self, script):
        ret = self.getExpression(script)

        if isinstance(ret, IOperator):
            return ret

        ret = ret.eval(self)

        if isinstance(ret, IOperator):
            return Closure(self, ret)
        else:
            return ret
Esempio n. 4
0
 def collapseWithMissingArgs(self, missingArgs, parentsCollapsed):
     block = FunctionBlock()
     block._outputType = self.getOutputType()
     parentsInfo = {
         k: {
             'func': parent.getFunction(),
             'inputs': parent._inputTypes
         }
         for k, parent in parentsCollapsed.items()
     }
     # Get a mapping from function to parent inputs
     flattenedTypes = []
     missingArgsMapped = [self._inputTypes[k] for k in missingArgs]
     for parentInfo in parentsInfo.values():
         flattenedTypes += [
             inputType for inputType in parentInfo['inputs'].values()
         ]
     remap = []
     for k in missingArgs:
         remap.insert(k, {'func': lambda value: value, 'inputsLen': 1})
     for k, v in parentsInfo.items():
         remap.insert(k, {'func': v['func'], 'inputsLen': len(v['inputs'])})
     cur = 0
     for i in xrange(len(remap)):
         length = remap[i]['inputsLen']
         remap[i]['inputsLen'] = (cur, cur + length)
         cur += length
     # if parents aren't missing args, flattenedTypes is []
     newInputTypes = flattenedTypes + missingArgsMapped
     block._inputTypes = {
         i: newInputTypes[i]
         for i in xrange(len(newInputTypes))
     }
     # Join the functions for parents needing args + our function if we need an arg.
     selfFunc = self._func
     block._func = Closure(lambda *args: selfFunc(*([
         l['func']
         (*[args[i] for i in xrange(l['inputsLen'][0], l['inputsLen'][1])])
         for l in remap
     ])))
     return block
    corr.Write()
    graphup.Write()
    graphdown.Write()
    graphbinup.Write()
    graphbindown.Write()


setPlotStyle()
closures = {}
for fakeType, inputs in closure_inputs.items():
    input_files = inputs['Files']
    global_weights = inputs['Weights']
    treeEst = inputs['TreeEst']
    treeTrue = inputs['TreeTrue']

    closure = Closure()
    closure.fillData('True', input_files, treeTrue, 'mt', 'Weight',
                     global_weights)
    closure.fillData('Est', input_files, treeEst, 'mt', 'Weight',
                     global_weights)

    closure.computeCDF('True')
    closure.computeCDF('Est')
    forceLowMTLinearDistance(closure, 'True')
    forceLowMTLinearDistance(closure, 'Est')

    for name, bins in mt_bins.items():
        plotClosure(fakeType + '_' + name,
                    closure,
                    bins,
                    smoothWidth=0.1,
Esempio n. 6
0
    histoId = str(hash(str(mvis_bins[nominal])))
    clos = closure.data['True/Est']['Histo_{H}_Smooth'.format(H=histoId)]
    clos.SetName(name)
    output.cd()
    clos.Write()



setPlotStyle()
for fakeType,inputs in closure_inputs.items():
    input_files = inputs['Files']
    global_weights = inputs['Weights']
    treeEst    = inputs['TreeEst']
    treeTrue   = inputs['TreeTrue']

    closure = Closure()
    closure.fillData('True', input_files, treeTrue, 'mvis', 'Weight', global_weights)
    closure.fillData('Est', input_files, treeEst, 'mvis', 'Weight', global_weights)

    closure.computeCDF('True')
    closure.computeCDF('Est')

    for name,bins in mvis_bins.items():
        plotClosure(fakeType+'_'+name, closure, bins, doErrors=True)

    #for nbins in [100,50,25]:
        #cdf = closure.data['True']['CDFInvert']
        #bins = [cdf.Eval(i/float(nbins)) for i in xrange(nbins+1)]
        #plotClosure(fakeType+'_NBins'+str(nbins), closure, bins)

    plotSummary(fakeType, closure, 0, 600)
Esempio n. 7
0
 def __init__(self, *args, **kwargs):
     if 'outputType' in kwargs.keys():
         self.outputType = kwargs['outputType']
     super(FunctionBlock, self).__init__(*args, **kwargs)
     self._func = Closure(self._func)
Esempio n. 8
0
 def __init__(self, *args, **kwargs):
     self._outputType = 'ARG'
     self._func = Closure(self._func, self)
     if 'argType' in kwargs.keys():
         self._type = kwargs['argType']
     super(InputBlock, self).__init__(*args, **kwargs)