Пример #1
0
    # optimizer
    verbose = True
    fesolver = CooFESolver(verbose=verbose)

    optimizer = None
    density_constraint = None

    if args.optimizer:
        if str(args.optimizer) == 'mas':
            optimizer = env.Environment(fesolver,
                                        young,
                                        poisson,
                                        verbose=verbose)
            # constraints
            density_constraint = DensityConstraint(volume_frac=1.0,
                                                   density_min=xmin,
                                                   density_max=xmax)
        if str(args.optimizer) == 'mas_ke':
            optimizer = env_ke.Environment(fesolver,
                                           young,
                                           poisson,
                                           verbose=verbose)
            # constraints
            density_constraint = DensityConstraint(volume_frac=1.0,
                                                   density_min=xmin,
                                                   density_max=xmax)
        if str(args.optimizer) == 'oc':
            optimizer = Oc(fesolver, young, poisson, verbose=verbose)
            # constraints
            density_constraint = DensityConstraint(volume_frac=volfrac,
                                                   density_min=xmin,
Пример #2
0
    # input parameters
    nelx = 180
    nely = 60

    penal = 3.0
    rmin = 1.1

    delta = 0.002
    loopy = math.inf

    # loading/problem
    load = HalfBeam(nelx, nely)

    # constraints
    density_constraint = DensityConstraint(volume_frac=volfrac, Emin=Emin)

    # optimizer
    verbose = True
    fesolver = CooFESolver(verbose=verbose)
    optimizer = Topopt(fesolver, young, poisson, verbose=verbose)

    # compute
    history = False
    x = optimizer.init(load, density_constraint)
    x, x_more = optimizer.layout(load, density_constraint, x, penal, rmin,
                                 delta, loopy, history)

    print('Elapsed time is: ', time.time() - t, 'seconds.')

    if history:
Пример #3
0
    # optimizer parameters
    penal = 3.0
    rmin = 3
    filt = 'sensitivity'
    loopy = 1000  # math.inf
    delta = 0.005

    # plotting and printing options
    verbose = True
    plotting = True
    save_plot = False
    history = False

    # constraints object created
    den_con = DensityConstraint(nelx, nely, move, volume_frac=volfrac)

    # loading case object, other classes can be selected and created
    load = Canti(nelx, nely, young, Emin, poisson)

    # FEA object is generated, other solvers can be selected and created
    fesolver = CvxFEA(verbose=verbose)

    # create optimizer object and initialise the problem
    optimizer = Topopt(den_con, load, fesolver, verbose=verbose)

    # execute the optimization
    t = time.time()
    x, x_history = optimizer.layout(penal, rmin, delta, loopy, filt, history)
    print('Elapsed time is: ', time.time() - t, 'seconds.')
Пример #4
0
    # plotting and printing options
    directory = 'CT0053/'
    verbose = True
    plotting = True
    save_plot = True
    history = True
    save_pointcloud = False
    save_array = True

    # loading case object, other classes can be selected and created
    load = CompactTension(nelx, crack_length, young, Emin, poisson, ext_stiff)

    # constraints object created
    den_con = DensityConstraint(load,
                                move,
                                volume_frac=volfrac,
                                density_min=1,
                                density_max=2)

    # FEA object is generated, other solvers can be selected and created
    fesolver = CvxFEA(verbose=verbose)

    # create optimizer object and initialise the problem
    optimizer = Topopt(den_con,
                       load,
                       fesolver,
                       verbose=verbose,
                       history=history)

    # compute
    t = time.time()
Пример #5
0
    loopy = 10  #math.inf
    load = HalfBeam(nelx, nely)

    # parallel optimizer testing
    verbose = True
    fesolver = CooFESolver(verbose=verbose)

    optimizer = None
    density_constraint = None

    # material properties
    young = 1
    poisson = 0.6

    optimizer = Environment(fesolver, young, poisson, verbose=verbose)
    # constraints
    density_constraint = DensityConstraint(volume_frac=1.0,
                                           density_min=0,
                                           density_max=1)

    # statistic time
    start_time = time.perf_counter()
    # compute
    history = True
    x = optimizer.init(load, density_constraint)
    x, x_more = optimizer.run(load, density_constraint, x, penal, rmin, delta,
                              loopy, history)
    end_time = time.perf_counter()
    print('Processed {} elements in {} seconds'.format(nelx * nely,
                                                       end_time - start_time))