Esempio n. 1
0
 def _generator(self):
     for path, data in self.meta['videos'].items():
         frames = set()
         for obj in data['objects'].values():
             frames.update(obj['frames'])
         for frame in frames:
             ifn = f'train/JPEGImages/{path}/{frame}.jpg'
             ofn = f'train/Annotations/{path}/{frame}.png'
             with self.zf.open(ifn) as fp:
                 im = utils.imdecode(fp)
             with self.zf.open(ofn) as fp:
                 mask = utils.imdecode(fp, 0)
             for c in np.unique(mask):
                 if c == 0:
                     continue
                 y = mask == c
                 y.dtype = 'uint8'
                 bbox = utils.find_bbox(y)
                 if not bbox:
                     continue
                 x = utils.get_object(im, bbox)
                 y = utils.get_object(y, bbox)
                 x.shape = (1,) + x.shape
                 y.shape = (1,) + y.shape + (1,)
                 yield x.astype('float32'), y.astype('float32')
Esempio n. 2
0
    def hist_getter_sig_will(self,sample=None,ID=None,sys=None,pt_bin=None,eta_bin=None,prongs=None,var=None,newname=None,antiID=None):
        if sample is None: sample = 'ZtautauTruth'
        if var is None: var = 'evtsel_tau_nTrackTotal'
        if prongs is None: prongs = 'inc'
        
        if prongs == 'inc': 
            h1P = self.hist_getter_sig_will(sample=sample,ID=ID,sys=sys,pt_bin=pt_bin,eta_bin=eta_bin,prongs='1P',var=var)
            hmP = self.hist_getter_sig_will(sample=sample,ID=ID,sys=sys,pt_bin=pt_bin,eta_bin=eta_bin,prongs='mP',var=var)
            if newname: h = h1P.Clone(newname)
            else: h = h1P.Clone()
            h.Add(hmP)
            return h

        IDtag = self.coepp_id_tag(ID)
        fname = self.filename_getter_sig(sys=sys,pt_bin=pt_bin,eta_bin=eta_bin,prongs=prongs,ID=ID)
        hname = 'h_%s_%s' % (var,sample)
        hpath = '%s/hists/%s' % (IDtag,hname)
        h = get_object(hpath,fname)
        if newname: 
            h = h.Clone(newname)
        if antiID: 
            hanti = self.hist_getter_sig_will(sample=sample,ID=antiID,sys=sys,pt_bin=pt_bin,eta_bin=eta_bin,prongs=prongs,var=var)
            h = hist_subtract_correlated(h,hanti)

        
        ## signal systematics
        print 'in hist getter, sys: ', sys
        if sys in self.sig_sys:
            hbits = ['h']
            if   prongs == '1P': hbits += ['1p']
            elif prongs == 'mP': hbits += ['mp'] 
            hbits += ['total_tracks',
                     IDtag,
                     'Ztautau',
                     sys,
                     pt_bin,
                     eta_bin,
                     'ratio'
                     ]
            hname = '_'.join(hbits)
            fname = os.path.join(self.base_dir,self.filename_getter_sig_sys())
            hsys = get_object(hname,fname)
            for i in xrange(h.GetNbinsX()+1):
                c = hsys.GetBinContent(i)
                ec = hsys.GetBinError(i)
                if not 0.5 < c < 1.5: 
                    c = 1.
                    ec = 0.2
                n = h.GetBinContent(i)
                en = h.GetBinError(i)
                if n:
                    nnew = n*c
                    ennew = sqrt(pow(ec/c,2)+pow(en/n,2)) * nnew
                    #print 'bin%d, n: %.1f+-%.1f, c: %.3f+-%.3f, nnew: %.1f+-%.1f'%(i,n,en,c,ec,nnew,ennew)
                    h.SetBinContent(i,nnew)
                    h.SetBinError(i,ennew)
            #h.Multiply(hsys)

        return h
Esempio n. 3
0
 def get(self, request, project, pk):
     plan_obj = get_object(TestPlan, project, pk)
     if plan_obj.del_flag:
         return Response({'detail': unicode("Not found plan{}".format(pk))},
                         status=status.HTTP_400_BAD_REQUEST)
     serializer = TestPlanSerializer(plan_obj)
     return Response(serializer.data, status=status.HTTP_200_OK)
Esempio n. 4
0
 def get(self, request, project, pk):
     suite_obj = get_object(TestSuite, project, pk)
     if suite_obj.del_flag:
         return Response({'detail': unicode("Not found suite({})".format(pk))},
                         status=status.HTTP_400_BAD_REQUEST)
     serializer = TestsuiteSerializer(suite_obj)
     return Response(serializer.data, status=status.HTTP_200_OK)
Esempio n. 5
0
    def put(self, request, project, pk):
        serializer = PerDPDKTestcaseResultDetailSerializer(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors,
                            status=status.HTTP_400_BAD_REQUEST)

        try:
            key = serializer.validated_data['key']
            value = serializer.validated_data['value']
        except KeyError:
            return Response(
                {'detail': unicode("The lack of required parameters.")},
                status=status.HTTP_400_BAD_REQUEST)

        testcase_result_detail_obj = get_object(PerfDPDKTestCaseResultDetail,
                                                project, pk)
        if not check_app_attr(key, testcase_result_detail_obj.app, project):
            return Response(
                {
                    'detail':
                    unicode("app ({0}) not have attribute ({1})".format(
                        testcase_result_detail_obj.app.name, key.name))
                },
                status=status.HTTP_400_BAD_REQUEST)

        testcase_result_detail_obj.key = key
        testcase_result_detail_obj.value = value
        testcase_result_detail_obj.save()
        new_serializer = PerDPDKTestcaseResultDetailSerializer(
            testcase_result_detail_obj)
        return Response(new_serializer.data, status=status.HTTP_202_ACCEPTED)
Esempio n. 6
0
    def delete(self, request, project, pk):
        plan_obj = get_object(TestPlan, project, pk)
        plan_obj.del_flag = True
        plan_obj.testsuite_set.clear()
        plan_obj.save()

        return Response(status=status.HTTP_204_NO_CONTENT)
Esempio n. 7
0
    def put(self, request, project, pk):
        serializer = AppAttrSerializer(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors,
                            status=status.HTTP_400_BAD_REQUEST)
        attr_name = serializer.data['name']
        attr_list = AppAttr.objects.filter(
            name=serializer.validated_data['name'],
            app=serializer.validated_data['app'],
            project=get_project_object(project))

        length = len(attr_list)
        if length > 1 or (length == 1 and attr_list[0].id != pk):
            return Response(
                {
                    'detail':
                    unicode(
                        "Found same name attr, please check your attr name.")
                },
                status=status.HTTP_409_CONFLICT)

        attr_obj = get_object(AppAttr, project, pk)
        attr_obj.name = attr_name
        attr_obj.save()

        new_serializer = AppAttrSerializer(attr_obj)
        return Response(new_serializer.data, status=status.HTTP_202_ACCEPTED)
Esempio n. 8
0
 def get(self, request, project, pk):
     suiteresult_obj = get_object(PerfTestSuiteResult, project, pk)
     perf_caseresult_list = PerfDPDKTestCaseResult.objects.filter(
         perf_testsuite_result=suiteresult_obj)
     serializer = PerDPDKTestCaseResultSerializer(perf_caseresult_list,
                                                  many=True)
     return Response(serializer.data, status=status.HTTP_200_OK)
Esempio n. 9
0
    def delete(self, request, project, pk):
        case_obj = get_object(TestCase, project, pk)
        case_obj.del_flag = True
        case_obj.testsuite.clear()
        case_obj.save()

        return Response(status=status.HTTP_204_NO_CONTENT)
Esempio n. 10
0
    def delete(self, request, project, pk):
        myresult_obj = get_object(MySuiteResult, project, pk)
        myresult_obj.del_flag = True
        myresult_obj.testsuite_set.clear()
        myresult_obj.save()

        return Response(status=status.HTTP_204_NO_CONTENT)
Esempio n. 11
0
    def put(self, request, project, pk):
        serializer = TestcaseResultSerializer(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors,
                            status=status.HTTP_400_BAD_REQUEST)

        try:
            result = str(serializer.validated_data['result']).lower()
            bug = serializer.validated_data['bug']
            log = serializer.validated_data['log']
            comments = serializer.validated_data['comments']
        except KeyError:
            return Response(
                {'detail': unicode("The lack of required parameters.")},
                status=status.HTTP_400_BAD_REQUEST)

        caseresult_obj = get_object(TestCaseResult, project, pk)
        caseresult_obj.result = result
        caseresult_obj.bug = bug
        caseresult_obj.log = log
        caseresult_obj.comments = comments
        caseresult_obj.save()

        serializer = TestcaseResultSerializer(caseresult_obj)
        return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
Esempio n. 12
0
def main(fn):
    model = keras.models.load_model('weights.001.h5', compile=False)
    im = cv2.imread('00020.jpg')
    mask = cv2.imread('00020.png', 0)

    c = np.unique(mask)[0]
    y = mask == c
    y.dtype = 'uint8'
    bbox = utils.find_bbox(y)
    x = utils.get_object(im, bbox)
    y = utils.get_object(y, bbox)
    x.shape = (1,) + x.shape
    y.shape = (1,) + y.shape + (1,)
    x = x.astype('float32')
    masks = model.predict(x)
    cv2.imwrite('a.jpg', masks[0])
Esempio n. 13
0
    def put(self, request, project, pk):
        serializer = TestsuiteResultSerializer(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        try:
            #id = serializer.validated_data['id']
            testexecution=serializer.validated_data['testexecution']
            #id = serializer.validated_data['id']
            testsuite=serializer.validated_data['testsuite']
            passed=serializer.validated_data['passed']
            failed=serializer.validated_data['failed']
            block=serializer.validated_data['block']
            na =serializer.validated_data['na']
            total=serializer.validated_data['total']
            #time=serializer.validated_data['time']
        except KeyError:
            pass
	suiteresult_obj = get_object(TestPlan,project,pk)
        #suiteresult_obj.id=id
	suiteresult_obj.testexecution=testexecution
	suiteresult_obj.testsuite=testsuite
	suiteresult_obj.passed=passed
	suiteresult_obj.failed=failed
	suiteresult_obj.block=block
	suiteresult_obj.na=na
	suiteresult_obj.total=total
	suiteresult_obj.save()

        new_serializer = TestsuiteResultSerializer(suiteresult_obj)
        return Response(new_serializer.data, status=status.HTTP_202_ACCEPTED)
Esempio n. 14
0
    def put(self, request, project, pk):
        serializer = TestexecutionSerializer(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        try:
            name = serializer.validated_data['name']
            runner = serializer.validated_data['runner']
        except KeyError:
            return Response({'detail': unicode("The lack of required parameters.")},
                            status=status.HTTP_400_BAD_REQUEST)

        if not check_name_by_id(TestExecution, name, project, pk):
            return Response({'detail': unicode("Found same name testexecution_name, "
                                               "please check your testexecution_name name.")},
                            status=status.HTTP_409_CONFLICT)

        execution_obj = get_object(TestExecution, project, pk)
        if not check_owner_runner(execution_obj.runner, runner):
            return Response({'detail': unicode("The runner can not be changed.")},
                            status=status.HTTP_400_BAD_REQUEST)

        execution_obj.name = name
        execution_obj.runner = runner
        execution_obj.save()

        new_serializer = TestexecutionSerializer(execution_obj)
        return Response(new_serializer.data, status=status.HTTP_202_ACCEPTED)
Esempio n. 15
0
 def get(self, request, project, pk):
     caseresult_obj = get_object(PerfDPDKTestCaseResult, project, pk)
     casedetail_result_list = PerfDPDKTestCaseResultDetail.objects.filter(
         perf_dpdk_testcase_result=caseresult_obj)
     serializer = PerDPDKTestcaseResultDetailSerializer(
         casedetail_result_list, many=True)
     return Response(serializer.data, status=status.HTTP_200_OK)
Esempio n. 16
0
    def delete(self, request, project, pk):
        suite_obj = get_object(TestSuite, project, pk)
        suite_obj.del_flag = True
        suite_obj.testplan.clear()
        suite_obj.testcase_set.clear()
        suite_obj.save()

        return Response(status=status.HTTP_204_NO_CONTENT)
Esempio n. 17
0
    def get(self, request, project, pk):
        auth_status, message = check_auth(request.user, project, 'reader')
        if not auth_status:
            return Response(message, status=status.HTTP_401_UNAUTHORIZED)

        component_obj = get_object(Component, project, pk)
        serializer = FeatureComponentSerializer(component_obj)
        return Response(serializer.data, status=status.HTTP_200_OK)
Esempio n. 18
0
 def delete(self, request, project, pk):
     attr_obj = get_object(AppAttr, project, pk)
     app = App.objects.get(id=attr_obj.app_id)
     if app.testcase_set.count() or app.testsuite_set.count() or \
             app.testplan_set.count() or app.testexecution_set.count():
         return Response({'detail': unicode('This app has been used.')})
     else:
         attr_obj.delete()
         return Response(status=status.HTTP_204_NO_CONTENT)
Esempio n. 19
0
    def delete(self, request, project, pk):
        auth_status, message = check_auth(request.user, project, 'writer')
        if not auth_status:
            return Response(message, status=status.HTTP_401_UNAUTHORIZED)

        component_obj = get_object(Component, project, pk)
        component_obj.feature_set.clear()
        component_obj.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)
Esempio n. 20
0
    def put(self, request, project, pk):
        serializer = TestPlanSerializer(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors,
                            status=status.HTTP_400_BAD_REQUEST)

        try:
            plan_name = serializer.validated_data['name']
            plan_category = serializer.validated_data['category']
            plan_owner = serializer.validated_data['owner']
            plan_description = serializer.validated_data['description']
            start_time = serializer.validated_data['start_time']
            end_time = serializer.validated_data['end_time']
        except KeyError:
            return Response(
                {'detail': unicode("The lack of required parameters.")},
                status=status.HTTP_400_BAD_REQUEST)

        perf = serializer.validated_data.get('performance', False)
        app = serializer.validated_data.get('app', None)

        if not check_name_by_id(
                TestPlan, plan_name, project, pk, check_flag=True):
            return Response(
                {
                    'detail':
                    unicode("Found same name testplan, "
                            "please check your testplan name.")
                },
                status=status.HTTP_409_CONFLICT)

        plan_obj = get_object(TestPlan, project, pk)
        if plan_obj.performance != perf or plan_obj.app != app:
            return Response(
                {
                    'detail':
                    unicode("Not allow change performance and app attribute.")
                },
                status=status.HTTP_400_BAD_REQUEST)

        if not check_owner_runner(plan_obj.owner, plan_owner):
            return Response(
                {'detail': unicode("The owner can not be changed.")},
                status=status.HTTP_400_BAD_REQUEST)

        plan_obj.name = plan_name
        plan_obj.owner = plan_owner
        plan_obj.category = plan_category
        plan_obj.start_time = start_time
        plan_obj.end_time = end_time
        plan_obj.description = plan_description
        plan_obj.save()

        new_serializer = TestPlanSerializer(plan_obj)
        return Response(new_serializer.data, status=status.HTTP_202_ACCEPTED)
Esempio n. 21
0
    def put(self, request, project, pk):
        serializer = TestsuiteSerializer(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        try:
            suite_name = serializer.validated_data['name']
            suite_subsystem = serializer.validated_data['subsystem']
            suite_description = serializer.validated_data['description']
            plan_list = serializer.validated_data['testplan']
        except KeyError:
            return Response({'detail': unicode("The lack of required parameters.")},
                            status=status.HTTP_400_BAD_REQUEST)

        perf = serializer.validated_data.get('performance', False)
        app = serializer.validated_data.get('app', None)
        if perf and not app:
                return Response({'detail': unicode("parameter app must provide when performance=True")},
                                status=status.HTTP_400_BAD_REQUEST)
        if not perf and app:
                return Response({'detail': unicode("parameter app can not be set when performance=False")},
                                status=status.HTTP_400_BAD_REQUEST)

        if not check_name_by_id(TestSuite, suite_name, project, pk, check_flag=True):
            return Response({'detail': unicode("Found same name testsuite_name, "
                                               "please check your testsuite_name name.")},
                            status=status.HTTP_409_CONFLICT)

        suite_obj = get_object(TestSuite, project, pk)
        if suite_obj.performance != perf or suite_obj.app != app:
            return Response({'detail': unicode("Not allow change performance and app attribute.")},
                            status=status.HTTP_400_BAD_REQUEST)

        suite_obj.name = suite_name
        suite_obj.subsystem = suite_subsystem
        suite_obj.description = suite_description

        validated_plan_list = []
        for plan in plan_list:
            if plan.performance != perf or plan.app != app:
                return Response({'detail': unicode("plan:{0} not match test suite of "
                                                   "performance type".format(plan.id))},
                                status=status.HTTP_409_CONFLICT)
            validated_plan_list.append(plan)

        suite_obj.save()
        suite_obj.testplan.clear()
        for plan in validated_plan_list:
            suite_obj.testplan.add(plan)

        new_serializer = TestsuiteSerializer(suite_obj)
        return Response(new_serializer.data, status=status.HTTP_202_ACCEPTED)
Esempio n. 22
0
    def delete(self, request, project, pk):
        # Allow delete app when it not used by case,suite,plan,execution
        app_obj = get_object(App, project, pk)
        if app_obj.testcase_set.count() or app_obj.testsuite_set.count() or \
                app_obj.testplan_set.count() or app_obj.testexecution_set.count() or \
                app_obj.perftestcaseresultdetail_set.count():
            return Response({'detail': unicode('This app has been used.')})

        # Related AppAttr will auto delete before delete app.
        AppAttr.objects.filter(app=app_obj, project__name=project).delete()
        app_obj.delete()

        return Response(status=status.HTTP_204_NO_CONTENT)
Esempio n. 23
0
    def run(self, ctx):
        if not isinstance(ctx, IGraphicalClientContext):
            print('This script must be run within a graphical client')
            return

        plugins = ctx.getEnginesContext().getEnginesPlugins()
        for plugin in plugins:
            assert isinstance(plugin, IEnginesPlugin)
            if 'yoav' in plugin.getClass().getCanonicalName():
                classloader = plugin.getClass().getClassLoader()

                # Update focused method
                UIBridge = utils.get_object("com.yoavst.jeb.bridge.UIBridge",
                                            classloader)
                UIBridge.update(ctx)

                # Get focused method
                dex_method = UIBridge.getFocusedMethod()
                if not dex_method:
                    print "No selected method"
                    return
                break
        else:
            print "JebOps is not installed"
            return

        assert isinstance(dex_method, IDexMethod)
        clz = dex_method.getClassType().getSignature()[1:-1].replace('/', '.')
        method = dex_method.getName(False)
        method = BasicMethodMap.get(method, method)
        sig = dex_method.getSignature(False)
        this_part = "" if (dex_method.getGenericFlags() & 8) == 8 else "this"
        if dex_method.getParameterTypes() and this_part:
            this_part += ", "

        params_list = ', '.join('"{}"'.format(
            self.signature_to_frida_signature(t.getSignature(False)))
                                for t in dex_method.getParameterTypes())
        args = []
        for t in dex_method.getParameterTypes():
            args.append(self.type_to_pretty_name(t, args))
        args_list = ', '.join(args)

        fmt = FMT_VOID if dex_method.getReturnType().getSignature(
        ) == "V" else FMT_RET
        print fmt.format(class_name=clz,
                         method_name=method,
                         method_sig=sig,
                         this_part=this_part,
                         param_list=params_list,
                         args_list=args_list)
Esempio n. 24
0
    def put(self, request, project, pk):
        serializer = TestexecutionOsSerializer(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        os_name = serializer.data['name']
        if not check_name_by_id(OS, os_name, project, pk):
            return Response({'detail': unicode("Found same name os, please check your os name.")},
                            status=status.HTTP_409_CONFLICT)

        os_obj = get_object(OS, project, pk)
        os_obj.name = serializer.data['name']
        os_obj.save()

        new_serializer = TestexecutionOsSerializer(os_obj)
        return Response(new_serializer.data, status=status.HTTP_202_ACCEPTED)
Esempio n. 25
0
 def hist_getter_sig_usyd(self,sample=None,ID=None,sys=None,pt_bin=None,eta_bin=None,prongs=None,var=None,newname=None,antiID=None):
     if sample is None: sample = 'ZtautauTruth'
     if var is None: var = 'evtsel_tau_nTrackTotal'
     if prongs is None: prongs = 'inc'
     kin_bin = self.get_kin_bin(pt_bin=pt_bin,eta_bin=eta_bin) 
     IDtag = self.coepp_id_tag(ID)
     fname = self.filename_getter_sig(sys=sys,pt_bin=pt_bin,eta_bin=eta_bin,prongs=prongs,ID=ID)
     hname = 'h_%s_%s' % (var,sample)
     hpath = '%s_%s_%s/hists/%s' % (IDtag,prongs,kin_bin,hname)
     h = get_object(hpath,fname)
     if newname: 
         h = h.Clone(newname)
     if antiID: 
         hanti = self.hist_getter_sig_fed(sample=sample,ID=antiID,sys=sys,pt_bin=pt_bin,eta_bin=eta_bin,prongs=prongs,var=var)
         h = hist_subtract_correlated(h,hanti)
     return h
Esempio n. 26
0
    def run(self, ctx):
        assert isinstance(ctx, IGraphicalClientContext)
        try:
            plugins = ctx.getEnginesContext().getEnginesPlugins()
            for plugin in plugins:
                assert isinstance(plugin, IEnginesPlugin)
                if 'yoav' in plugin.getClass().getCanonicalName():
                    classloader = plugin.getClass().getClassLoader()

                    print "Updating UI bridge"
                    UIBridge = utils.get_object(
                        "com.yoavst.jeb.bridge.UIBridge", classloader)
                    UIBridge.update(ctx)
                    break
        except:
            traceback.print_exc(file=sys.stdout)
Esempio n. 27
0
    def put(self, request, project, pk):
        serializer = TestcaseTypeSerializer(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        type_name = serializer.data['name']
        if not check_name_by_id(TestCaseType, type_name, project, pk):
            return Response({'detail': unicode("Found same name type, "
                                               "please check your type name.")},
                            status=status.HTTP_409_CONFLICT)

        type_obj = get_object(TestCaseType, project, pk)
        type_obj.name = type_name
        type_obj.save()

        new_serializer = TestcaseTypeSerializer(type_obj)
        return Response(new_serializer.data, status=status.HTTP_202_ACCEPTED)
Esempio n. 28
0
    def put(self, request, project, pk):
        serializer = TestsuiteSubsystemSerializer(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        subsystem_name = serializer.data['name']
        if not check_name_by_id(Subsystem, subsystem_name, project, pk):
            return Response({'detail': unicode("Found same name subsystem, "
                                               "please check your subsystem name.")},
                            status=status.HTTP_409_CONFLICT)

        subsystem_obj = get_object(Subsystem, project, pk)
        subsystem_obj.name = subsystem_name
        subsystem_obj.save()

        new_serializer = TestsuiteSubsystemSerializer(subsystem_obj)
        return Response(new_serializer.data, status=status.HTTP_202_ACCEPTED)
Esempio n. 29
0
    def hist_getter_abcd_fed(self,sample=None,region=None,ID=None,sys=None,pt_bin=None,eta_bin=None,var=None,newname=None, antiID=None):
        if sample is None: sample = 'data'
        if region is None: region = 'regA'
        if var is None: var = 'evtsel_tau_nTrackTotal'
        IDtag = self.coepp_id_tag(ID)
        if sys not in self.abcd_sys: sys = None

        fname = self.filename_getter_abcd(sys=sys,pt_bin=pt_bin,eta_bin=eta_bin,ID=ID)
        hname = 'h_%s_%s_%s' % (var,region,sample)
        hpath = '%s/%s/hists/%s' % (IDtag,region,hname)
        h = get_object(hpath,fname)
        if newname: 
            h = h.Clone(newname)

        if antiID: 
            hanti = self.hist_getter_abcd_fed(sample=sample,region=region,ID=antiID,sys=sys,pt_bin=pt_bin,eta_bin=eta_bin,var=var)
            h = hist_subtract_correlated(h,hanti)
        return h
Esempio n. 30
0
    def hist_getter_wcontrol_fed(self,sample=None,sign=None,ID=None,sys=None,pt_bin=None,eta_bin=None,var=None,newname=None,antiID=None):
        if sample is None: sample = 'data'
        if sign is None: sign = 'OS'
        if var is None: var = 'evtsel_tau_nTrackTotal'
        IDtag = self.coepp_id_tag(ID)
        
        w_sys = sys if sys in self.w_sys else None

        fname = self.filename_getter_wcontrol(sys=w_sys,pt_bin=pt_bin,eta_bin=eta_bin,ID=ID)
        hname = 'h_%s_%s' % (var,sample)
        hpath = '%s_%s/hists/%s' % (IDtag,sign,hname)
        h = get_object(hpath,fname)
        if newname: 
            h = h.Clone(newname)
        if antiID: 
            hanti = self.hist_getter_wcontrol_fed(sample=sample,sign=sign,ID=antiID,sys=sys,pt_bin=pt_bin,eta_bin=eta_bin,var=var)
            h = hist_subtract_correlated(h,hanti)
        return h