package com.miniframe.model.mdo;

import com.miniframe.system.MiniserviceBaseModel;
import java.io.Serializable;
import javax.persistence.*;

@Table(name = "mdo_pro_evolution")
public class MdoProEvolution extends MiniserviceBaseModel implements Serializable {
    /**
     * 进化器参数ID
     */
    @Id
    private String id;

    /**
     * 项目ID
     */
    private String pid;

    /**
     * 优化算法
     */
    private String algorithm;

    /**
     * 种群规模
     */
    private String popsize;

    /**
     * 迭代次数
     */
    private String epoch;

    /**
     * 交叉概率
     */
    private String probcrossover;

    /**
     * 变异概率
     */
    private String probmut;

    /**
     * 交叉算子
     */
    private String proboperator;

    /**
     * 竞赛规模
     */
    private String probscale;

    /**
     * 保留优选策略
     */
    private String strategy;

    /**
     * 变异算子选择
     */
    private String operator;

    /**
     * GPU加速
     */
    private String gpu;

    /**
     * 是否选中 1 -选中 0-未选中 
     */
    private Short checked;

    private static final long serialVersionUID = 1L;

    /**
     * 获取进化器参数ID
     *
     * @return id - 进化器参数ID
     */
    public String getId() {
        return id;
    }

    /**
     * 设置进化器参数ID
     *
     * @param id 进化器参数ID
     */
    public void setId(String id) {
        this.id = id == null ? null : id.trim();
    }

    /**
     * 获取项目ID
     *
     * @return pid - 项目ID
     */
    public String getPid() {
        return pid;
    }

    /**
     * 设置项目ID
     *
     * @param pid 项目ID
     */
    public void setPid(String pid) {
        this.pid = pid == null ? null : pid.trim();
    }

    /**
     * 获取优化算法
     *
     * @return algorithm - 优化算法
     */
    public String getAlgorithm() {
        return algorithm;
    }

    /**
     * 设置优化算法
     *
     * @param algorithm 优化算法
     */
    public void setAlgorithm(String algorithm) {
        this.algorithm = algorithm == null ? null : algorithm.trim();
    }

    /**
     * 获取种群规模
     *
     * @return popsize - 种群规模
     */
    public String getPopsize() {
        return popsize;
    }

    /**
     * 设置种群规模
     *
     * @param popsize 种群规模
     */
    public void setPopsize(String popsize) {
        this.popsize = popsize == null ? null : popsize.trim();
    }

    /**
     * 获取迭代次数
     *
     * @return epoch - 迭代次数
     */
    public String getEpoch() {
        return epoch;
    }

    /**
     * 设置迭代次数
     *
     * @param epoch 迭代次数
     */
    public void setEpoch(String epoch) {
        this.epoch = epoch == null ? null : epoch.trim();
    }

    /**
     * 获取交叉概率
     *
     * @return probcrossover - 交叉概率
     */
    public String getProbcrossover() {
        return probcrossover;
    }

    /**
     * 设置交叉概率
     *
     * @param probcrossover 交叉概率
     */
    public void setProbcrossover(String probcrossover) {
        this.probcrossover = probcrossover == null ? null : probcrossover.trim();
    }

    /**
     * 获取变异概率
     *
     * @return probmut - 变异概率
     */
    public String getProbmut() {
        return probmut;
    }

    /**
     * 设置变异概率
     *
     * @param probmut 变异概率
     */
    public void setProbmut(String probmut) {
        this.probmut = probmut == null ? null : probmut.trim();
    }

    /**
     * 获取交叉算子
     *
     * @return proboperator - 交叉算子
     */
    public String getProboperator() {
        return proboperator;
    }

    /**
     * 设置交叉算子
     *
     * @param proboperator 交叉算子
     */
    public void setProboperator(String proboperator) {
        this.proboperator = proboperator == null ? null : proboperator.trim();
    }

    /**
     * 获取竞赛规模
     *
     * @return probscale - 竞赛规模
     */
    public String getProbscale() {
        return probscale;
    }

    /**
     * 设置竞赛规模
     *
     * @param probscale 竞赛规模
     */
    public void setProbscale(String probscale) {
        this.probscale = probscale == null ? null : probscale.trim();
    }

    /**
     * 获取保留优选策略
     *
     * @return strategy - 保留优选策略
     */
    public String getStrategy() {
        return strategy;
    }

    /**
     * 设置保留优选策略
     *
     * @param strategy 保留优选策略
     */
    public void setStrategy(String strategy) {
        this.strategy = strategy == null ? null : strategy.trim();
    }

    /**
     * 获取变异算子选择
     *
     * @return operator - 变异算子选择
     */
    public String getOperator() {
        return operator;
    }

    /**
     * 设置变异算子选择
     *
     * @param operator 变异算子选择
     */
    public void setOperator(String operator) {
        this.operator = operator == null ? null : operator.trim();
    }

    /**
     * 获取GPU加速
     *
     * @return gpu - GPU加速
     */
    public String getGpu() {
        return gpu;
    }

    /**
     * 设置GPU加速
     *
     * @param gpu GPU加速
     */
    public void setGpu(String gpu) {
        this.gpu = gpu == null ? null : gpu.trim();
    }

    /**
     * 获取是否选中 1 -选中 0-未选中 
     *
     * @return checked - 是否选中 1 -选中 0-未选中 
     */
    public Short getChecked() {
        return checked;
    }

    /**
     * 设置是否选中 1 -选中 0-未选中 
     *
     * @param checked 是否选中 1 -选中 0-未选中 
     */
    public void setChecked(Short checked) {
        this.checked = checked;
    }
}