예제 #1
0
 def __calculate_area_pixels(self):
     xc = 0
     yc = 0
     z = 0
     xs, ys, zs = self.spacing 
     
     proj = Project()
     orig_orien = proj.original_orientation
     
     xy = (xs, ys)
     yz = (ys, zs)
     xz = (xs, zs)
     
     if (orig_orien == const.SAGITAL):
         orientation_based_spacing = {"SAGITAL" : xy,
                                  "AXIAL" : yz,
                                  "CORONAL" : xz}
     elif(orig_orien == const.CORONAL):
         orientation_based_spacing = {"CORONAL" : xy,
                                      "AXIAL" : xz,
                                      "SAGITAL" : yz}
     else:
         orientation_based_spacing = {"AXIAL" : xy,
                                      "SAGITAL" : yz,
                                      "CORONAL" : xz}
     
     xs, ys = orientation_based_spacing[self.orientation]
     self.pixel_list = []
     for i in utils.frange(yc - self.y_length/2, yc + self.y_length/2, ys):
         for k in utils.frange(xc - self.x_length/2, xc + self.x_length/2, xs):
             self.pixel_list.append((k, i))
예제 #2
0
    def draw(self, a, b, cell, cam, shadow):
        building = cell.building
        if building:
            camera(cam.c.x - a * self.cell_size, cam.c.y - b * self.cell_size)

            if shadow:
                for i in frange(0, building.height / 2, 4):
                    t = Vec2(building.s.x, building.s.y)
                    t._mul(i * 0.015)
                    t._add(building.pos)

                    rectfill(t.x - building.w, t.y - building.h,
                             t.x + building.w, t.y + building.h, 5)
            else:
                for i in frange(building.height / 2, building.height - 1, 4):
                    t = Vec2(building.s.x, building.s.y)
                    t._mul(i * 0.015)
                    t._add(building.pos)

                    rectfill(t.x - building.w, t.y - building.h,
                             t.x + building.w, t.y + building.h, 5)

                    s = building.s.mul(building.height * 0.015)
                    s._add(building.pos)
                    rectfill(s.x - building.w, s.y - building.h,
                             s.x + building.w, s.y + building.h,
                             building.color)
예제 #3
0
    def __init__(self):
        self.names = ['fl', 'sax', 'vla', 'vc', 'tbn', 'gtr']
        self.fl = fl =Piccolo()
        self.sax = sax = SopranoSaxophone()
        self.vla = vla = Viola()
        self.vc = vc =Violoncello()
        self.tbn = tbn = Trombone()
        self.gtr = gtr = ElectricGuitar()
        self.l = [fl, sax, vla, vc, tbn, gtr]
        self.d = {}
        for name, inst in zip(self.names, self.l):
            inst.nickname = name
            self.d[name] = inst

        # lowest, highest notes
        ranges = [
            ('D5', 'C7'),  # Piccolo
            ('C4', 'C6'),  # Soprano Sax
            ('C3', 'E5'),  # Viola
            ('C2', 'E4'),  # Cello
            ('E2', 'B-4'),  # Trombone
            ('E2', 'A5')  # Guitar
        ]
        for r, i in zip(ranges, self.l):
            i.lowest_note = Pitch(r[0])
            i.highest_note = Pitch(r[1])
            i.all_notes = list(frange(i.lowest_note.ps, i.highest_note.ps + 1))
            i.all_notes_24 = list(frange(i.lowest_note.ps, i.highest_note.ps + 1, 0.5))

        self.piece_range = list(frange(Pitch('E2').ps, Pitch('C7').ps + 1))
        self.piece_range_at_least_two_instruments = list(frange(Pitch('E2').ps, Pitch('C6').ps + 1))
예제 #4
0
def CreateBBGrid(xMin,
                 xMax,
                 yMin,
                 yMax,
                 cellSize,
                 fixes,
                 intervals,
                 searchArea=None,
                 progressor=None):
    """Build a brownian bridge grid by dividing the extents into
    square cells of size cellSize.  The grid is a list of rows.  Each
    row is a list of cell value.  Each row is built left to right, and the
    rows are built top to bottom.  See the EvaluateGridPoint() for details
    on the remaining parameters."""

    if progressor is not None:
        rowCount = 1 + int((yMax - yMin) / cellSize)
        if progressor == True:
            rowIndex = 0
            print "Start Building Grid", rowCount
        else:
            progressor.SetProgressor("step", "Building Grid...", 0, rowCount,
                                     1)

    if searchArea is not None:
        point = arcpy.Point()

    grid = []
    #build the grid from the top down
    for y in utils.frange(yMax, yMin, -cellSize):
        row = []
        for x in utils.frange(xMin, xMax, cellSize):
            if searchArea is None:
                cell = EvaluateGridPoint(x, y, fixes, intervals)
                #cell = 1
            else:
                point.X, point.Y = x, y
                if searchArea.contains(point):
                    cell = EvaluateGridPoint(x, y, fixes, intervals)
                    #cell = 1
                else:
                    cell = 0
            row.append(cell)
        grid.append(row)

        if progressor is not None:
            if progressor == True:
                rowIndex += 1
                print "Finished row", rowIndex, "of", rowCount
            else:
                progressor.SetProgressorPosition()

    return grid
예제 #5
0
    def __init__(self):
        self.names = [
            'fl',
            'ob',
            'cl',
            'sax',
            'tpt',
            'vln',
            'vib',
            'bs'
        ]
        self.fl = fl = Flute()
        self.ob = ob = Oboe()
        self.cl = cl = Clarinet()
        self.sax = sax = AltoSaxophone()
        self.tpt = tpt = Trumpet()
        self.vln = vln = Violin()
        self.vib = vib = Vibraphone()
        self.bs = bs = Contrabass()

        self.l = [
            fl,
            ob,
            cl,
            sax,
            tpt,
            vln,
            vib,
            bs
        ]
        self.d = {}
        for name, inst in zip(self.names, self.l):
            inst.nickname = name
            self.d[name] = inst

        # lowest, highest notes
        ranges = [
            ('C4', 'C7'),     # Flute     60 96
            ('B-3', 'G#6'),   # Oboe      58 92
            ('D3', 'G6'),     # Clarinet  50 91
            ('D-3', 'A-5'),   # Sax       49 80
            ('E3', 'B-5'),    # Trumpet   52 82
            ('G3', 'B6'),     # Violin
            ('F3', 'F6'),     # Vibraphone
            ('E1', 'G3')      # Bass
        ]
        for r, i in zip(ranges, self.l):
            i.lowest_note = Pitch(r[0])
            i.highest_note = Pitch(r[1])
            i.all_notes = list(frange(i.lowest_note.ps, i.highest_note.ps + 1))
            i.all_notes_24 = list(frange(i.lowest_note.ps, i.highest_note.ps + 1, 0.5))
예제 #6
0
파일: exec_tcl.py 프로젝트: xiayumei/CS5700
def run_experiment1(args):
    """
    Main entry for executing experiment1 and executing yielded
    files one by one
    """
    threads = []
    tcp_agents = OrderedDict({})
    tcp_agents['Tahoe'] = 'Agent/TCP'
    tcp_agents['Reno'] = 'Agent/TCP/Reno'
    tcp_agents['NewReno'] = 'Agent/TCP/Newreno'
    tcp_agents['Vegas'] = 'Agent/TCP/Vegas'
    cbr_rates = frange(1.00, 10.00, args.granularity)
    for agent_name, agent in tcp_agents.items():
        for cbr_rate in cbr_rates:
            out_file = format_trace_file_name(args.out, agent_name, cbr_rate)
            nsargs = [
                agent, cbr_rate, out_file, args.cbr_start, args.cbr_stop,
                args.tcp_start, args.tcp_stop, args.duration
            ]
            rc = ns('../ns2/experiment1.tcl', nsargs)
            nsargs.append(str(rc))
            nsargs[0] = agent_name
            print("experiment1, tcp_agent: %s, cbr_rate: %s, " +
                  "out_to: %s, cbr_start: %s, cbr_stop: %s, " +
                  "tcp_start: %s, tcp_stop: %s, duration: %s, " +
                  "return code: %s") % tuple(map(lambda x: str(x), nsargs))
            kwargs = {
                'cbr_rate': str(cbr_rate),
                'agent_name': agent_name,
            }
            t = post_process(args.which, out_file, **kwargs)
            threads.append(t)
    # waits for all thread finish once get out of the loop
    wait_for(threads)
예제 #7
0
def manipulate_latent(model, data, args):
    print('-' * 30 + 'Begin: manipulate' + '-' * 30)
    x_test, y_test = data
    index = np.argmax(y_test, 1) == args.digit
    number = np.random.randint(low=0, high=sum(index) - 1)
    x, y = x_test[index][number], y_test[index][number]
    x, y = np.expand_dims(x, 0), np.expand_dims(y, 0)
    noise = np.zeros([1, conf.NUM_CLASSES, 16])
    x_recons = []
    for dim in range(16):
        # for r in [-0.25, -0.2, -0.15, -0.1, -0.05, 0, 0.05, 0.1, 0.15, 0.2, 0.25]:
        for r in utils.frange(-0.25, 0.25, 0.05):
            tmp = np.copy(noise)
            tmp[:, :, dim] = r
            x_recon = model.predict([x, y, tmp])
            x_recons.append(x_recon)

    x_recons = np.concatenate(x_recons)

    img = utils.combine_images(x_recons, height=16)
    image = img * 255
    Image.fromarray(image.astype(
        np.uint8)).save(args.save_dir + '/manipulate-%d.png' % args.digit)
    print('manipulated result saved to %s/manipulate-%d.png' %
          (args.save_dir, args.digit))
    print('-' * 30 + 'End: manipulate' + '-' * 30)
예제 #8
0
    def create_iter_elems(param, start_only):
        """
        Creates the elements corresponding to an iteration element.

        :param param:
        :param start_only:
        :return:
        """
        name_attr = param['@name']
        from_attr = float(param['@from'])
        to_attr = float(param['@to'])
        by_attr = float(param['@by'])

        # Sanity check (positive steps only), no more than 10 steps
        # If this test fails, the parameter is replaced by its starting point
        if not start_only:
            if from_attr < to_attr and by_attr > 0 and (to_attr - from_attr) / 10 <= 10:
                logging.info("Parameter iteration found. Adding metrics for range: ")
                param_range = frange(from_attr, to_attr+by_attr, by_attr)
            else:
                logging.warn("Illegal parameter iteration specified: from %f, to %f, by %f",
                             from_attr, to_attr, by_attr)
                param_range = [from_attr]
        else:
            logging.warn("Extra iteration parameters replaced with start point %s")
            param_range = [from_attr]

        iter_elems = [{'@name': name_attr, '#text': param_value} for param_value in param_range]

        return iter_elems
예제 #9
0
파일: iso.py 프로젝트: certik/chemev
def getisosweights_gauss(weights,age,metallicity,isos,sigma):
    """ same as getisoweights, but adds Gaussian scatter """ 
    w=[0.]*len(isos)
    for m,a,feh in zip(weights,age,metallicity):
        for x in utils.frange(feh-4,feh+4,0.1):
            w[getn(x,a,isos)]+=m*utils.gauss(x,feh,sigma)
    return w
예제 #10
0
def getisosweights_gauss(weights, age, metallicity, isos, sigma):
    """ same as getisoweights, but adds Gaussian scatter """
    w = [0.] * len(isos)
    for m, a, feh in zip(weights, age, metallicity):
        for x in utils.frange(feh - 4, feh + 4, 0.1):
            w[getn(x, a, isos)] += m * utils.gauss(x, feh, sigma)
    return w
예제 #11
0
    def choose_melody_pitches(self, notes, register, harmonies):
        print 'Choosing pitches'
        for h in harmonies:
            h['pitch_classes'] = [p % 12 for p in h['pitch']]

        set_start_end(notes)
        set_start_end(harmonies)

        previous_note_index = random.choice(range(int(len(register) * .4)))
        prev = register[previous_note_index]

        for note in notes:
            beats = list(
                frange(note['start'], note['start'] + note['duration'], .25))
            note_harmonies = []
            for b in beats:
                h = get_at(b, harmonies)
                h = h['pitch_classes']
                if h not in note_harmonies:
                    note_harmonies.append(h)

            print 'note_harmonies', note_harmonies

            if len(note_harmonies) == 1:
                pitch_options = self.get_pitch_options(note_harmonies[0], prev)
            else:
                pitch_options = []

                c = Counter()
                for h in note_harmonies:
                    for p in h:
                        c[p] += 1

                common = []
                for p, count in c.most_common():
                    if count == len(note_harmonies):
                        common.append(p)

                if len(common) > 0:
                    pitch_options = self.get_pitch_options(common, prev)

                if len(pitch_options) == 0:
                    ranked = [p for p, _ in c.most_common() if p not in common]

                    for p in ranked:
                        pitch_options = self.get_pitch_options([p], prev)
                        if len(pitch_options) > 0:
                            break

            if len(pitch_options) == 0:
                pitch_options = [prev - 2, prev - 1, prev + 1, prev + 2]

            note['pitch'] = random.choice(pitch_options)

            print note['pitch'] % 12
            print

            prev = note['pitch']

            self.add_ornament(note, prev, note_harmonies)
예제 #12
0
    def obtener_resultado(self, min, max=None, interval=None, velocidad=None):
        if max == None:
            max = min
            min = 0

        tiempo_aproximado = None
        tiempo_real = None

        for tiempo in utils.frange(min, max, interval):
            self.velocidad_anterior.append(
                self.obtener_velocidad_aproximada(tiempo))
            self.velocidad_anterior_real.append(self.obtener_velocidad(tiempo))
            self.tiempo_anterior.append(tiempo)

            if utils.isclose(self.obtener_velocidad_aproximada(tiempo),
                             velocidad,
                             rel_tol=0.001) and tiempo_aproximado is None:
                tiempo_aproximado = tiempo

            if utils.isclose(self.obtener_velocidad(tiempo),
                             velocidad,
                             rel_tol=0.001) and tiempo_real is None:
                tiempo_real = tiempo

            if tiempo_real is not None and tiempo_aproximado is not None:
                return [tiempo_aproximado, tiempo_real]
예제 #13
0
    def update(self, x, y, cell, cam, cells, blobs):
        building = cell.building
        if building:
            cellp = Vec2(cam.pos.x % self.cell_size - x * self.cell_size,
                         cam.pos.y % self.cell_size - y * self.cell_size)
            building.s = building.pos.sub(
                cellp.add(self.config.perspective_offset))

            s1 = max(building.w, building.h)
            s2 = min(building.w, building.h)
            for i in frange(-s1 + s2 / 2, s1 - s2 / 2, s2):
                p1 = Vec2((cells.pos.x + x) * self.cell_size,
                          (cells.pos.y + y) * self.cell_size).add(building.pos)
                if s1 == building.w:
                    p1.x += i
                else:
                    p1.y += i
                blobs.add_blob(p1, s2)

                p2 = Vec2((cells.pos.x + x) * self.cell_size,
                          (cells.pos.y + y) * self.cell_size).add(building.pos)
                if s1 == building.w:
                    p2.x += s1 - s2 / 2
                else:
                    p2.y += s1 - s2 / 2

                if p2.dist(p1) > 2:
                    blobs.add_blob(p2, s2)
def run_experiment1(args):
    """
    Main entry for executing experiment1 and executing yielded
    files one by one
    """
    threads = []
    tcp_agents = OrderedDict({})
    tcp_agents['Tahoe'] = 'Agent/TCP'
    tcp_agents['Reno'] = 'Agent/TCP/Reno'
    tcp_agents['NewReno'] = 'Agent/TCP/Newreno'
    tcp_agents['Vegas'] = 'Agent/TCP/Vegas'
    cbr_rates = frange(1.00, 10.00, args.granularity)
    for agent_name, agent in tcp_agents.items():
        for cbr_rate in cbr_rates:
            out_file = format_trace_file_name(args.out, agent_name, cbr_rate)
            nsargs = [agent, cbr_rate, out_file, args.cbr_start, args.cbr_stop,
                      args.tcp_start, args.tcp_stop, args.duration]
            rc = ns('../ns2/experiment1.tcl', nsargs)
            nsargs.append(str(rc))
            nsargs[0] = agent_name
            print ("experiment1, tcp_agent: %s, cbr_rate: %s, " +
                   "out_to: %s, cbr_start: %s, cbr_stop: %s, " +
                   "tcp_start: %s, tcp_stop: %s, duration: %s, " +
                   "return code: %s") % tuple(map(lambda x: str(x), nsargs))
            kwargs = {
                'cbr_rate': str(cbr_rate),
                'agent_name': agent_name,
            }
            t = post_process(args.which, out_file, **kwargs)
            threads.append(t)
    # waits for all thread finish once get out of the loop
    wait_for(threads)
예제 #15
0
 def __calculate_area_pixels(self):
     """
     Return the cursor's pixels.
     This method scans the circle line by line.
     Extracted equation. 
     http://www.mathopenref.com/chord.html
     """
     xc = 0.0
     yc = 0.0
     z = 0.0
     xs, ys, zs = self.spacing 
     
     proj = Project()
     orig_orien = proj.original_orientation
     
     xy = (xs, ys)
     yz = (ys, zs)
     xz = (xs, zs)
     
     if (orig_orien == const.SAGITAL):
         orientation_based_spacing = {"SAGITAL" : xy,
                                  "AXIAL" : yz,
                                  "CORONAL" : xz}
     elif(orig_orien == const.CORONAL):
         orientation_based_spacing = {"CORONAL" : xy,
                                      "AXIAL" : xz,
                                      "SAGITAL" : yz}
     else:
         orientation_based_spacing = {"AXIAL" : xy,
                                      "SAGITAL" : yz,
                                      "CORONAL" : xz}
     
     xs, ys = orientation_based_spacing[self.orientation]
     self.pixel_list = []
     radius = self.radius
     for i in utils.frange(yc - radius, yc + radius, ys):
         # distance from the line to the circle's center
         d = yc - i
         # line size
         line = sqrt(radius**2 - d**2) * 2
         # line initial x
         xi = xc - line/2.0
         # line final
         xf = line/2.0 + xc
         yi = i
         for k in utils.frange(xi,xf,xs):
             self.pixel_list.append((k, yi))
예제 #16
0
    def choose_melody_pitches(self, notes, register, harmonies):
        print 'Choosing pitches'
        for h in harmonies:
            h['pitch_classes'] = [p % 12 for p in h['pitch']]

        set_start_end(notes)
        set_start_end(harmonies)

        previous_note_index = random.choice(range(int(len(register) * .4)))
        prev = register[previous_note_index]

        for note in notes:
            beats = list(frange(note['start'], note['start'] + note['duration'], .25))
            note_harmonies = []
            for b in beats:
                h = get_at(b, harmonies)
                h = h['pitch_classes']
                if h not in note_harmonies:
                    note_harmonies.append(h)

            print 'note_harmonies', note_harmonies

            if len(note_harmonies) == 1:
                pitch_options = self.get_pitch_options(note_harmonies[0], prev)
            else:
                pitch_options = []

                c = Counter()
                for h in note_harmonies:
                    for p in h:
                        c[p] += 1

                common = []
                for p, count in c.most_common():
                    if count == len(note_harmonies):
                        common.append(p)

                if len(common) > 0:
                    pitch_options = self.get_pitch_options(common, prev)

                if len(pitch_options) == 0:
                    ranked = [p for p, _ in c.most_common() if p not in common]

                    for p in ranked:
                        pitch_options = self.get_pitch_options([p], prev)
                        if len(pitch_options) > 0:
                            break

            if len(pitch_options) == 0:
                pitch_options = [prev - 2, prev - 1, prev + 1, prev + 2]

            note['pitch'] = random.choice(pitch_options)

            print note['pitch'] % 12
            print

            prev = note['pitch']

            self.add_ornament(note, prev, note_harmonies)
예제 #17
0
파일: iso.py 프로젝트: certik/chemev
def sumisos_gauss_slow(mass,age,metallicity,fehlist,agelist,isos,sigma):
    """slower version"""
    summed_iso = 0.*isos[isos.keys()[0]]
    for m,a,z in zip(mass,age,metallicity):
        feh = numarray.log10(z)-numarray.log10(SOLAR)
        for x in utils.frange(feh-4,feh+4,0.1):
            summed_iso+= utils.gauss(x,feh,sigma)*m*getiso(x,a,fehlist,agelist,isos)
    return summed_iso
예제 #18
0
def sumisos_gauss_slow(mass, age, metallicity, fehlist, agelist, isos, sigma):
    """slower version"""
    summed_iso = 0. * isos[isos.keys()[0]]
    for m, a, z in zip(mass, age, metallicity):
        feh = numarray.log10(z) - numarray.log10(SOLAR)
        for x in utils.frange(feh - 4, feh + 4, 0.1):
            summed_iso += utils.gauss(x, feh, sigma) * m * getiso(
                x, a, fehlist, agelist, isos)
    return summed_iso
예제 #19
0
def CreateBBGrid(xMin, xMax, yMin, yMax, cellSize, fixes, intervals, searchArea=None, progressor=None):
    """Build a brownian bridge grid by dividing the extents into
    square cells of size cellSize.  The grid is a list of rows.  Each
    row is a list of cell value.  Each row is built left to right, and the
    rows are built top to bottom.  See the EvaluateGridPoint() for details
    on the remaining parameters."""
    
    if progressor is not None:
        rowCount = 1 + int((yMax - yMin) / cellSize)
        if progressor == True:
            rowIndex = 0
            print "Start Building Grid", rowCount
        else:
            progressor.SetProgressor("step", "Building Grid...", 0, rowCount, 1)

    if searchArea is not None:
        point = arcpy.Point()

    grid = []
    #build the grid from the top down
    for y in utils.frange(yMax, yMin, -cellSize):
        row = []
        for x in utils.frange(xMin, xMax, cellSize):
            if searchArea is None:
                cell = EvaluateGridPoint(x, y, fixes, intervals)
                #cell = 1
            else:
                point.X, point.Y = x, y
                if searchArea.contains(point):
                    cell = EvaluateGridPoint(x, y, fixes, intervals)
                    #cell = 1
                else:
                    cell = 0
            row.append(cell)
        grid.append(row)

        if progressor is not None:
            if progressor == True:
                rowIndex += 1
                print "Finished row", rowIndex, "of", rowCount
            else:
                progressor.SetProgressorPosition()

    return grid
예제 #20
0
    def choose_solo_notes(self):
        rest_beginning = random.choice([True, False, False, False, False])
        rest_middle = random.choice([True, True, False])
        rest_end = random.choice([True, True, True, False, False])

        rests = [rest_beginning, rest_middle, rest_end]
        num_rests = rests.count(True)

        min_num_divs = 3 + num_rests

        num_divs = random.randint(min_num_divs, 9)

        divs = divide(16, num_divs)

        notes = [{'pitch': None, 'duration': div / 4.0} for div in divs]

        if rest_beginning:
            notes[0]['pitch'] = 'rest'

        if rest_end:
            notes[-1]['pitch'] = 'rest'

        if rest_middle:
            if rest_beginning:
                start = 2
            else:
                start = 1
            if rest_end:
                end = -2
            else:
                end = -1
            middle_rest_index = random.choice(range(len(notes))[start:end])
            notes[middle_rest_index]['pitch'] = 'rest'


        for note in notes:
            if note['pitch'] != 'rest':
                note['pitch'] = ps = random.choice(self.soloist_shared_notes)

                self.soloist_shared_notes = [p for p in frange(ps - 2, ps + 3) if p in self.all_soloists_shared_notes]

        self.soloist_shared_notes = [p for p in frange(ps - 5, ps + 6) if p in self.all_soloists_shared_notes]

        return notes
예제 #21
0
def getisosweights_vgauss(weights, age, metallicity, isos, sigma, dsigmadlogt):
    """ same as getisoweights, but adds age-dependent Gaussian scatter """
    w = [0.] * len(isos)
    logt0 = numarray.log10(age[0])
    for m, a, feh in zip(weights, age, metallicity):
        logt = numarray.log10(a)
        sig = sigma + dsigmadlogt * (logt - logt0)
        for x in utils.frange(feh - 4, feh + 4, 0.1):
            w[getn(x, a, isos)] += m * utils.gauss(x, feh, sig)
    return w
예제 #22
0
파일: iso.py 프로젝트: certik/chemev
def getisosweights_vgauss(weights,age,metallicity,isos,sigma,dsigmadlogt):
    """ same as getisoweights, but adds age-dependent Gaussian scatter """ 
    w=[0.]*len(isos)
    logt0 = numarray.log10(age[0])
    for m,a,feh in zip(weights,age,metallicity):
        logt = numarray.log10(a)
        sig = sigma+dsigmadlogt*(logt-logt0)
        for x in utils.frange(feh-4,feh+4,0.1):
            w[getn(x,a,isos)]+=m*utils.gauss(x,feh,sig)
    return w
예제 #23
0
def range(ode_method, ode, initial_val, start, end, step_size=0.01):
    values = []
    old_val = initial_val

    for t in frange(start, end + 0.00001, step_size):
        values.append((t, old_val))
        new_val = ode_method(ode, old_val, t, step_size)
        old_val = new_val

    return values
예제 #24
0
    def __init__(self):
        self.names = ['vln', 'gtr']
        self.vln = vln = Violin()
        self.gtr = gtr = AcousticGuitar()
        self.l = [vln, gtr]
        self.d = {}
        for name, inst in zip(self.names, self.l):
            inst.nickname = name
            self.d[name] = inst

        # lowest, highest notes
        ranges = [
            ('G3', 'B6'),  # Violin
            ('E2', 'G5')  # Guitar
        ]
        for r, i in zip(ranges, self.l):
            i.lowest_note = Pitch(r[0])
            i.highest_note = Pitch(r[1])
            i.all_notes = list(frange(i.lowest_note.ps, i.highest_note.ps + 1))
            i.all_notes_24 = list(frange(i.lowest_note.ps, i.highest_note.ps + 1, 0.5))
예제 #25
0
    def __init__(self):
        self.names = ['vln', 'gtr']
        self.vln = vln = Violin()
        self.gtr = gtr = AcousticGuitar()
        self.l = [vln, gtr]
        self.d = {}
        for name, inst in zip(self.names, self.l):
            inst.nickname = name
            self.d[name] = inst

        # lowest, highest notes
        ranges = [
            ('G3', 'B6'),  # Violin
            ('E2', 'G5')  # Guitar
        ]
        for r, i in zip(ranges, self.l):
            i.lowest_note = Pitch(r[0])
            i.highest_note = Pitch(r[1])
            i.all_notes = list(frange(i.lowest_note.ps, i.highest_note.ps + 1))
            i.all_notes_24 = list(
                frange(i.lowest_note.ps, i.highest_note.ps + 1, 0.5))
예제 #26
0
def readin():
    """ read in the best fit:
        p,t,s,m,w,model,data,isos,isow = readin()
        parameters, time, sfr, metallicity, weights, model, data, ...
    """
    log_tmax = Numeric.log10(13.7e9)
    data = iso.readfits(isodir + "/datarr.fits")
    isos = iso.readisos(isodir)
    t = utils.frange(8, log_tmax, 0.001)
    p = parameters()
    p.load()
    m, s, w, isow, model = compute_model(t, p, isos, data)
    return p, t, s, m, w, model, data, isos, isow
예제 #27
0
파일: plotsmooth.py 프로젝트: certik/chemev
def readin():
    """ read in the best fit:
        p,t,s,m,w,model,data,isos,isow = readin()
        parameters, time, sfr, metallicity, weights, model, data, ...
    """
    log_tmax = Numeric.log10(13.7e9)
    data=iso.readfits(isodir+"/datarr.fits")
    isos = iso.readisos(isodir)
    t=utils.frange(8,log_tmax,0.001)
    p=parameters()
    p.load()
    m,s,w,isow,model = compute_model(t,p,isos,data)
    return p,t,s,m,w,model,data,isos,isow
예제 #28
0
파일: iso.py 프로젝트: certik/chemev
def sumisos_gauss(mass,age,metallicity,fehlist,agelist,isos,sigma):
    """Faster version."""
    isoweight = {}
    for k in isos.keys():
        isoweight[k] = 0.
    for m,a,z in zip(mass,age,metallicity):
        feh = numarray.log10(z/SOLAR)
        for x in utils.frange(feh-4,feh+4,0.1):
            isoweight[getindices(x,a,fehlist,agelist)]+= utils.gauss(x,feh,sigma)*m
    summed_iso = 0.*isos[isos.keys()[0]]
    for k in isoweight.keys():
        summed_iso+=isoweight[k]*isos[k]
#    p(isoweight)
    return summed_iso
예제 #29
0
파일: iso.py 프로젝트: certik/chemev
def getisosweights_sgauss(weights,age,sfr,metallicity,isos,sigma,dsigmadlogt):
    """ Same as getisoweights, but adds sfr-dependent Gaussian scatter.
        **** CAUTION: not yet tested ****
    """ 
    w=[0.]*len(isos)
    logt0 = numarray.log10(age[0])
    for m,a,feh,s in zip(weights,age,metallicity,sfr):
        ss = numarray.maximum(sfr,1.e-5)
        logs = numarray.log10(ss)
        logt = numarray.log10(a)
        sig = sigma+dsigmadlogs*(logs)
        for x in utils.frange(feh-4,feh+4,0.1):
            w[getn(x,a,isos)]+=m*utils.gauss(x,feh,sig)
    return w
예제 #30
0
def getisosweights_sgauss(weights, age, sfr, metallicity, isos, sigma,
                          dsigmadlogt):
    """ Same as getisoweights, but adds sfr-dependent Gaussian scatter.
        **** CAUTION: not yet tested ****
    """
    w = [0.] * len(isos)
    logt0 = numarray.log10(age[0])
    for m, a, feh, s in zip(weights, age, metallicity, sfr):
        ss = numarray.maximum(sfr, 1.e-5)
        logs = numarray.log10(ss)
        logt = numarray.log10(a)
        sig = sigma + dsigmadlogs * (logs)
        for x in utils.frange(feh - 4, feh + 4, 0.1):
            w[getn(x, a, isos)] += m * utils.gauss(x, feh, sig)
    return w
예제 #31
0
def Search(func, allSquaredDistances, n, h_ref, min_percent, max_percent, step_percent):

    h_min = min_percent * h_ref
    h_max = max_percent * h_ref
    h_step = step_percent * h_ref

    h_res = h_max
    minErr = func(allSquaredDistances, n, h_max)

    for h_test in utils.frange(h_min, h_max, h_step):
        err = func(allSquaredDistances, n, h_test)
        if (err < minErr):
            minErr = err
            h_res = h_test     
    return h_res
def Search(func, allSquaredDistances, n, h_ref, min_percent, max_percent,
           step_percent):

    h_min = min_percent * h_ref
    h_max = max_percent * h_ref
    h_step = step_percent * h_ref

    h_res = h_max
    minErr = func(allSquaredDistances, n, h_max)

    for h_test in utils.frange(h_min, h_max, h_step):
        err = func(allSquaredDistances, n, h_test)
        if (err < minErr):
            minErr = err
            h_res = h_test
    return h_res
예제 #33
0
def sumisos_gauss(mass, age, metallicity, fehlist, agelist, isos, sigma):
    """Faster version."""
    isoweight = {}
    for k in isos.keys():
        isoweight[k] = 0.
    for m, a, z in zip(mass, age, metallicity):
        feh = numarray.log10(z / SOLAR)
        for x in utils.frange(feh - 4, feh + 4, 0.1):
            isoweight[getindices(x, a, fehlist,
                                 agelist)] += utils.gauss(x, feh, sigma) * m
    summed_iso = 0. * isos[isos.keys()[0]]
    for k in isoweight.keys():
        summed_iso += isoweight[k] * isos[k]


#    p(isoweight)
    return summed_iso
예제 #34
0
    def choose_pitches(self, parts):
        for part in parts:
            for note in part['notes']:

                if note['pitch'] != 'rest':
                    note_opts = self.song.note_opts[part['instrument_name']]

                    # note_opts = self.piece.i.d[part['instrument_name']].all_notes

                    note['pitch'] = random.choice(note_opts)
                    # reset note_opts to a range within a 4th in either direction of the chosen note,
                    # but making sure that all notes are in all_note_opts
                    self.song.note_opts[part['instrument_name']] = [p for p in frange(note['pitch'] - 5, note['pitch'] + 6) if p in self.piece.i.d[part['instrument_name']].all_notes]

        harmonies = get_harmonies(parts)
        valid = all([validate_harmony(h) for h in harmonies])
        if not valid:
            self.choose_pitches(parts)
예제 #35
0
파일: exec_tcl.py 프로젝트: xiayumei/CS5700
def run_experiment2(args):
    """
    Main entry for executing experiment2 and executing yielded
    files one by one
    """
    threads = []
    tcp_agent_pairs = OrderedDict({})

    tcp_agent_pairs[('Reno', 'Reno')] = ('Agent/TCP/Reno', 'Agent/TCP/Reno')
    tcp_agent_pairs[('NewReno', 'Reno')] = ('Agent/TCP/Newreno',
                                            'Agent/TCP/Reno')
    tcp_agent_pairs[('Vegas', 'Vegas')] = ('Agent/TCP/Vegas',
                                           'Agent/TCP/Vegas')
    tcp_agent_pairs[('NewReno', 'Vegas')] = ('Agent/TCP/Newreno',
                                             'Agent/TCP/Vegas')
    cbr_rates = frange(1.00, 10.00, args.granularity)
    for pair_names, agent_pair in tcp_agent_pairs.items():
        for cbr_rate in cbr_rates:
            pair_name = '-'.join(pair_names)
            out_file = format_trace_file_name(args.out, pair_name, cbr_rate)
            nsargs = [
                agent_pair[0], agent_pair[1], cbr_rate, out_file,
                args.cbr_start, args.cbr_stop, args.tcp1_start, args.tcp1_stop,
                args.tcp2_start, args.tcp2_stop, args.duration
            ]
            rc = ns('../ns2/experiment2.tcl', nsargs)
            nsargs.append(str(rc))
            nsargs[1] = pair_name
            print ("experiment2, tcp_agents: %s, cbr_rate: %s, " +
                   "out_to: %s, cbr_start: %s, cbr_stop: %s, " +
                   "tcp1_start: %s, tcp1_stop: %s, tcp2_start: %s" +
                   "tcp2_stop: %s, duration: %s, return code: %s") \
                % tuple(map(lambda x: str(x), nsargs[1:]))
            kwargs = {
                'cbr_rate': str(cbr_rate),
                'agent1_name': pair_names[0],
                'agent2_name': pair_names[1],
            }
            t = post_process(args.which, out_file, **kwargs)
            threads.append(t)
    # waits for all thread finish once get out of the loop
    wait_for(threads)
def run_experiment2(args):
    """
    Main entry for executing experiment2 and executing yielded
    files one by one
    """
    threads = []
    tcp_agent_pairs = OrderedDict({})

    tcp_agent_pairs[('Reno', 'Reno')] = ('Agent/TCP/Reno',
                                         'Agent/TCP/Reno')
    tcp_agent_pairs[('NewReno', 'Reno')] = ('Agent/TCP/Newreno',
                                            'Agent/TCP/Reno')
    tcp_agent_pairs[('Vegas', 'Vegas')] = ('Agent/TCP/Vegas',
                                           'Agent/TCP/Vegas')
    tcp_agent_pairs[('NewReno', 'Vegas')] = ('Agent/TCP/Newreno',
                                             'Agent/TCP/Vegas')
    cbr_rates = frange(1.00, 10.00, args.granularity)
    for pair_names, agent_pair in tcp_agent_pairs.items():
        for cbr_rate in cbr_rates:
            pair_name = '-'.join(pair_names)
            out_file = format_trace_file_name(args.out, pair_name, cbr_rate)
            nsargs = [agent_pair[0], agent_pair[1], cbr_rate, out_file,
                      args.cbr_start, args.cbr_stop, args.tcp1_start,
                      args.tcp1_stop, args.tcp2_start, args.tcp2_stop,
                      args.duration]
            rc = ns('../ns2/experiment2.tcl', nsargs)
            nsargs.append(str(rc))
            nsargs[1] = pair_name
            print ("experiment2, tcp_agents: %s, cbr_rate: %s, " +
                   "out_to: %s, cbr_start: %s, cbr_stop: %s, " +
                   "tcp1_start: %s, tcp1_stop: %s, tcp2_start: %s" +
                   "tcp2_stop: %s, duration: %s, return code: %s") \
                % tuple(map(lambda x: str(x), nsargs[1:]))
            kwargs = {
                'cbr_rate': str(cbr_rate),
                'agent1_name': pair_names[0],
                'agent2_name': pair_names[1],
            }
            t = post_process(args.which, out_file, **kwargs)
            threads.append(t)
    # waits for all thread finish once get out of the loop
    wait_for(threads)
예제 #37
0
    def getBodies(self):
        bodies = []

        for r in [.3]:
            for theta in frange(0, 2 * math.pi, .1):
                x = 0.5 + (r + .05) * math.cos(theta)
                y = 0.5 + (r + .05) * math.sin(theta)
                vx = 0.4 * math.sin(theta)
                vy = -0.4 * math.cos(theta)
                bodies.append(
                    Body(mass=2,
                         pos=Vector(x, y),
                         vel=Vector(vx, vy),
                         rad=0.01,
                         value=-1))
        good = random.sample(bodies, len(bodies) // 3)
        for g in good:
            g.color = (0, 255, 0)
            g.value = 1
        return bodies
예제 #38
0
def parallelizeParameters(paramFile, original):
	parameters = []
	if (paramFile.has_section('Parallel')):
		#Open the original parameter file
		with open (original, "r") as originalFile:
    			pFile=originalFile.read()
		lists = []
		replacements = []
		#Read parallel section
		for metrics_par in paramFile.options('Parallel'):
			if metrics_par.count('#'):
				value = paramFile.get('Parallel' , metrics_par)
				#Parse range
				if value.count('..'):
					values = value.split('..')
					init = eval(values[0])
					end = eval(values[1])
					if len(values) > 2:
						step = eval(values[2])
					else:
						step = 1
					lists.append(u.frange(init, end, step))
				#Parse list
				else:
					values = value.split(' ')
					lists.append(values)
				replacements.append('#' + metrics_par)
		#Generate all combinations
		combinations = list(itertools.product(*lists))
		for comb in combinations:
			newParams = pFile
			for rep in xrange(len(replacements)):
				newParams = newParams.replace(replacements[rep], str(comb[rep]))
			newParParser = ConfigParser.RawConfigParser()
			newParParser.optionxform=str
			newParParser.readfp(StringIO.StringIO(newParams))
			parameters.append(newParParser)

	else:
		parameters.append(paramFile)
	return parameters
예제 #39
0
def ornament_bridge(a, b, n=None, prev_duration=0.75, width=2):
    """Find notes that bridge the interval between a and b"""

    if n is None:
        # Choose the number of notes in the ornament
        if prev_duration >= 0.75:
            n = weighted_choice([1, 2, 3, 4, 5, 6], [3, 3, 4, 5, 4, 3])
        else:
            n = weighted_choice([1, 2, 3], [3, 4, 5])

    interval = b - a
    direction = 0
    if interval > 0:
        direction = 1
    if interval < 0:
        direction = -1

    if direction == 0:
        option_groups = [range(int(a - width), int(a + width + 1))] * n

    else:
        offset_interval = float(interval) / n
        option_groups = []
        for offset in list(frange(a, b, offset_interval)):
            middle = int(round(offset))
            opts = range(middle - width, middle + width + 1)
            option_groups.append(opts)

    # Prevent the last note in the ornament from being the target note.
    if b in option_groups[-1]:
        option_groups[-1].remove(b)

    ornaments = []
    for opts in option_groups:
        choice = choose(opts, ornaments)
        ornaments.append(choice)

    return ornaments
예제 #40
0
파일: prot.py 프로젝트: certik/chemev
"""Writes all the information about the best fit to the file "protocol" """

import sys
sys.path.append("/home/ondrej/py")

import utils
import iso
from params import parameters
import fit

gauss = True

isodir = "/home/ondrej/data/isochrones/696/halo"
data = iso.readfits(isodir + "/datarr.fits")
isos = iso.readisos(isodir)
t = utils.frange(8, 10.25, 0.001)
p = parameters()
p.load()
m = fit.metallicity(t, p)
s = fit.sfr(t, p)
w = utils.calculateweights(t, s)
if gauss:
    isow = iso.getisosweights_gauss(w, 10.**t, m, isos, p.sigma)
else:
    isow = iso.getisosweights(w, 10.**t, m, isos)
model = iso.computeCMD(isow, isos)
#model=isos[0][2]*0.0+1.0
model = utils.normalize(model, sum(data.flat))
#model=model/sum(model.flat)

예제 #41
0
def create_videos(trainer):
    """
    Create videos for visualizing. Will generate a video for each sample, so cancel when you have enough videos.
    For this experiment, you need to have the images downloaded.
    """
    if not trainer.args.use_cpu:
        torch.cuda.synchronize()

    # Switch to evaluate mode
    trainer.model.eval()

    len_audio = 20.48  # Only if target_spec_length = 2048
    folder_name = os.path.join(trainer.args.results, 'results_video', trainer.args.name_checkpoint)
    os.makedirs(folder_name, exist_ok=True)

    with torch.no_grad():
        for i, (image_input, audio_input, negatives, nframes, path, _) in enumerate(trainer.loaders['test']):

            v_init = trainer.z[int(path[0])]
            z_img = torch.FloatTensor(audio_input.size(0), v_init.shape[0])

            for k in range(audio_input.size(0)):
                z_img[k, :] = trainer.z[int(path[k])]

            if not trainer.args.loading_image:
                image_input = trainer.generator.generate_images(z_img, intervention=None)
                image_input = utils.transform(image_input).detach()

            # compute output
            model_output = trainer.model(image_input, audio_input, [])
            image_output = model_output[0]
            audio_output = model_output[1]

            pooling_ratio = round(audio_input.size(3) / audio_output.size(3))
            nframes.div_(pooling_ratio)

            fps = audio_output.size(3) / len_audio

            for bs in range(image_output.size(0)):

                try:
                    target_writer = imageio.get_writer(folder_name + f'/output_video_{path[bs]}.mp4', fps=fps)
                    matchmap = utils.compute_matchmap(image_output[bs],
                                                      audio_output[bs][:, :, 0:nframes[bs]]).data.cpu().numpy().copy()
                    wav = trainer.loaders['test'].dataset.load_audio_raw(path=path[bs])
                    scipy.io.wavfile.write(folder_name + f'/output_audio_{path[bs]}.mp3', 44100,
                                           wav.astype(np.int16))

                    matchmap = matchmap.transpose(2, 0, 1)  # l, h, w
                    matchmap = matchmap / matchmap.sum()
                    matchmap_l, matchmap_h, matchmap_w = matchmap.shape
                    k_ranges = utils.frange(np.max(matchmap) / 100, np.max(matchmap), np.max(matchmap) / 100)

                    for k in k_ranges:
                        binary_mask = matchmap > k
                        map_temp = np.multiply(matchmap, binary_mask)
                        if np.sum(map_temp) < 0.1:
                            break

                    smoothing_factor = 1
                    struct_element = [[[True]]] * smoothing_factor
                    binary_mask = morph.binary_dilation(binary_mask, struct_element)  # Temporal smoothing
                    matchmap = np.multiply(matchmap, binary_mask)
                    matchmap = (matchmap - np.min(matchmap)) / (np.max(matchmap) - np.min(matchmap))

                    image = trainer.loaders['test'].dataset.load_image_raw(path=path[bs])

                    for t in range(matchmap_l):
                        mask_resize = np.array([cv2.resize(binary_mask[t, :, :].astype(float),
                                                           (image.shape[1], image.shape[0]))] * 3).transpose(1, 2, 0)
                        map_t = cv2.resize(matchmap[t, :, :], (image.shape[1], image.shape[0]))
                        map_t = 1 - map_t
                        map_t = 255 * map_t
                        map_t = map_t.astype(np.uint8)
                        map_t = cv2.applyColorMap(map_t, cv2.COLORMAP_JET)

                        im_final = np.multiply((0.3 * image + 0.7 * map_t), mask_resize) + np.multiply(image,
                                                                                                       1 - mask_resize)

                        target_writer.append_data(im_final)

                    target_writer.close()
                    # -y means overwrite

                    os.system('ffmpeg -y -i ' +
                              folder_name + f'/output_video_{path[bs]}.mp4 -i ' +
                              folder_name + f'/output_audio_{path[bs]}.mp3 -vf scale=1200:1200 -shortest -strict -2 '
                                            '-c:v libx264 ' +
                              folder_name + f'/video_{path[bs]}.mp4')
                except KeyboardInterrupt as e:
                    print('you decided to finish!')

                finally:
                    # Remove temporary files
                    try:
                        os.remove(folder_name + f'/output_video_{path[bs]}.mp4')
                    except OSError:
                        pass
                    try:
                        os.remove(folder_name + f'/output_audio_{path[bs]}.mp3')
                    except OSError:
                        pass

    return False
예제 #42
0
    def choose_melody_pitches(self, notes, register, harmonies, start_with_rest):
        # print 'Choosing pitches'
        for h in harmonies:
            h['pitch_classes'] = [p % 12 for p in h['pitch']]

        set_start_end(notes)
        set_start_end(harmonies)

        # Pick a random pitch from the instrument's register on which to start
        previous_note_index = random.choice(range(int(len(register))))
        prev = register[previous_note_index]

        previous_note = {'duration': 1.0, 'pitch': prev}

        pitch_history = []

        first = True
        # print '-'*10
        for note in notes:
            if first and start_with_rest:
                note['pitch'] = 'rest'
                first = False
                continue
            beats = list(frange(note['start'], note['start'] + note['duration'], .25))
            note_harmonies = []
            for b in beats:
                h = get_at(b, harmonies)
                h = h['pitch_classes']
                if h not in note_harmonies:
                    note_harmonies.append(h)

            if len(note_harmonies) == 1:
                pitch_options = self.get_pitch_options(note_harmonies[0], prev)
            else:
                pitch_options = []

                c = Counter()
                for h in note_harmonies:
                    for p in h:
                        c[p] += 1

                common = []
                for p, count in c.most_common():
                    if count == len(note_harmonies):
                        common.append(p)

                if len(common) > 0:
                    pitch_options = self.get_pitch_options(common, prev)

                if len(pitch_options) == 0:
                    ranked = [p for p, _ in c.most_common() if p not in common]

                    for p in ranked:
                        pitch_options = self.get_pitch_options([p], prev)
                        if len(pitch_options) > 0:
                            break

            if len(pitch_options) == 0:
                pitch_options = [prev - 2, prev - 1, prev + 1, prev + 2]

            note['pitch'] = random.choice(pitch_options)

            self.add_ornament(note, previous_note, note_harmonies, first)

            # print note

            prev = note['pitch']
            previous_note = note
            pitch_history.append(note['pitch'])

            first = False
예제 #43
0
파일: prot.py 프로젝트: certik/chemev
"""Writes all the information about the best fit to the file "protocol" """

import sys
sys.path.append("/home/ondrej/py")

import utils
import iso
from params import parameters
import fit

gauss=False

isodir="/home/ondrej/data/isochrones/696/halo"
data=iso.readfits(isodir+"/datarr.fits")
isos = iso.readisos(isodir)
t=utils.frange(8,10.25,0.001)
p=parameters()
p.load()
m=fit.metallicity(t,p)
s=fit.sfr(t,p)
w=utils.calculateweights(t,s)
if gauss:
    isow=iso.getisosweights_gauss(w,10.**t,m,isos,p.sigma)
else:
    isow=iso.getisosweights(w,10.**t,m,isos)
model=iso.computeCMD(isow,isos)
#model=isos[0][2]*0.0+1.0
model=utils.normalize(model,sum(data.flat))
#model=model/sum(model.flat)

def plot_residuals(d,m):
예제 #44
0
 def makeSquiggles(self, image):
     """
     actual calculations
     :param image: bitmap to squigglify
     :return:
     """
     noOfLines = self.parent.noOfLines.value()
     height = image.height()
     width = image.width()
     amplitude = self.parent.strength.value()
     strokeWidth = self.parent.lineWidth.value()
     detail = self.parent.detail.value()
     invertColors = self.parent.invertColors.checkState() == Qt.Checked
     verticalSquiggles = self.parent.verticalSquiggles.checkState(
     ) == Qt.Checked
     maxBrightness = self.parent.maxBrightness.value()
     minBrightness = self.parent.minBrightness.value()
     self.removeOldGraphicsItems()
     group = QGraphicsItemGroup()
     finalRow = False
     minStepSize = self.parent.minStepSize.value()
     maxStepSize = self.parent.maxStepSize.value()
     # TODO: too much code duplication!
     path = QPainterPath()
     if not verticalSquiggles:
         scaledystep = max(1, height / noOfLines)
         for y in frange(0, height, scaledystep):
             if fabs(y - height) < 1e-3 or y >= height:
                 finalRow = True
             x = 0
             disturbance_direction = -1
             prevX = 0
             prevY = y
             while x < width:
                 disturbance_direction = -disturbance_direction
                 grayvalue = qGray(image.pixel(x, y))
                 if invertColors:
                     grayvalue = 255 - grayvalue
                 stepSize = Mapping.linexp(grayvalue, 0, 255, minStepSize,
                                           maxStepSize)
                 stepSize = Mapping.linlin(stepSize, 1, 10, 1, 10 / detail)
                 amplitudeSize = Mapping.linlin(grayvalue, 0, 255,
                                                amplitude, 0)
                 if x == 0:
                     path = QPainterPath()
                     path.moveTo(x, y)
                 x = prevX + stepSize
                 newY = prevY + amplitudeSize * disturbance_direction
                 if minBrightness <= grayvalue <= maxBrightness:
                     path.quadTo((prevX + x) / 2, newY, x, prevY)
                 else:
                     path.moveTo(x, prevY)
                 if x >= width:
                     item = QGraphicsPathItem(path)
                     pen = QPen()
                     pen.setWidth(strokeWidth)
                     item.setPen(pen)
                     group.addToGroup(item)
                 prevX = x
                 prevY = y
             if finalRow:
                 break
     else:
         scaledxstep = max(1, width / noOfLines)
         for x in frange(0, width, scaledxstep):
             if fabs(x - width) < 1e-3 or x >= width:
                 finalRow = True
             y = 0
             disturbance_direction = -1
             prevX = x
             prevY = 0
             while y < height:
                 disturbance_direction = -disturbance_direction
                 grayvalue = qGray(image.pixel(x, y))
                 if invertColors:
                     grayvalue = 255 - grayvalue
                 stepSize = Mapping.linexp(grayvalue, 0, 255, minStepSize,
                                           maxStepSize)
                 stepSize = Mapping.linlin(stepSize, 1, 10, 1, 10 / detail)
                 amplitudeSize = Mapping.linlin(grayvalue, 0, 255,
                                                amplitude, 0)
                 if y == 0:
                     path = QPainterPath()
                     path.moveTo(x, y)
                 y = prevY + stepSize
                 newX = prevX + amplitudeSize * disturbance_direction
                 if minBrightness <= grayvalue <= maxBrightness:
                     path.quadTo(newX, (prevY + y) / 2, prevX, y)
                 else:
                     path.moveTo(x, prevY)
                 if y >= height:
                     item = QGraphicsPathItem(path)
                     pen = QPen()
                     pen.setWidth(strokeWidth)
                     item.setPen(pen)
                     group.addToGroup(item)
                 prevX = x
                 prevY = y
             if finalRow:
                 break
     self.addNewGraphicsItems(group)
예제 #45
0
    def objective(trial, ctf):
        learning_rate = trial.suggest_uniform('learning_rate', 0.0, 0.1)
        gamma = trial.suggest_uniform('gamma', 0.0, 0.1)
        dimensions = trial.suggest_int('dimensions', 750, 1000)
        x, y = calculate_fisher_discriminant(training_images_flat,
                                             training_labels, ctf)
        local_svm = SVMTree(x.shape[1],
                            list(range(10)),
                            learning_rate,
                            dimensions=dimensions,
                            gamma=gamma)
        return local_svm.train(x, y, 14)

    data = []
    for ctf in frange(0.0, 1.0, 0.2):
        study = optuna.create_study(pruner=MedianPruner())
        study.optimize(lambda trial: objective(trial, ctf), n_trials=25)
        best = study.best_params

        x, y = calculate_fisher_discriminant(training_images_flat,
                                             training_labels, ctf)
        svm = SVMTree(x.shape[1],
                      list(range(10)),
                      best['learning_rate'],
                      dimensions=best['dimensions'],
                      gamma=best['gamma'])
        t1 = time.time()
        svm.train(x, y, 14)
        t2 = time.time()
        adv_ex, bro_ex, grad_ex, peraccuracy = stage(test_images, test_labels,
예제 #46
0
def run(solvent_ratio):
	utils.Molecule.set_params('oplsaa4.prm')

	tail = utils.Molecule('hexanenitrile.arc')
	solvent = utils.Molecule('methane.arc')

	for a in tail.atoms:
		a.x, a.z = a.z, a.x

	directory = 'lammps'
	os.chdir(directory)

	n_steps = 1
	for step in range(0,n_steps):

		atoms = []
		bonds = []
		angles = []
		dihedrals = []

		S = 3.5
		box_size = [20,20,20]
		theta = 0; z = 0.0

		print len(atoms)/len(tail.atoms)
		atom_count = len(atoms)
		solvent_spacing = [(max(solvent.atoms, key=lambda a:a.x).x-min(solvent.atoms, key=lambda a:a.x).x), (max(solvent.atoms, key=lambda a:a.y).y-min(solvent.atoms, key=lambda a:a.y).y), (max(solvent.atoms, key=lambda a:a.z).z-min(solvent.atoms, key=lambda a:a.z).z)]
		solvent_spacing = [x+1.0 for x in solvent_spacing]
		max_vdw_r = max(solvent.atoms, key=lambda a:a.type.vdw_r).type.vdw_r
		solvent_spacing = [max(x,max_vdw_r) for x in solvent_spacing]
		for x in utils.frange(-box_size[0]/2, box_size[0]/2-solvent_spacing[0], solvent_spacing[0]):
			for y in utils.frange(-box_size[1]/2, box_size[1]/2-solvent_spacing[1], solvent_spacing[1]):
				for z in utils.frange(-box_size[2]/2, box_size[2]/2-solvent_spacing[2], solvent_spacing[2]):
					try:
						for a in atoms[:atom_count]:
							if (a.x-x)**2 + (a.y-y)**2 + (a.z-z)**2 < max_vdw_r**2:
								raise Exception()
						solvent.add_to(x, y, z, atoms, bonds, angles, dihedrals)
					except: pass

		T = 94.0
		P = 1.45

		print (len(atoms)-atom_count)/len(solvent.atoms)
		filetypes.write_xyz('out', atoms)

		run_name = 'azoto_solv__'+str(int(step))
	
		atom_types = dict( [(t.type,True) for t in atoms] ).keys()
		atom_type_numbers = dict( [(t,i+1) for i,t in enumerate(atom_types)] )
		is_charged = True

		lammps.write_data_file_general(atoms, bonds, angles, dihedrals, box_size, run_name, atom_types=atom_types)
		os.system('cp ../'+sys.argv[0]+' '+run_name+'.py')

		f = open(run_name+'.in', 'w')
		f.write('units	real\natom_style	full #bonds, angles, dihedrals, impropers, charges\n')

		if is_charged:
			f.write('pair_style lj/cut/coul/long 8.0\n')
		else:
			f.write('pair_style lj/cut 8.0\n')
		if bonds: f.write('bond_style harmonic\n')
		if angles: f.write('angle_style harmonic\n')
		if dihedrals: f.write('dihedral_style opls\n')
		if is_charged: f.write('kspace_style pppm 1.0e-3\n')

		f.write('special_bonds lj/coul 0.0 0.0 0.5\nread_data	'+run_name+'.data\n')

		f.write('''thermo		0
dump	1 all xyz 10000 '''+run_name+'''.xyz

thermo_style custom etotal ke temp pe ebond eangle edihed evdwl ecoul elong press lx ly lz tpcpu
thermo_modify	line multi format float %14.6f

minimize 0.0 1.0e-8 1000 100000
velocity all create '''+str(T)+''' 1 rot yes dist gaussian
fix press all npt temp '''+str(T)+' '+str(T)+''' 100 aniso '''+str(P)+' '+str(P)+''' 500
timestep  4.0
neigh_modify check yes every 1 delay 0
run_style respa 4 2 2 2 inner 2 4.5 6.0 middle 3 7.0 8.0 outer 4
thermo		100
run 25000
unfix press
fix dynamics all nvt temp '''+str(T)+' '+str(T)+''' 100
thermo_style 	custom epair pe etotal
thermo 1
run 25000
''')
		f.close()
		if True: #start multiple processes
			os.system('nohup ~/lammps/src/lmp_g++_no_cuda -in %s.in -log %s.log &> /dev/null &' % (run_name, run_name) )
			print 'Running', run_name
		else:
			os.system('~/lammps/src/lmp_g++_no_cuda -in %s.in -log %s.log' % (run_name, run_name) )
			sys.exit()
	os.chdir('..')
예제 #47
0
def CVL(fixes, lowerBound, upperBound, step, scaleFactor):
    """Return a list (with step number of items).  Each item is a tuple of
    (variance, likelihood).  Variances in the list are equally distributed between
    lowerBound to upperBound. The likelihood is based on Equation 7 in Horne, et al
    and I beleive it is a likelihood cross validation.   
    fixes is a list of fixes where each fix is (time, x, y, locational_variance).
    fixes are assumed to be in chronological order, and time is a number.  The units
    of time are unimportant, as the mobility variance varies with the units chosen.
    
    The algorithm is as follows: Assume a mobility variance, vm.  For the first three fixes,
    pretend that fix2 is missing, and calculate the normal distribution at the observed
    location of fix2 based on the predicted (part way between fix1 and fix3) mean location of
    fix2.  Do this again for fixes 2,3,4 then 3,4,5 etc until the last 3 fixes.  The product
    of the normal distributions is the indicator of the likelihood of the assumed mobility
    variance.

    In Horne, et al (2007), only odd numbered fixes are considered independent.
    in the adehabitat code, each group of three is considered.  This code uses
    the second approach."""
    
    #print "In CVL(); len(fixes) =", len(fixes), "lowerBound =",lowerBound, "upperBound =",upperBound, "step =", step, "scaleFactor =", scaleFactor   

    if len(fixes) < 3:
        raise ValueError, "Not enough fixes provided"

    results = []    
    for vm in utils.frange(lowerBound, (upperBound + step), step):
        #print "vm = ",vm
        likelihood = 1
        for i in range(1, (len(fixes) - 1)):
            #times
            prevTime = fixes[i-1][0]
            thisTime = fixes[i][0]
            nextTime = fixes[i+1][0]
            #locations
            prevX = fixes[i-1][1]
            thisX = fixes[i][1]
            nextX = fixes[i+1][1]
            prevY = fixes[i-1][2]
            thisY = fixes[i][2]
            nextY = fixes[i+1][2]
            #locational Variance
            prevV = fixes[i-1][3]
            nextV = fixes[i+1][3]
            
            T = nextTime - prevTime
            #a = alphai = percent of path
            a = float(thisTime - prevTime) / T 

            # (meanX, meanY) = mui(ti) = mean predicted location at time i
            meanX = prevX + a * (nextX - prevX)
            meanY = prevY + a * (nextY - prevY)

            # v = sigmai^2(ti) = total assumed brownian motion variance at time i
            v = T * a * (1 - a) * vm  +  (1-a)**2 * prevV  +  a**2 * nextV
            
            #distanceSquared = ((thisX - meanX)**2 + (thisY - meanY)**2)
            #print "thisX =",thisX,"thisY =",thisY,"meanX =",meanX,"meanY =",meanY, "v =", v
            #print "distanceSquared =",distanceSquared, "T =", T, "a =", a, "vm =", vm, "prevV =", prevV, "nextV =", nextV,

            # (thisX, thisY) = Zi = location at which to get value of PDF
            normal = Horne2dNormal(thisX, thisY, meanX, meanY, v)
            #print "normal =",normal
            
            # The normal is typically very small (the total area under the normal curve = 1.0)
            # the scale factor keeps the product from decaying to zero with a
            # large number of fixes.  Since the likelihoods are relative, the
            # scale factor will not alter the relative likelihood of the Vm
            likelihood *= (normal * scaleFactor)
            #print "likelihood =",likelihood
            if likelihood == 0:
                break

        results.append((vm, likelihood))
    return results
예제 #48
0
def CVL(fixes, lowerBound, upperBound, step, scaleFactor):
    """Return a list (with step number of items).  Each item is a tuple of
    (variance, likelihood).  Variances in the list are equally distributed between
    lowerBound to upperBound. The likelihood is based on Equation 7 in Horne, et al
    and I beleive it is a likelihood cross validation.   
    fixes is a list of fixes where each fix is (time, x, y, locational_variance).
    fixes are assumed to be in chronological order, and time is a number.  The units
    of time are unimportant, as the mobility variance varies with the units chosen.
    
    The algorithm is as follows: Assume a mobility variance, vm.  For the first three fixes,
    pretend that fix2 is missing, and calculate the normal distribution at the observed
    location of fix2 based on the predicted (part way between fix1 and fix3) mean location of
    fix2.  Do this again for fixes 2,3,4 then 3,4,5 etc until the last 3 fixes.  The product
    of the normal distributions is the indicator of the likelihood of the assumed mobility
    variance.

    In Horne, et al (2007), only odd numbered fixes are considered independent.
    in the adehabitat code, each group of three is considered.  This code uses
    the second approach."""

    #print "In CVL(); len(fixes) =", len(fixes), "lowerBound =",lowerBound, "upperBound =",upperBound, "step =", step, "scaleFactor =", scaleFactor

    if len(fixes) < 3:
        raise ValueError, "Not enough fixes provided"

    results = []
    for vm in utils.frange(lowerBound, (upperBound + step), step):
        #print "vm = ",vm
        likelihood = 1
        for i in range(1, (len(fixes) - 1)):
            #times
            prevTime = fixes[i - 1][0]
            thisTime = fixes[i][0]
            nextTime = fixes[i + 1][0]
            #locations
            prevX = fixes[i - 1][1]
            thisX = fixes[i][1]
            nextX = fixes[i + 1][1]
            prevY = fixes[i - 1][2]
            thisY = fixes[i][2]
            nextY = fixes[i + 1][2]
            #locational Variance
            prevV = fixes[i - 1][3]
            nextV = fixes[i + 1][3]

            T = nextTime - prevTime
            #a = alphai = percent of path
            a = float(thisTime - prevTime) / T

            # (meanX, meanY) = mui(ti) = mean predicted location at time i
            meanX = prevX + a * (nextX - prevX)
            meanY = prevY + a * (nextY - prevY)

            # v = sigmai^2(ti) = total assumed brownian motion variance at time i
            v = T * a * (1 - a) * vm + (1 - a)**2 * prevV + a**2 * nextV

            #distanceSquared = ((thisX - meanX)**2 + (thisY - meanY)**2)
            #print "thisX =",thisX,"thisY =",thisY,"meanX =",meanX,"meanY =",meanY, "v =", v
            #print "distanceSquared =",distanceSquared, "T =", T, "a =", a, "vm =", vm, "prevV =", prevV, "nextV =", nextV,

            # (thisX, thisY) = Zi = location at which to get value of PDF
            normal = Horne2dNormal(thisX, thisY, meanX, meanY, v)
            #print "normal =",normal

            # The normal is typically very small (the total area under the normal curve = 1.0)
            # the scale factor keeps the product from decaying to zero with a
            # large number of fixes.  Since the likelihoods are relative, the
            # scale factor will not alter the relative likelihood of the Vm
            likelihood *= (normal * scaleFactor)
            #print "likelihood =",likelihood
            if likelihood == 0:
                break

        results.append((vm, likelihood))
    return results
def readCEData(parameters, variable):
	try:
		fileName = parameters.get(variable, 'input_files')
		field = parameters.get(variable, 'field')
		popType = parameters.get(variable, 'population_type')
		dims = parameters.getint(variable, 'dimensions')
		if popType != 'statistical' and popType != 'spatial':
			print 'ERROR: Population type ' + popType + ' for field ' + field + ' incorrect.'
		if dims < 1 or dims > 4:
			print 'ERROR: Number of dimensions ' + dims + ' for field ' + field + ' is incorrect. It should be from 1 up to 4.'

		stat_from = ""
		time_from = ""
		group_from = ""
		if parameters.has_option(variable, 'stat_from'):
			stat_from = eval(parameters.get(variable, 'stat_from'))
			stat_to = eval(parameters.get(variable, 'stat_to'))
			stat_step = 1
			if parameters.has_option(variable, 'stat_step'):
				stat_step = eval(parameters.get(variable, 'stat_step'))
		if parameters.has_option(variable, 'time_from'):
			time_from = eval(parameters.get(variable, 'time_from'))
			time_to = eval(parameters.get(variable, 'stat_to'))
			time_step = 1
			if parameters.has_option(variable, 'time_step'):
				time_step = eval(parameters.get(variable, 'time_step'))
		if parameters.has_option(variable, 'group_from'):
			group_from = eval(parameters.get(variable, 'group_from'))
			group_to = eval(parameters.get(variable, 'group_to'))
			group_step = 1
			if parameters.has_option(variable, 'group_step'):
				group_step = eval(parameters.get(variable, 'group_step'))

		#Read actual dimensions in the field
		fName = fileName.replace('[P]', str(stat_from)).replace('[T]', str(time_from)).replace('[G]', str(group_from))
		fileDims = getDataDims(fName, field)
		dimesionsToAdd = dims - fileDims

		if dims < fileDims:
			print 'ERROR: Variable ' + variable + ' has more dimensions than specified.'	

		if dims == 1:
			if popType == 'spatial':
				print 'ERROR: Variable ' + variable + ' should have more than one dimension to use spatial population_type.'
		if dimesionsToAdd == 0:
			if popType == 'spatial':
				aux_init_data = readSpatialData(fileName, field, parameters, variable)
			if popType == 'statistical':
				aux_init_data = readField(fileName, field)
		if dimesionsToAdd == 1:
			if popType == 'spatial':
				if fileName.count('[T]') != 1:
					print 'ERROR: Spatial population for variable ' + variable + ' must have "[T]" wildcard.'
				try:
					time_from = eval(parameters.get(variable, 'time_from'))
					time_to = eval(parameters.get(variable, 'time_to'))
					initial = True
					i = 0
					for index in u.frange(time_from, time_to + time_step, time_step):
						fName = fileName.replace('[T]', str(index))
						tmp = readSpatialData(fName, field, parameters, variable)
						if initial:
							aux_init_data = np.ndarray(shape=(round((time_to - time_from)/time_step + 1), len(tmp)), dtype=object)
							initial = False
						aux_init_data[i, :] = tmp[:]
						i = i + 1
				except ValueError as e:
					print 'ERROR: ', e

				except ConfigParser.NoOptionError:
					print 'ERROR: Error in ', variable, '. Spatial population must have time_from and time_to configurations.'
			if popType == 'statistical':
				if fileName.count('[P]') != 1:
					print 'ERROR: Statistical population for variable ' + variable + ' must have "[P]" wildcard.'
				try:
					stat_from = eval(parameters.get(variable, 'stat_from'))
					stat_to = eval(parameters.get(variable, 'stat_to'))
					stat_step = 1
					if parameters.has_option(variable, 'stat_step'):
						stat_step = eval(parameters.get(variable, 'stat_step'))
					initial = True
					i = 0
					for index_stat in u.frange(stat_from, stat_to + stat_step, stat_step):
						fName = fileName.replace('[P]', str(index_stat))
						var = readField (fName, field)
						if initial:
							aux_init_data = np.ndarray(shape=(var.shape + (round((stat_to - stat_from)/stat_step + 1),)), dtype='float')
							initial = False
						aux_init_data[..., i] = var
						i = i + 1
				except ValueError as e:
					import traceback
					print traceback.format_exc()
					print 'ERROR: ', e

				except ConfigParser.NoOptionError:
					print 'ERROR: Error in ', variable, '. Statistical population must have stat_from and stat_to configurations.'	
		if dimesionsToAdd == 2:
			if popType == 'spatial':
				if fileName.count('[T]') != 1 or fileName.count('[G]') != 1:
					print 'ERROR: Spatial population for variable ' + variable + ' must have "[T]" and "[G]" wildcards.'
				try:
					group_from = eval(parameters.get(variable, 'group_from'))
					group_to = eval(parameters.get(variable, 'group_to'))
					group_step = 1
					if parameters.has_option(variable, 'group_step'):
						group_step = eval(parameters.get(variable, 'group_step'))
					time_from = eval(parameters.get(variable, 'time_from'))
					time_to = eval(parameters.get(variable, 'time_to'))
					time_step = 1
					if parameters.has_option(variable, 'time_step'):
						time_step = eval(parameters.get(variable, 'time_step'))
					initial = True
					i = 0
					for index_group in u.frange(group_from, group_to + group_step, group_step):
						j = 0
						for index_time in u.frange(time_from, time_to + time_step, time_step):
							fName = fileName.replace('[T]', str(index_time)).replace('[G]', str(index_group))
							tmp = readSpatialData(fName, field, parameters, variable)
							if initial:
								aux_init_data = np.ndarray(shape=(round((group_to - group_from)/group_step + 1), round((time_to - time_from)/time_step + 1), len(tmp)), dtype=object)
								initial = False
							aux_init_data[i, j, :] = tmp[:]
							j = j + 1
						i = i + 1
				except ValueError as e:
					print 'ERROR: ', e

				except ConfigParser.NoOptionError:
					print 'ERROR: Error in ', variable, '. Spatial population must have group_from, group_to, time_from and time_to configurations.'
			if popType == 'statistical':
				if fileName.count('[P]') != 1 or fileName.count('[T]') != 1:
					print 'ERROR: Statistical population for variable ' + variable + ' must have "[P]" and "[T]" wildcards.'
				try:
					time_from = eval(parameters.get(variable, 'time_from'))
					time_to = eval(parameters.get(variable, 'time_to'))
					time_step = 1
					if parameters.has_option(variable, 'time_step'):
						time_step = eval(parameters.get(variable, 'time_step'))
					stat_from = eval(parameters.get(variable, 'stat_from'))
					stat_to = eval(parameters.get(variable, 'stat_to'))
					stat_step = 1
					if parameters.has_option(variable, 'stat_step'):
						stat_step = eval(parameters.get(variable, 'stat_step'))
					initial = True
					i = 0
					for index_time in u.frange(time_from, time_to + time_step, time_step):
						j = 0
						for index_stat in u.frange(stat_from, stat_to + stat_step, stat_step):
							fName = fileName.replace('[P]', str(index_stat)).replace('[T]', str(index_time))
							var = readField (fName, field)
							if initial:
								aux_init_data = np.ndarray(shape=((round((time_to - time_from)/time_step + 1),) + var.shape + (round((stat_to - stat_from)/stat_step + 1),)), dtype='float')
								initial = False
							aux_init_data[i, ..., j] = var
							j = j + 1
						i = i + 1
			
				except ValueError as e:
					print 'ERROR: ', e

				except ConfigParser.NoOptionError:
					print 'ERROR: Error in ', variable, '. Statistical population must have time_from, time_to, stat_from and stat_to configurations.'
		if dimesionsToAdd == 3:
			if popType == 'spatial':
				print 'ERROR: Error in ', variable, '. Cannot add more than 2 extra dimensions to the spatial data provided.'
			if popType == 'statistical':
				if fileName.count('[P]') != 1 or fileName.count('[T]') != 1 or fileName.count('[G]') != 1:
					print 'ERROR: Statistical population for variable ' + variable + ' must have "[P]", "[G]" and "[T]" wildcards.'
				try:
					group_from = eval(parameters.get(variable, 'group_from'))
					group_to = eval(parameters.get(variable, 'group_to'))
					group_step = 1
					if parameters.has_option(variable, 'group_step'):
						group_step = eval(parameters.get(variable, 'group_step'))
					time_from = eval(parameters.get(variable, 'time_from'))
					time_to = eval(parameters.get(variable, 'time_to'))
					time_step = 1
					if parameters.has_option(variable, 'time_step'):
						time_step = eval(parameters.get(variable, 'time_step'))
					stat_from = eval(parameters.get(variable, 'stat_from'))
					stat_to = eval(parameters.get(variable, 'stat_to'))
					stat_step = 1
					if parameters.has_option(variable, 'stat_step'):
						stat_step = eval(parameters.get(variable, 'stat_step'))
					initial = True
					i = 0
					for index_group in u.frange(group_from, group_to + group_step, group_step):
						j = 0
						for index_time in u.frange(time_from, time_to + time_step, time_step):
							k = 0
							for index_stat in u.frange(stat_from, stat_to + stat_step, stat_step):
								fName = fileName.replace('[P]', str(index_stat)).replace('[T]', str(index_time)).replace('[G]', str(index_group))
								var = readField (fName, field)
								if initial:
									aux_init_data = np.ndarray(shape=((round((group_to - group_from)/group_step + 1), round((time_to - time_from)/time_step + 1),) + var.shape + (round((stat_to - stat_from)/stat_step + 1),)), dtype='float')
									initial = False
								aux_init_data[i, j, ..., k] = var
								k = k + 1
							j = j + 1
						i = i + 1
			
				except ValueError as e:
					print 'ERROR: ', e

				except ConfigParser.NoOptionError:
					print 'ERROR: Error in ', variable, '. Statistical population must have group_from, group_to, time_from, time_to, stat_from and stat_to configurations.'
		return aux_init_data
	except Exception as e:
		print 'ERROR: ', e
def readMeshlessData(parameters, variable):
	try:
		fileName = parameters.get(variable, 'input_files')
		field = parameters.get(variable, 'field')
		popType = parameters.get(variable, 'population_type')
		dims = parameters.getint(variable, 'dimensions')
		if popType != 'statistical' and popType != 'spatial':
			print 'ERROR: Population type ' + popType + ' for field ' + field + ' incorrect.'
			
		if dims < 2 or dims > 4:
			print 'ERROR: Number of dimensions ' + dims + ' for field ' + field + ' is incorrect. It should be 2, 3, or 4.'
			
		if dims == 2:
			if popType == 'spatial':
				return np.array(readSpatialData(fileName, field, parameters, variable))
			if popType == 'statistical':
				if fileName.count('[P]') != 1:
					print 'ERROR: Statistical population for variable ' + variable + ' must have "[P]" wildcard.'
					 
				try:
					stat_from = eval(parameters.get(variable, 'stat_from'))
					stat_to = eval(parameters.get(variable, 'stat_to'))
					stat_step = 1
					if parameters.has_option(variable, 'stat_step'):
						stat_step = eval(parameters.get(variable, 'stat_step'))
					initial = True
					i = 0
					for index_stat in u.frange(stat_from, stat_to + stat_step, stat_step):
						fName = fileName.replace('[P]', str(index_stat))
						var = readField (fName, field)
						if initial:
							aux_init_data = np.ndarray(shape=(var.shape[0], round((stat_to - stat_from)/stat_step + 1)), dtype='float')
							initial = False
						aux_init_data[:, i] = np.resize(var, var.size)
						i = i + 1
			
				except ValueError as e:
					print 'ERROR: ', e
					

				except ConfigParser.NoOptionError:
					print 'ERROR: Error in ', variable, '. Statistical population must have stat_from and stat_to configurations.'
						
		if dims == 3:
			if popType == 'spatial':
				if fileName.count('[T]') != 1:
					print 'ERROR: Spatial population for variable ' + variable + ' must have "[T]" wildcard.'
					 
				try:
					time_from = eval(parameters.get(variable, 'time_from'))
					time_to = eval(parameters.get(variable, 'time_to'))
					time_step = 1
					if parameters.has_option(variable, 'time_step'):
						time_step = eval(parameters.get(variable, 'time_step'))
					initial = True
					i = 0
					for index in u.frange(time_from, time_to + time_step, time_step):
						fName = fileName.replace('[T]', str(index))
						tmp = readSpatialData(fName, field, parameters, variable)
						if initial:
							aux_init_data = np.ndarray(shape=(round((time_to - time_from)/time_step + 1), len(tmp)), dtype=object)
							initial = False
						aux_init_data[i, :] = tmp[:]
						i = i + 1
				except ValueError as e:
					print 'ERROR: ', e
					

				except ConfigParser.NoOptionError:
					print 'ERROR: Error in ', variable, '. Spatial population must have time_from and time_to configurations.'
					
			if popType == 'statistical':
				if fileName.count('[P]') != 1 or fileName.count('[T]') != 1:
					print 'ERROR: Statistical population for variable ' + variable + ' must have "[P]" and "[T]" wildcard.'
					 
				try:
					stat_from = eval(parameters.get(variable, 'stat_from'))
					stat_to = eval(parameters.get(variable, 'stat_to'))
					stat_step = 1
					if parameters.has_option(variable, 'stat_step'):
						stat_step = eval(parameters.get(variable, 'stat_step'))
					time_from = eval(parameters.get(variable, 'time_from'))
					time_to = eval(parameters.get(variable, 'time_to'))
					time_step = 1
					if parameters.has_option(variable, 'time_step'):
						time_step = eval(parameters.get(variable, 'time_step'))
					initial = True
					i = 0
					for index_time in u.frange(time_from, time_to + time_step, time_step):
						j = 0
						for index_stat in u.frange(stat_from, stat_to + stat_step, stat_step):
							fName = fileName.replace('[P]', str(index_stat)).replace('[T]', str(index_time))
							var = readField (fName, field)
							if initial:
								aux_init_data = np.ndarray(shape=(round((time_to - time_from)/time_step + 1), var.shape[0], round((stat_to - stat_from)/stat_step + 1)), dtype='float')
								initial = False
							aux_init_data[i, :, j] = np.resize(var, var.size)
							j = j + 1
						i = i + 1
			
				except ValueError as e:
					print 'ERROR: ', e
					

				except ConfigParser.NoOptionError:
					print 'ERROR: Error in ', variable, '. Statistical population must have time_from, time_to, stat_from and stat_to configurations.'
						
		if dims == 4:
			if popType == 'spatial':
				if fileName.count('[T]') != 1 or fileName.count('[G]') != 1:
					print 'ERROR: Spatial population for variable ' + variable + ' must have "[T]" and "[G]" wildcard.'
					 
				try:
					group_from = eval(parameters.get(variable, 'group_from'))
					group_to = eval(parameters.get(variable, 'group_to'))
					group_step = 1
					if parameters.has_option(variable, 'group_step'):
						group_step = eval(parameters.get(variable, 'group_step'))
					time_from = eval(parameters.get(variable, 'time_from'))
					time_to = eval(parameters.get(variable, 'time_to'))
					time_step = 1
					if parameters.has_option(variable, 'time_step'):
						time_step = eval(parameters.get(variable, 'time_step'))
					initial = True
					i = 0
					for index_group in u.frange(group_from, group_to + group_step, group_step):
						j = 0
						for index_time in u.frange(time_from, time_to + time_step, time_step):
							fName = fileName.replace('[T]', str(index_time)).replace('[G]', str(index_group))
							tmp = readSpatialData(fName, field, parameters, variable)
							if initial:
								aux_init_data = np.ndarray(shape=(round((group_to - group_from)/group_step + 1), round((time_to - time_from)/time_step + 1), len(tmp)), dtype=object)
								initial = False
							aux_init_data[i, j, :] = tmp[:]
							j = j + 1
						i = i + 1
				except ValueError as e:
					print 'ERROR: ', e
					

				except ConfigParser.NoOptionError:
					print 'ERROR: Error in ', variable, '. Spatial population must have group_from, group_to, time_from and time_to configurations.'
					
			if popType == 'statistical':
				if fileName.count('[P]') != 1 or fileName.count('[T]') != 1 or fileName.count('[G]') != 1:
					print 'ERROR: Statistical population for variable ' + variable + ' must have "[P]", "[G]" and "[T]" wildcard.'
					 
				try:
					group_from = eval(parameters.get(variable, 'group_from'))
					group_to = eval(parameters.get(variable, 'group_to'))
					group_step = 1
					if parameters.has_option(variable, 'group_step'):
						group_step = eval(parameters.get(variable, 'group_step'))
					stat_from = eval(parameters.get(variable, 'stat_from'))
					stat_to = eval(parameters.get(variable, 'stat_to'))
					stat_step = 1
					if parameters.has_option(variable, 'stat_step'):
						stat_step = eval(parameters.get(variable, 'stat_step'))
					time_from = eval(parameters.get(variable, 'time_from'))
					time_to = eval(parameters.get(variable, 'time_to'))
					time_step = 1
					if parameters.has_option(variable, 'time_step'):
						time_step = eval(parameters.get(variable, 'time_step'))
					initial = True
					i = 0
					for index_group in u.frange(group_from, group_to + group_step, group_step):
						j = 0
						for index_time in u.frange(time_from, time_to + time_step, time_step):
							k = 0
							for index_stat in u.frange(stat_from, stat_to + stat_step, stat_step):
								fName = fileName.replace('[P]', str(index_stat)).replace('[T]', str(index_time)).replace('[G]', str(index_group))
								var = readField (fName, field)
								if initial:
									aux_init_data = np.ndarray(shape=(round((group_to - group_from)/group_step + 1), round((time_to - time_from)/time_step + 1), var.shape[0], round((stat_to - stat_from)/stat_step + 1)), dtype='float')
									initial = False
								aux_init_data[i, j, :, k] = np.resize(var, var.size)
								k = k + 1
							j = j + 1
						i = i + 1
				except ValueError as e:
					print 'ERROR: ', e
					

				except ConfigParser.NoOptionError:
					print 'ERROR: Error in ', variable, '. Statistical population must have stat_from and stat_to configurations.'
						

		return aux_init_data
	except Exception as e:
		print 'ERROR: ', e
 def raycast(self, screen, numrays=5, angle=45):
     self.rays = []
     for curangle in utils.frange(-angle, angle, angle / 2, inclusive=True):
         r, c = utils.ray(screen, self.pos, self.rot + utils.rad(curangle))
         self.rays.append(Ray(r, c, self.pos))
예제 #52
0
                self.running = False
                self.ticks -= self.STEADY_STATE_THRESHOLD  # hack to make run() return the right val
                self.print("Controller reached steady state in {} ticks".format(self.ticks))
        else:
            self.steady_state_ticks = 0

        output = error * self.PROPORTIONAL_GAIN

        self.temperature_delta = output


if __name__ == "__main__":
    # sim = PController(0.01)
    # sim.run()

    results = {}
    start = 0.001
    step = 0.01
    stop = 0.999

    for gain in frange(start, stop, step):
        sim = PController(gain, verbose=False)
        results[gain] = sim.run()

    print("{:<10}|{:>8}".format("Gain", "Ticks"))
    for gain, ticks in sorted(results.items(), key=operator.itemgetter(0)):
        print("{:<10f}|{:>8}".format(gain, ticks))

    gain, ticks = min(results.items(), key=operator.itemgetter(1))
    print("Winner: {:f} at {} ticks".format(gain, ticks))
def readGraphData(parameters, variable):
    try:
        fieldType = parameters.get(variable, "field_type")
        fileName = parameters.get(variable, "input_files")
        field = parameters.get(variable, "field")
        popType = parameters.get(variable, "population_type")
        dims = parameters.getint(variable, "dimensions")
        if popType != "statistical" and popType != "spatial":
            print "ERROR: Population type " + popType + " for field " + field + " incorrect."

        if fieldType != "edge" and fieldType != "node":
            print "ERROR: Field type" + fieldType + " for field " + field + " incorrect."

        if dims < 2 or dims > 4:
            print "ERROR: Number of dimensions " + dims + " for field " + field + " is incorrect. It should be 2, 3, or 4."

        if dims == 2:
            if popType == "spatial":
                if fieldType == "edge":
                    print "ERROR: Edge, " + field + ", population cannot be spatial."

                aux_init_data = readGraphFieldSpatial(fileName, field)
            if popType == "statistical":
                if fileName.count("[P]") != 1:
                    print "ERROR: Statistical population for bidimensional variable " + variable + ' must have "[P]" wildcard. E.g: ./output_[P]/result.dot'

                try:
                    stat_from = eval(parameters.get(variable, "stat_from"))
                    stat_to = eval(parameters.get(variable, "stat_to"))
                    stat_step = 1
                    if parameters.has_option(variable, "stat_step"):
                        stat_step = eval(parameters.get(variable, "stat_step"))
                    initial = True
                    i = 0
                    for index in u.frange(stat_from, stat_to + stat_step, stat_step):
                        print stat_from, index
                        fName = fileName.replace("[P]", str(index))
                        g = readGraphField(fName, field, fieldType)
                        if initial:
                            aux_init_data = np.ndarray(
                                shape=(len(g), round((stat_to - stat_from) / stat_step + 1)), dtype="float"
                            )
                            initial = False
                        aux_init_data[:, i] = g[:]
                        i = i + 1
                except ValueError as e:
                    print "ERROR: ", e

                except ConfigParser.NoOptionError:
                    print "ERROR: Error in ", variable, ". Bidimensional statistical population must have stat_from and stat_to configurations."

        if dims == 3:
            if popType == "spatial":
                if fileName.count("[T]") != 1:
                    print "ERROR: Spatial population for tridimensional variable " + variable + ' must have "[T]" wildcard. E.g: ./output_[T]/result.dot'

                aux_init_data = []
                if fieldType == "edge":
                    print "ERROR: Edge, " + field + ", population cannot be spatial."

                try:
                    time_from = eval(parameters.get(variable, "time_from"))
                    time_to = eval(parameters.get(variable, "time_to"))
                    time_step = 1
                    if parameters.has_option(variable, "time_step"):
                        time_step = eval(parameters.get(variable, "time_step"))
                    initial = True
                    i = 0
                    for index in u.frange(time_from, time_to + time_step, time_step):
                        fName = fileName.replace("[T]", str(index))
                        tmp = readGraphFieldSpatial(fName, field)
                        if initial:
                            aux_init_data = np.ndarray(
                                shape=(round((time_to - time_from) / time_step + 1), len(tmp)), dtype=object
                            )
                            initial = False
                        aux_init_data[i, :] = tmp[:]
                        i = i + 1
                except ValueError as e:
                    print "ERROR: ", e

                except ConfigParser.NoOptionError:
                    print "ERROR: Error in ", variable, ". Tridimensional spatial population must have time_from and time_to configurations."

            if popType == "statistical":
                if fileName.count("[P]") != 1 or fileName.count("[T]") != 1:
                    print "ERROR: Statistical population for tridimensional variable " + variable + ' must have "[P]" and "[T]" wildcards. E.g: ./output_[P]/result[T].dot'

                try:
                    stat_from = eval(parameters.get(variable, "stat_from"))
                    stat_to = eval(parameters.get(variable, "stat_to"))
                    stat_step = 1
                    if parameters.has_option(variable, "stat_step"):
                        stat_step = eval(parameters.get(variable, "stat_step"))
                    time_from = eval(parameters.get(variable, "time_from"))
                    time_to = eval(parameters.get(variable, "time_to"))
                    time_step = 1
                    if parameters.has_option(variable, "time_step"):
                        time_step = eval(parameters.get(variable, "time_step"))
                    initial = True
                    i = 0
                    for index_t in u.frange(time_from, time_to + time_step, time_step):
                        j = 0
                        for index_s in u.frange(stat_from, stat_to + stat_step, stat_step):
                            fName = fileName.replace("[P]", str(index_s)).replace("[T]", str(index_t))
                            g = readGraphField(fName, field, fieldType)
                            if initial:
                                aux_init_data = np.ndarray(
                                    shape=(
                                        round((time_to - time_from) / time_step + 1),
                                        len(g),
                                        round((stat_to - stat_from) / stat_step + 1),
                                    ),
                                    dtype="float",
                                )
                                initial = False
                            aux_init_data[i, :, j] = g[:]
                            j = j + 1
                        i = i + 1
                except ValueError as e:
                    print "ERROR: ", e

                except ConfigParser.NoOptionError:
                    print "ERROR: Error in ", variable, ". Tridimensional statistical population must have time_from, time_to, stat_from and stat_to configurations."

        if dims == 4:
            if popType == "spatial":
                if fileName.count("[T]") != 1 or fileName.count("[G]") != 1:
                    print "ERROR: Spatial population for 4-dimensional variable " + variable + ' must have "[T]" and "[G]" wildcards. E.g: ./output_[T]_[G]/result.dot'

                aux_init_data = []
                if fieldType == "edge":
                    print "ERROR: Edge, " + field + ", population cannot be spatial."

                try:
                    time_from = eval(parameters.get(variable, "time_from"))
                    time_to = eval(parameters.get(variable, "time_to"))
                    time_step = 1
                    if parameters.has_option(variable, "time_step"):
                        time_step = eval(parameters.get(variable, "time_step"))
                    group_from = eval(parameters.get(variable, "group_from"))
                    group_to = eval(parameters.get(variable, "group_to"))
                    group_step = 1
                    if parameters.has_option(variable, "group_step"):
                        group_step = eval(parameters.get(variable, "group_step"))
                    initial = True
                    i = 0
                    for index_g in u.frange(group_from, group_to + group_step, group_step):
                        j = 0
                        for index_t in u.frange(time_from, time_to + time_step, time_step):
                            fName = fileName.replace("[T]", str(index_t)).replace("[G]", str(index_g))
                            tmp = readGraphFieldSpatial(fName, field)
                            if initial:
                                aux_init_data = np.ndarray(
                                    shape=(
                                        round((group_to - group_from) / group_step + 1),
                                        round((time_to - time_from) / time_step + 1),
                                        len(tmp),
                                    ),
                                    dtype=object,
                                )
                                initial = False
                            aux_init_data[i, j, :] = tmp[:]
                            j = j + 1
                        i = i + 1
                except ValueError as e:
                    print "ERROR: ", e

                except ConfigParser.NoOptionError:
                    print "ERROR: Error in ", variable, ". 4-dimensional spatial population must have group_from, group_to, time_from and time_to configurations."

            if popType == "statistical":
                if fileName.count("[P]") != 1 or fileName.count("[T]") != 1 or fileName.count("[G]") != 1:
                    print "ERROR: Statistical population for 4-dimensional variable " + variable + ' must have "[P]" and "[T]" and "[G]" wildcards. E.g: ./output_[P]_[G]/result[T].dot'

                try:
                    stat_from = eval(parameters.get(variable, "stat_from"))
                    stat_to = eval(parameters.get(variable, "stat_to"))
                    stat_step = 1
                    if parameters.has_option(variable, "stat_step"):
                        stat_step = eval(parameters.get(variable, "stat_step"))
                    time_from = eval(parameters.get(variable, "time_from"))
                    time_to = eval(parameters.get(variable, "time_to"))
                    time_step = 1
                    if parameters.has_option(variable, "time_step"):
                        time_step = eval(parameters.get(variable, "time_step"))
                    group_from = eval(parameters.get(variable, "group_from"))
                    group_to = eval(parameters.get(variable, "group_to"))
                    group_step = 1
                    if parameters.has_option(variable, "group_step"):
                        group_step = eval(parameters.get(variable, "group_step"))
                    initial = True
                    i = 0
                    for index_g in u.frange(group_from, group_to + group_step, group_step):
                        j = 0
                        for index_t in u.frange(time_from, time_to + time_step, time_step):
                            k = 0
                            for index_s in u.frange(stat_from, stat_to + stat_step, stat_step):
                                fName = (
                                    fileName.replace("[P]", str(index_s))
                                    .replace("[T]", str(index_t))
                                    .replace("[G]", str(index_g))
                                )
                                g = readGraphField(fName, field, fieldType)
                                if initial:
                                    aux_init_data = np.ndarray(
                                        shape=(
                                            round((group_to - group_from) / group_step + 1),
                                            round((time_to - time_from) / time_step + 1),
                                            var.shape[0],
                                            round((stat_to - stat_from) / stat_step + 1),
                                        ),
                                        dtype="float",
                                    )
                                    initial = False
                                aux_init_data[i, j, :, k] = g[:]
                                k = k + 1
                            j = j + 1
                        i = i + 1
                except ValueError as e:
                    print "ERROR: ", e

                except ConfigParser.NoOptionError:
                    print "ERROR: Error in ", variable, ". Tridimensional statistical population must have group_from, group_to, time_from, time_to, stat_from and stat_to configurations."

        return aux_init_data
    except Exception as e:
        print "ERROR: ", e
예제 #54
0
def test1():
    for f in utils.frange(1, 2, 0.16):
        print f
    for f in utils.frange(3, 2, -0.16):
        print f
예제 #55
0
if __name__ == "__main__":
    # sim = PIController(0.01, 0.01)
    # sim.run()

    results = defaultdict(dict)

    pg_args = (0.0, 1.0, 0.05)
    ig_args = (-1.0, 1.0, 0.1)

    total_sims = ((pg_args[1] - pg_args[0]) / pg_args[2]) * (
        (ig_args[1] - ig_args[0]) / ig_args[2])

    print("Doing {} simulations...".format(total_sims))
    sims = 0
    for proportional_gain in frange(*pg_args):
        for integral_gain in frange(*ig_args):
            sim = PIController(proportional_gain, integral_gain, verbose=False)
            results[proportional_gain][integral_gain] = sim.run()
            sims += 1
            if sims % 100 == 0:
                print("Done {} of {} ({} %)".format(
                    sims, total_sims, round(100 * sims / total_sims, 0)))

    min_ticks = 1E6
    min_pg = 0
    min_ig = 0
    for proportional_gain in results:
        for integral_gain in results[proportional_gain]:
            ticks = results[proportional_gain][integral_gain]
            if ticks < min_ticks:
예제 #56
0
def simul(isodir):
    """ Read in parameters, data and isochrones. Create callback functions
    for the optimization routine, one of which will return the log(likelihood)
    and the other of which will print the best-fit parameter values. Having
    done this, call the optimization routine to minimize log(L).
    """
    log_tmax = math.log10(13.7e9)
    params=parameters()
    eps=0.01
    #feh
    params.set("m0y"   ,1.0, 0,2.5,True)
    params.set("m0cphi",-0.001,  -pi/2+eps,0,True)
    params.set("m0cr"  ,0.01,  0,2,True)
    params.set("m1y"   ,-2.5,  -2.5,0.9,True)
    params.set("m1cphi",1.67,  pi/2+eps,pi,True)
    params.set("m1cr"  ,1.06,  0,2,True)
    params.set("sigma" ,0.2,  0,1, True)
    params.set("dsigmadlogt" ,0.2,  -1,1, True)

    #sfr
    params.set("s0x"   ,8.0,   8.0,9.0,True)
    params.set("s0y"   ,0.5,   0.0,1,True)
    params.set("s0tx"  ,0.1,   0.,1.,True)
    params.set("s0ty"  ,0.1,   0,1,True)
    params.set("s1tx"  ,0.1,   0.,1.,True)
    params.set("s1ty"  ,0.1,   -1,1,True)
    params.set("s1x"   ,0.5,   0,1,True)
    params.set("s1y"   ,1.0,   0.0,1.0,False)
    params.set("s2x"   ,log_tmax,  9.5,10.25,True)
    params.set("s2y"   ,0.1,   0,1.0,True)
    params.set("s2tx"  ,0.1,   0.,1.,True)
    params.set("s2ty"  ,0.1,   0.,1.,True)

    if len(sys.argv) == 2:
        if sys.argv[1] == "start": #run with a param to start from the beginning
            params.save()
    params.load()
    if not params.pars.has_key('dsigmadlogt'):
        params.set('dsigmadlogt',0.,0,False)
    if not params.pars.has_key('dsigmadlogs'):  # Hook for SFR-depenedent spread; not fully implemented 
        params.set('dsigmadlogs',0.,0,False)
    if len(sys.argv) == 2:
        if sys.argv[1] == "nudge": #Tweak the values near their limits
             print "Nudging parameters near the limits"
             p1 = params.getl()
             utils.nudge(params)
             p2 = params.getl()
             for pp1,pp2 in zip(p1,p2):
                 if pp1[1] != pp2[1]:
                      print "%s %.8f -> %.8f" % (pp1[0],pp1[1],pp2[1])

    data=iso.readfits(isodir+"/datarr.fits")
    isos = iso.readisos(isodir)
    t=utils.frange(8,log_tmax,0.001)
    def f(par):
        params.setvalues(par)
        p = params
        w=utils.calculateweights(t,sfr(t,params))
        # isow=iso.getisosweights(w,10.**t,metallicity(t,params),isos)
        if p.sigma > 0.:
            if p.dsigmadlogt == 0.:
                isow=iso.getisosweights_gauss(w,10.**t,metallicity(t,p),isos,p.sigma)
            if p.dsigmadlogt != 0.:
#               print "Gaussian sigma, ds/dlogt ",p.sigma,p.dsigmadlogt
                isow=iso.getisosweights_vgauss(w,10.**t,metallicity(t,p),isos,p.sigma,p.dsigmadlogt)
            if p.dsigmadlogs != 0.: # Hook for SFR-depenedent spread; not fully implemented 
                isow=iso.getisosweights_sgauss(w,10.**t,sfr(t,params),metallicity(t,p),
                   isos,p.sigma,p.dsigmadlogs)
        else:
            isow=iso.getisosweights(w,10.**t,metallicity(t,p),isos)

        m=iso.computeCMD(isow,isos)
        m=utils.normalize(m,sum(data.flat))
        return utils.loglikelihood(m,data)

    d = numarray.maximum(data,1e-20)
    llhC=sum( (d*numarray.log(d)).flat )
    def b(par,value,iter):
        params.setvalues(par)
        params.save()
        print "henry:",value,"tom:",2.0*(value+llhC),"iter:",iter,time.ctime()
        sys.stdout.flush()

    optimization.minmax(optimization.fmin_simplex,f,
            params.getvalues(),params.min(),params.max(),b)
예제 #57
0
파일: metools.py 프로젝트: dtmori/HWW
def buildMappedMultidimEPD( samples, sig_pvals, bkg_pvals, nbins = 30, nbins1D = 40, cuts = None, name='NDimEPD' ):
    from ROOT import TObjArray
    from ROOT import Array2D
    from ROOT import Array1D

    treeList = TObjArray( len( samples ) )
    infoList = TObjArray( len( samples ) )

    binning = Array2D( len(bkg_pvals), Array1D(nbins,0) )

    varListString = ''
    
    sigme = '+'.join( ['%s'%(me) for me in sig_pvals] )
    alpha = { }
    for ipval, pval in enumerate( bkg_pvals ):
        nonill = '(' + '&&'.join( ['(%s>0)'%(me) for me in sig_pvals ] ) + '&& (%s>0)'%(pval) + ')'
        samples.draw( 'alpha:'+pval, '', 'log((%s)/(%s))/log(10)'%(sigme,pval), 1000, utils.frange(-100,100,ndiv=1000), cuts = nonill )
        hSumBkg = None
        for ismpl, smpl in enumerate( samples ):
            if smpl.get_stype() != 'bkg':
                continue
            if hSumBkg==None: hSumBkg  = smpl['alpha:'+pval]( 'SumBkgAlpha' )
            else:             hSumBkg += smpl['alpha:'+pval]
        il, ir = -1, -1        
        for ib in xrange( 1, hSumBkg.GetNbinsX() + 2 ):
            if il < 0 and hSumBkg.GetBinContent(ib) > 0:
                il = ib
            if il > 0 and hSumBkg.GetBinContent(ib) > 0:
                ir = ib

        xlow, xhigh = hSumBkg.GetBinLowEdge(il-1), hSumBkg.GetBinLowEdge(ir+1)

        print xlow, xhigh

        formString = 'log( (%s) / (%s) )/log(10)'%( sigme, pval ) ## @FIXME what about nil p-values ?? 
        for ibin in xrange( nbins + 1 ):
            binning[ipval][ibin] = ( (xhigh-xlow) / nbins * ibin + xlow )
        hSumBkg.Delete()

        if len( varListString ) == '': varListString = formString
        else:                          varListString = ':'.join( (varListString, formString) )
    
    if cuts == None or len(cuts) == 0:
        cuts = '0<1'
    
    for ismpl, smpl in enumerate( samples ):
        treeList.AddLast( smpl.get_tree() )
        struct = ROOT.TSampleStruct( )
        struct.Variable = varListString
        struct.Name = smpl.get_name()
        struct.Weight = '(%s * %0.5g * %0.5g)'%( smpl.get_weights(),
                                                 smpl.get_scale(),
                                                 abs(smpl.get_lumi()) )
        struct.Selection = '( %s ) && ( %s )'%( cuts, smpl.get_cuts() )
        struct.Type = smpl.get_stype()
        infoList.AddLast( struct )

    mappedNDList = ROOT.getMappedNDim( treeList, infoList, binning, "ND" )

    hists1D = []
    for ismpl, smpl in enumerate( samples ):
        hists1D += [ ROOT.get1DMapped( mappedNDList[ismpl], len(varListString.split(':')), nbins, nbins1D ) ]
        smpl[name+'Mapped'] = histogram.pyhist1F( hists1D[-1] )
        smpl.set_style()        
                                            
    return mappedNDList
예제 #58
0
def test1():
    for f in utils.frange(1,2,0.16):
        print f
    for f in utils.frange(3,2,-0.16):
        print f