package com.miniframe.model.mdo;

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

@Table(name = "mdo_pro_surro")
public class MdoProSurro extends MiniserviceBaseModel implements Serializable {
    /**
     * 代理优化器ID
     */
    @Id
    private String id;

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

    private String nsurro;

    @Column(name = "n_kriging")
    private String nKriging;

    /**
     * 屏幕输出等级
     */
    private String iout;

    /**
     * 续算开关 0-否，1-是
     */
    private String irestart;

    /**
     * 试验设计方法
     */
    private String ndoe;

    /**
     * 初始样本点数
     */
    private String ns;

    /**
     * 最大样本点数
     */
    private String nsmax;

    /**
     * 低可信度初始样本点数（nsurro=4 and n_kriging=12时）
     */
    @Column(name = "ns_lf")
    private String nsLf;

    /**
     * 低可信度最大样本点数（nsurro=4 and n_kriging=12时
     */
    @Column(name = "nsmax_lf")
    private String nsmaxLf;

    /**
     * 各可信度初始样本点数（nsurro=4 and n_kriging>12时）
     */
    @Column(name = "ns_mk")
    private String nsMk;

    /**
     * 各可信度最大样本点数（nsurro=4 and n_kriging>12
     */
    @Column(name = "nsmax_mk")
    private String nsmaxMk;

    /**
     * 最优解收敛性容差
     */
    @Column(name = "x_tol")
    private String xTol;

    /**
     * 真实函数的约束容差
     */
    @Column(name = "feasibility_tol_real")
    private String feasibilityTolReal;

    /**
     * 代理模型的约束容差
     */
    @Column(name = "feasibility_tol_surro")
    private String feasibilityTolSurro;

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

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

    /**
     * 代理模型
     */
    @Column(name = "surro_mod")
    private String surroMod;

    /**
     * 相关函数 0-各向异性高斯指数函数 1-各向同性高斯指数函数 2-三次样条函数
     */
    private String corr;

    /**
     * 是否优化超参数 1-不优化超参数 0-使用随机初值优化超参数 -1-上一轮建模数据作为初值优化超参数
     */
    @Column(name = "const_theta")
    private String constTheta;

    /**
     * Kriging模型的阶数 0-普通Kriging 1-泛Kriging 
     */
    private String porder;

    /**
     * 相关矩阵分解方法 0-LU分解 2-Cholesky分解 3-采用第三方库进行并行分解
     */
    private String dcmp;

    /**
     * 超参数优化方法 1-HookeJeeves 2-BFGS 3-单纯形搜索方法
     */
    private String paraopt;

    /**
     * 正则化方法 0-不进行正则化 1-常数正则化 2-优化正则化
     */
    private String regular;

    /**
     * 加点准则
     */
    private String infill;

    /**
     * KB加点数量
     */
    private String nparallel;

    /**
     * 子优化方法
     */
    private String iopt;

    /**
     * 约束处理方法
     */
    private String icstr;

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

    /**
     * 最大进化代数
     */
    private String maxgen;

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

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

    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 nsurro
     */
    public String getNsurro() {
        return nsurro;
    }

    /**
     * @param nsurro
     */
    public void setNsurro(String nsurro) {
        this.nsurro = nsurro == null ? null : nsurro.trim();
    }

    /**
     * @return n_kriging
     */
    public String getnKriging() {
        return nKriging;
    }

    /**
     * @param nKriging
     */
    public void setnKriging(String nKriging) {
        this.nKriging = nKriging == null ? null : nKriging.trim();
    }

    /**
     * 获取屏幕输出等级
     *
     * @return iout - 屏幕输出等级
     */
    public String getIout() {
        return iout;
    }

    /**
     * 设置屏幕输出等级
     *
     * @param iout 屏幕输出等级
     */
    public void setIout(String iout) {
        this.iout = iout == null ? null : iout.trim();
    }

    /**
     * 获取续算开关 0-否，1-是
     *
     * @return irestart - 续算开关 0-否，1-是
     */
    public String getIrestart() {
        return irestart;
    }

    /**
     * 设置续算开关 0-否，1-是
     *
     * @param irestart 续算开关 0-否，1-是
     */
    public void setIrestart(String irestart) {
        this.irestart = irestart == null ? null : irestart.trim();
    }

    /**
     * 获取试验设计方法
     *
     * @return ndoe - 试验设计方法
     */
    public String getNdoe() {
        return ndoe;
    }

    /**
     * 设置试验设计方法
     *
     * @param ndoe 试验设计方法
     */
    public void setNdoe(String ndoe) {
        this.ndoe = ndoe == null ? null : ndoe.trim();
    }

    /**
     * 获取初始样本点数
     *
     * @return ns - 初始样本点数
     */
    public String getNs() {
        return ns;
    }

    /**
     * 设置初始样本点数
     *
     * @param ns 初始样本点数
     */
    public void setNs(String ns) {
        this.ns = ns == null ? null : ns.trim();
    }

    /**
     * 获取最大样本点数
     *
     * @return nsmax - 最大样本点数
     */
    public String getNsmax() {
        return nsmax;
    }

    /**
     * 设置最大样本点数
     *
     * @param nsmax 最大样本点数
     */
    public void setNsmax(String nsmax) {
        this.nsmax = nsmax == null ? null : nsmax.trim();
    }

    /**
     * 获取低可信度初始样本点数（nsurro=4 and n_kriging=12时）
     *
     * @return ns_lf - 低可信度初始样本点数（nsurro=4 and n_kriging=12时）
     */
    public String getNsLf() {
        return nsLf;
    }

    /**
     * 设置低可信度初始样本点数（nsurro=4 and n_kriging=12时）
     *
     * @param nsLf 低可信度初始样本点数（nsurro=4 and n_kriging=12时）
     */
    public void setNsLf(String nsLf) {
        this.nsLf = nsLf == null ? null : nsLf.trim();
    }

    /**
     * 获取低可信度最大样本点数（nsurro=4 and n_kriging=12时
     *
     * @return nsmax_lf - 低可信度最大样本点数（nsurro=4 and n_kriging=12时
     */
    public String getNsmaxLf() {
        return nsmaxLf;
    }

    /**
     * 设置低可信度最大样本点数（nsurro=4 and n_kriging=12时
     *
     * @param nsmaxLf 低可信度最大样本点数（nsurro=4 and n_kriging=12时
     */
    public void setNsmaxLf(String nsmaxLf) {
        this.nsmaxLf = nsmaxLf == null ? null : nsmaxLf.trim();
    }

    /**
     * 获取各可信度初始样本点数（nsurro=4 and n_kriging>12时）
     *
     * @return ns_mk - 各可信度初始样本点数（nsurro=4 and n_kriging>12时）
     */
    public String getNsMk() {
        return nsMk;
    }

    /**
     * 设置各可信度初始样本点数（nsurro=4 and n_kriging>12时）
     *
     * @param nsMk 各可信度初始样本点数（nsurro=4 and n_kriging>12时）
     */
    public void setNsMk(String nsMk) {
        this.nsMk = nsMk == null ? null : nsMk.trim();
    }

    /**
     * 获取各可信度最大样本点数（nsurro=4 and n_kriging>12
     *
     * @return nsmax_mk - 各可信度最大样本点数（nsurro=4 and n_kriging>12
     */
    public String getNsmaxMk() {
        return nsmaxMk;
    }

    /**
     * 设置各可信度最大样本点数（nsurro=4 and n_kriging>12
     *
     * @param nsmaxMk 各可信度最大样本点数（nsurro=4 and n_kriging>12
     */
    public void setNsmaxMk(String nsmaxMk) {
        this.nsmaxMk = nsmaxMk == null ? null : nsmaxMk.trim();
    }

    /**
     * 获取最优解收敛性容差
     *
     * @return x_tol - 最优解收敛性容差
     */
    public String getxTol() {
        return xTol;
    }

    /**
     * 设置最优解收敛性容差
     *
     * @param xTol 最优解收敛性容差
     */
    public void setxTol(String xTol) {
        this.xTol = xTol == null ? null : xTol.trim();
    }

    /**
     * 获取真实函数的约束容差
     *
     * @return feasibility_tol_real - 真实函数的约束容差
     */
    public String getFeasibilityTolReal() {
        return feasibilityTolReal;
    }

    /**
     * 设置真实函数的约束容差
     *
     * @param feasibilityTolReal 真实函数的约束容差
     */
    public void setFeasibilityTolReal(String feasibilityTolReal) {
        this.feasibilityTolReal = feasibilityTolReal == null ? null : feasibilityTolReal.trim();
    }

    /**
     * 获取代理模型的约束容差
     *
     * @return feasibility_tol_surro - 代理模型的约束容差
     */
    public String getFeasibilityTolSurro() {
        return feasibilityTolSurro;
    }

    /**
     * 设置代理模型的约束容差
     *
     * @param feasibilityTolSurro 代理模型的约束容差
     */
    public void setFeasibilityTolSurro(String feasibilityTolSurro) {
        this.feasibilityTolSurro = feasibilityTolSurro == null ? null : feasibilityTolSurro.trim();
    }

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

    /**
     * 设置优化算法
     *
     * @param algorithm 优化算法
     */
    public void setAlgorithm(String algorithm) {
        this.algorithm = algorithm == null ? null : algorithm.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;
    }

    /**
     * 获取代理模型
     *
     * @return surro_mod - 代理模型
     */
    public String getSurroMod() {
        return surroMod;
    }

    /**
     * 设置代理模型
     *
     * @param surroMod 代理模型
     */
    public void setSurroMod(String surroMod) {
        this.surroMod = surroMod == null ? null : surroMod.trim();
    }

    /**
     * 获取相关函数 0-各向异性高斯指数函数 1-各向同性高斯指数函数 2-三次样条函数
     *
     * @return corr - 相关函数 0-各向异性高斯指数函数 1-各向同性高斯指数函数 2-三次样条函数
     */
    public String getCorr() {
        return corr;
    }

    /**
     * 设置相关函数 0-各向异性高斯指数函数 1-各向同性高斯指数函数 2-三次样条函数
     *
     * @param corr 相关函数 0-各向异性高斯指数函数 1-各向同性高斯指数函数 2-三次样条函数
     */
    public void setCorr(String corr) {
        this.corr = corr == null ? null : corr.trim();
    }

    /**
     * 获取是否优化超参数 1-不优化超参数 0-使用随机初值优化超参数 -1-上一轮建模数据作为初值优化超参数
     *
     * @return const_theta - 是否优化超参数 1-不优化超参数 0-使用随机初值优化超参数 -1-上一轮建模数据作为初值优化超参数
     */
    public String getConstTheta() {
        return constTheta;
    }

    /**
     * 设置是否优化超参数 1-不优化超参数 0-使用随机初值优化超参数 -1-上一轮建模数据作为初值优化超参数
     *
     * @param constTheta 是否优化超参数 1-不优化超参数 0-使用随机初值优化超参数 -1-上一轮建模数据作为初值优化超参数
     */
    public void setConstTheta(String constTheta) {
        this.constTheta = constTheta == null ? null : constTheta.trim();
    }

    /**
     * 获取Kriging模型的阶数 0-普通Kriging 1-泛Kriging 
     *
     * @return porder - Kriging模型的阶数 0-普通Kriging 1-泛Kriging 
     */
    public String getPorder() {
        return porder;
    }

    /**
     * 设置Kriging模型的阶数 0-普通Kriging 1-泛Kriging 
     *
     * @param porder Kriging模型的阶数 0-普通Kriging 1-泛Kriging 
     */
    public void setPorder(String porder) {
        this.porder = porder == null ? null : porder.trim();
    }

    /**
     * 获取相关矩阵分解方法 0-LU分解 2-Cholesky分解 3-采用第三方库进行并行分解
     *
     * @return dcmp - 相关矩阵分解方法 0-LU分解 2-Cholesky分解 3-采用第三方库进行并行分解
     */
    public String getDcmp() {
        return dcmp;
    }

    /**
     * 设置相关矩阵分解方法 0-LU分解 2-Cholesky分解 3-采用第三方库进行并行分解
     *
     * @param dcmp 相关矩阵分解方法 0-LU分解 2-Cholesky分解 3-采用第三方库进行并行分解
     */
    public void setDcmp(String dcmp) {
        this.dcmp = dcmp == null ? null : dcmp.trim();
    }

    /**
     * 获取超参数优化方法 1-HookeJeeves 2-BFGS 3-单纯形搜索方法
     *
     * @return paraopt - 超参数优化方法 1-HookeJeeves 2-BFGS 3-单纯形搜索方法
     */
    public String getParaopt() {
        return paraopt;
    }

    /**
     * 设置超参数优化方法 1-HookeJeeves 2-BFGS 3-单纯形搜索方法
     *
     * @param paraopt 超参数优化方法 1-HookeJeeves 2-BFGS 3-单纯形搜索方法
     */
    public void setParaopt(String paraopt) {
        this.paraopt = paraopt == null ? null : paraopt.trim();
    }

    /**
     * 获取正则化方法 0-不进行正则化 1-常数正则化 2-优化正则化
     *
     * @return regular - 正则化方法 0-不进行正则化 1-常数正则化 2-优化正则化
     */
    public String getRegular() {
        return regular;
    }

    /**
     * 设置正则化方法 0-不进行正则化 1-常数正则化 2-优化正则化
     *
     * @param regular 正则化方法 0-不进行正则化 1-常数正则化 2-优化正则化
     */
    public void setRegular(String regular) {
        this.regular = regular == null ? null : regular.trim();
    }

    /**
     * 获取加点准则
     *
     * @return infill - 加点准则
     */
    public String getInfill() {
        return infill;
    }

    /**
     * 设置加点准则
     *
     * @param infill 加点准则
     */
    public void setInfill(String infill) {
        this.infill = infill == null ? null : infill.trim();
    }

    /**
     * 获取KB加点数量
     *
     * @return nparallel - KB加点数量
     */
    public String getNparallel() {
        return nparallel;
    }

    /**
     * 设置KB加点数量
     *
     * @param nparallel KB加点数量
     */
    public void setNparallel(String nparallel) {
        this.nparallel = nparallel == null ? null : nparallel.trim();
    }

    /**
     * 获取子优化方法
     *
     * @return iopt - 子优化方法
     */
    public String getIopt() {
        return iopt;
    }

    /**
     * 设置子优化方法
     *
     * @param iopt 子优化方法
     */
    public void setIopt(String iopt) {
        this.iopt = iopt == null ? null : iopt.trim();
    }

    /**
     * 获取约束处理方法
     *
     * @return icstr - 约束处理方法
     */
    public String getIcstr() {
        return icstr;
    }

    /**
     * 设置约束处理方法
     *
     * @param icstr 约束处理方法
     */
    public void setIcstr(String icstr) {
        this.icstr = icstr == null ? null : icstr.trim();
    }

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

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

    /**
     * 获取最大进化代数
     *
     * @return maxgen - 最大进化代数
     */
    public String getMaxgen() {
        return maxgen;
    }

    /**
     * 设置最大进化代数
     *
     * @param maxgen 最大进化代数
     */
    public void setMaxgen(String maxgen) {
        this.maxgen = maxgen == null ? null : maxgen.trim();
    }

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

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

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

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