airoptserver/modelsrc/com/miniframe/model/mdo/MdoProGrad.java

package com.miniframe.model.mdo;

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

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

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

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

    /**
     * 最大外迭代步数
     */
    @Column(name = "major_iterations_limit")
    private String majorIterationsLimit;

    /**
     * 输出精度等级
     */
    @Column(name = "major_print_level")
    private String majorPrintLevel;

    /**
     * 线性约束容差
     */
    @Column(name = "linear_feasibility_tolerance")
    private String linearFeasibilityTolerance;

    /**
     * 非线性约束容差
     */
    @Column(name = "nonlinear_feasibility_tolerance")
    private String nonlinearFeasibilityTolerance;

    /**
     * 最优性度量（KKT 条件）容差
     */
    @Column(name = "optimality_tolerance")
    private String optimalityTolerance;

    /**
     * 梯度验证级别 -1：不验证 0：简单验证 1-3：详细验证（1目标-2约束-3目标+约束）
     */
    @Column(name = "verify_level")
    private String verifyLevel;

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

    /**
     * 流程id
     */
    private String wid;

    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 major_iterations_limit - 最大外迭代步数
     */
    public String getMajorIterationsLimit() {
        return majorIterationsLimit;
    }

    /**
     * 设置最大外迭代步数
     *
     * @param majorIterationsLimit 最大外迭代步数
     */
    public void setMajorIterationsLimit(String majorIterationsLimit) {
        this.majorIterationsLimit = majorIterationsLimit == null ? null : majorIterationsLimit.trim();
    }

    /**
     * 获取输出精度等级
     *
     * @return major_print_level - 输出精度等级
     */
    public String getMajorPrintLevel() {
        return majorPrintLevel;
    }

    /**
     * 设置输出精度等级
     *
     * @param majorPrintLevel 输出精度等级
     */
    public void setMajorPrintLevel(String majorPrintLevel) {
        this.majorPrintLevel = majorPrintLevel == null ? null : majorPrintLevel.trim();
    }

    /**
     * 获取线性约束容差
     *
     * @return linear_feasibility_tolerance - 线性约束容差
     */
    public String getLinearFeasibilityTolerance() {
        return linearFeasibilityTolerance;
    }

    /**
     * 设置线性约束容差
     *
     * @param linearFeasibilityTolerance 线性约束容差
     */
    public void setLinearFeasibilityTolerance(String linearFeasibilityTolerance) {
        this.linearFeasibilityTolerance = linearFeasibilityTolerance == null ? null : linearFeasibilityTolerance.trim();
    }

    /**
     * 获取非线性约束容差
     *
     * @return nonlinear_feasibility_tolerance - 非线性约束容差
     */
    public String getNonlinearFeasibilityTolerance() {
        return nonlinearFeasibilityTolerance;
    }

    /**
     * 设置非线性约束容差
     *
     * @param nonlinearFeasibilityTolerance 非线性约束容差
     */
    public void setNonlinearFeasibilityTolerance(String nonlinearFeasibilityTolerance) {
        this.nonlinearFeasibilityTolerance = nonlinearFeasibilityTolerance == null ? null : nonlinearFeasibilityTolerance.trim();
    }

    /**
     * 获取最优性度量（KKT 条件）容差
     *
     * @return optimality_tolerance - 最优性度量（KKT 条件）容差
     */
    public String getOptimalityTolerance() {
        return optimalityTolerance;
    }

    /**
     * 设置最优性度量（KKT 条件）容差
     *
     * @param optimalityTolerance 最优性度量（KKT 条件）容差
     */
    public void setOptimalityTolerance(String optimalityTolerance) {
        this.optimalityTolerance = optimalityTolerance == null ? null : optimalityTolerance.trim();
    }

    /**
     * 获取梯度验证级别 -1：不验证 0：简单验证 1-3：详细验证（1目标-2约束-3目标+约束）
     *
     * @return verify_level - 梯度验证级别 -1：不验证 0：简单验证 1-3：详细验证（1目标-2约束-3目标+约束）
     */
    public String getVerifyLevel() {
        return verifyLevel;
    }

    /**
     * 设置梯度验证级别 -1：不验证 0：简单验证 1-3：详细验证（1目标-2约束-3目标+约束）
     *
     * @param verifyLevel 梯度验证级别 -1：不验证 0：简单验证 1-3：详细验证（1目标-2约束-3目标+约束）
     */
    public void setVerifyLevel(String verifyLevel) {
        this.verifyLevel = verifyLevel == null ? null : verifyLevel.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;
    }

    /**
     * 获取流程id
     *
     * @return wid - 流程id
     */
    public String getWid() {
        return wid;
    }

    /**
     * 设置流程id
     *
     * @param wid 流程id
     */
    public void setWid(String wid) {
        this.wid = wid == null ? null : wid.trim();
    }
}