优化器参数

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

@@ -0,0 +1,247 @@
+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;
+
+    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;
+    }
+}

modelsrc/com/miniframe/model/mdo/MdoProGradSQLBuilder.java

@@ -0,0 +1,890 @@
+package com.miniframe.model.mdo;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MdoProGradSQLBuilder {
+    protected String orderByClause;
+
+    protected boolean distinct;
+
+    protected List<Criteria> oredCriteria;
+
+    public MdoProGradSQLBuilder() {
+        oredCriteria = new ArrayList<Criteria>();
+    }
+
+    public void setOrderByClause(String orderByClause) {
+        this.orderByClause = orderByClause;
+    }
+
+    public String getOrderByClause() {
+        return orderByClause;
+    }
+
+    public void setDistinct(boolean distinct) {
+        this.distinct = distinct;
+    }
+
+    public boolean isDistinct() {
+        return distinct;
+    }
+
+    public List<Criteria> getOredCriteria() {
+        return oredCriteria;
+    }
+
+    public void or(Criteria criteria) {
+        oredCriteria.add(criteria);
+    }
+
+    public Criteria or() {
+        Criteria criteria = createCriteriaInternal();
+        oredCriteria.add(criteria);
+        return criteria;
+    }
+
+    public Criteria createCriteria() {
+        Criteria criteria = createCriteriaInternal();
+        if (oredCriteria.size() == 0) {
+            oredCriteria.add(criteria);
+        }
+        return criteria;
+    }
+
+    protected Criteria createCriteriaInternal() {
+        Criteria criteria = new Criteria();
+        return criteria;
+    }
+
+    public void clear() {
+        oredCriteria.clear();
+        orderByClause = null;
+        distinct = false;
+    }
+
+    protected abstract static class GeneratedCriteria {
+        protected List<Criterion> criteria;
+
+        protected GeneratedCriteria() {
+            super();
+            criteria = new ArrayList<Criterion>();
+        }
+
+        public boolean isValid() {
+            return criteria.size() > 0;
+        }
+
+        public List<Criterion> getAllCriteria() {
+            return criteria;
+        }
+
+        public List<Criterion> getCriteria() {
+            return criteria;
+        }
+
+        protected void addCriterion(String condition) {
+            if (condition == null) {
+                throw new RuntimeException("Value for condition cannot be null");
+            }
+            criteria.add(new Criterion(condition));
+        }
+
+        protected void addCriterion(String condition, Object value, String property) {
+            if (value == null) {
+                throw new RuntimeException("Value for " + property + " cannot be null");
+            }
+            criteria.add(new Criterion(condition, value));
+        }
+
+        protected void addCriterion(String condition, Object value1, Object value2, String property) {
+            if (value1 == null || value2 == null) {
+                throw new RuntimeException("Between values for " + property + " cannot be null");
+            }
+            criteria.add(new Criterion(condition, value1, value2));
+        }
+
+        public Criteria andIdIsNull() {
+            addCriterion("id is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdIsNotNull() {
+            addCriterion("id is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdEqualTo(String value) {
+            addCriterion("id =", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdNotEqualTo(String value) {
+            addCriterion("id <>", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdGreaterThan(String value) {
+            addCriterion("id >", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdGreaterThanOrEqualTo(String value) {
+            addCriterion("id >=", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdLessThan(String value) {
+            addCriterion("id <", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdLessThanOrEqualTo(String value) {
+            addCriterion("id <=", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdLike(String value) {
+            addCriterion("id like", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdNotLike(String value) {
+            addCriterion("id not like", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdIn(List<String> values) {
+            addCriterion("id in", values, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdNotIn(List<String> values) {
+            addCriterion("id not in", values, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdBetween(String value1, String value2) {
+            addCriterion("id between", value1, value2, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdNotBetween(String value1, String value2) {
+            addCriterion("id not between", value1, value2, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidIsNull() {
+            addCriterion("pid is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidIsNotNull() {
+            addCriterion("pid is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidEqualTo(String value) {
+            addCriterion("pid =", value, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidNotEqualTo(String value) {
+            addCriterion("pid <>", value, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidGreaterThan(String value) {
+            addCriterion("pid >", value, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidGreaterThanOrEqualTo(String value) {
+            addCriterion("pid >=", value, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidLessThan(String value) {
+            addCriterion("pid <", value, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidLessThanOrEqualTo(String value) {
+            addCriterion("pid <=", value, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidLike(String value) {
+            addCriterion("pid like", value, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidNotLike(String value) {
+            addCriterion("pid not like", value, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidIn(List<String> values) {
+            addCriterion("pid in", values, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidNotIn(List<String> values) {
+            addCriterion("pid not in", values, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidBetween(String value1, String value2) {
+            addCriterion("pid between", value1, value2, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidNotBetween(String value1, String value2) {
+            addCriterion("pid not between", value1, value2, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmIsNull() {
+            addCriterion("algorithm is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmIsNotNull() {
+            addCriterion("algorithm is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmEqualTo(String value) {
+            addCriterion("algorithm =", value, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmNotEqualTo(String value) {
+            addCriterion("algorithm <>", value, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmGreaterThan(String value) {
+            addCriterion("algorithm >", value, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmGreaterThanOrEqualTo(String value) {
+            addCriterion("algorithm >=", value, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmLessThan(String value) {
+            addCriterion("algorithm <", value, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmLessThanOrEqualTo(String value) {
+            addCriterion("algorithm <=", value, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmLike(String value) {
+            addCriterion("algorithm like", value, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmNotLike(String value) {
+            addCriterion("algorithm not like", value, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmIn(List<String> values) {
+            addCriterion("algorithm in", values, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmNotIn(List<String> values) {
+            addCriterion("algorithm not in", values, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmBetween(String value1, String value2) {
+            addCriterion("algorithm between", value1, value2, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmNotBetween(String value1, String value2) {
+            addCriterion("algorithm not between", value1, value2, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorIterationsLimitIsNull() {
+            addCriterion("major_iterations_limit is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorIterationsLimitIsNotNull() {
+            addCriterion("major_iterations_limit is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorIterationsLimitEqualTo(String value) {
+            addCriterion("major_iterations_limit =", value, "majorIterationsLimit");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorIterationsLimitNotEqualTo(String value) {
+            addCriterion("major_iterations_limit <>", value, "majorIterationsLimit");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorIterationsLimitGreaterThan(String value) {
+            addCriterion("major_iterations_limit >", value, "majorIterationsLimit");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorIterationsLimitGreaterThanOrEqualTo(String value) {
+            addCriterion("major_iterations_limit >=", value, "majorIterationsLimit");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorIterationsLimitLessThan(String value) {
+            addCriterion("major_iterations_limit <", value, "majorIterationsLimit");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorIterationsLimitLessThanOrEqualTo(String value) {
+            addCriterion("major_iterations_limit <=", value, "majorIterationsLimit");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorIterationsLimitLike(String value) {
+            addCriterion("major_iterations_limit like", value, "majorIterationsLimit");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorIterationsLimitNotLike(String value) {
+            addCriterion("major_iterations_limit not like", value, "majorIterationsLimit");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorIterationsLimitIn(List<String> values) {
+            addCriterion("major_iterations_limit in", values, "majorIterationsLimit");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorIterationsLimitNotIn(List<String> values) {
+            addCriterion("major_iterations_limit not in", values, "majorIterationsLimit");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorIterationsLimitBetween(String value1, String value2) {
+            addCriterion("major_iterations_limit between", value1, value2, "majorIterationsLimit");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorIterationsLimitNotBetween(String value1, String value2) {
+            addCriterion("major_iterations_limit not between", value1, value2, "majorIterationsLimit");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorPrintLevelIsNull() {
+            addCriterion("major_print_level is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorPrintLevelIsNotNull() {
+            addCriterion("major_print_level is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorPrintLevelEqualTo(String value) {
+            addCriterion("major_print_level =", value, "majorPrintLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorPrintLevelNotEqualTo(String value) {
+            addCriterion("major_print_level <>", value, "majorPrintLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorPrintLevelGreaterThan(String value) {
+            addCriterion("major_print_level >", value, "majorPrintLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorPrintLevelGreaterThanOrEqualTo(String value) {
+            addCriterion("major_print_level >=", value, "majorPrintLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorPrintLevelLessThan(String value) {
+            addCriterion("major_print_level <", value, "majorPrintLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorPrintLevelLessThanOrEqualTo(String value) {
+            addCriterion("major_print_level <=", value, "majorPrintLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorPrintLevelLike(String value) {
+            addCriterion("major_print_level like", value, "majorPrintLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorPrintLevelNotLike(String value) {
+            addCriterion("major_print_level not like", value, "majorPrintLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorPrintLevelIn(List<String> values) {
+            addCriterion("major_print_level in", values, "majorPrintLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorPrintLevelNotIn(List<String> values) {
+            addCriterion("major_print_level not in", values, "majorPrintLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorPrintLevelBetween(String value1, String value2) {
+            addCriterion("major_print_level between", value1, value2, "majorPrintLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andMajorPrintLevelNotBetween(String value1, String value2) {
+            addCriterion("major_print_level not between", value1, value2, "majorPrintLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andLinearFeasibilityToleranceIsNull() {
+            addCriterion("linear_feasibility_tolerance is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andLinearFeasibilityToleranceIsNotNull() {
+            addCriterion("linear_feasibility_tolerance is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andLinearFeasibilityToleranceEqualTo(String value) {
+            addCriterion("linear_feasibility_tolerance =", value, "linearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andLinearFeasibilityToleranceNotEqualTo(String value) {
+            addCriterion("linear_feasibility_tolerance <>", value, "linearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andLinearFeasibilityToleranceGreaterThan(String value) {
+            addCriterion("linear_feasibility_tolerance >", value, "linearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andLinearFeasibilityToleranceGreaterThanOrEqualTo(String value) {
+            addCriterion("linear_feasibility_tolerance >=", value, "linearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andLinearFeasibilityToleranceLessThan(String value) {
+            addCriterion("linear_feasibility_tolerance <", value, "linearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andLinearFeasibilityToleranceLessThanOrEqualTo(String value) {
+            addCriterion("linear_feasibility_tolerance <=", value, "linearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andLinearFeasibilityToleranceLike(String value) {
+            addCriterion("linear_feasibility_tolerance like", value, "linearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andLinearFeasibilityToleranceNotLike(String value) {
+            addCriterion("linear_feasibility_tolerance not like", value, "linearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andLinearFeasibilityToleranceIn(List<String> values) {
+            addCriterion("linear_feasibility_tolerance in", values, "linearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andLinearFeasibilityToleranceNotIn(List<String> values) {
+            addCriterion("linear_feasibility_tolerance not in", values, "linearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andLinearFeasibilityToleranceBetween(String value1, String value2) {
+            addCriterion("linear_feasibility_tolerance between", value1, value2, "linearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andLinearFeasibilityToleranceNotBetween(String value1, String value2) {
+            addCriterion("linear_feasibility_tolerance not between", value1, value2, "linearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andNonlinearFeasibilityToleranceIsNull() {
+            addCriterion("nonlinear_feasibility_tolerance is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNonlinearFeasibilityToleranceIsNotNull() {
+            addCriterion("nonlinear_feasibility_tolerance is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNonlinearFeasibilityToleranceEqualTo(String value) {
+            addCriterion("nonlinear_feasibility_tolerance =", value, "nonlinearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andNonlinearFeasibilityToleranceNotEqualTo(String value) {
+            addCriterion("nonlinear_feasibility_tolerance <>", value, "nonlinearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andNonlinearFeasibilityToleranceGreaterThan(String value) {
+            addCriterion("nonlinear_feasibility_tolerance >", value, "nonlinearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andNonlinearFeasibilityToleranceGreaterThanOrEqualTo(String value) {
+            addCriterion("nonlinear_feasibility_tolerance >=", value, "nonlinearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andNonlinearFeasibilityToleranceLessThan(String value) {
+            addCriterion("nonlinear_feasibility_tolerance <", value, "nonlinearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andNonlinearFeasibilityToleranceLessThanOrEqualTo(String value) {
+            addCriterion("nonlinear_feasibility_tolerance <=", value, "nonlinearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andNonlinearFeasibilityToleranceLike(String value) {
+            addCriterion("nonlinear_feasibility_tolerance like", value, "nonlinearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andNonlinearFeasibilityToleranceNotLike(String value) {
+            addCriterion("nonlinear_feasibility_tolerance not like", value, "nonlinearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andNonlinearFeasibilityToleranceIn(List<String> values) {
+            addCriterion("nonlinear_feasibility_tolerance in", values, "nonlinearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andNonlinearFeasibilityToleranceNotIn(List<String> values) {
+            addCriterion("nonlinear_feasibility_tolerance not in", values, "nonlinearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andNonlinearFeasibilityToleranceBetween(String value1, String value2) {
+            addCriterion("nonlinear_feasibility_tolerance between", value1, value2, "nonlinearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andNonlinearFeasibilityToleranceNotBetween(String value1, String value2) {
+            addCriterion("nonlinear_feasibility_tolerance not between", value1, value2, "nonlinearFeasibilityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andOptimalityToleranceIsNull() {
+            addCriterion("optimality_tolerance is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andOptimalityToleranceIsNotNull() {
+            addCriterion("optimality_tolerance is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andOptimalityToleranceEqualTo(String value) {
+            addCriterion("optimality_tolerance =", value, "optimalityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andOptimalityToleranceNotEqualTo(String value) {
+            addCriterion("optimality_tolerance <>", value, "optimalityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andOptimalityToleranceGreaterThan(String value) {
+            addCriterion("optimality_tolerance >", value, "optimalityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andOptimalityToleranceGreaterThanOrEqualTo(String value) {
+            addCriterion("optimality_tolerance >=", value, "optimalityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andOptimalityToleranceLessThan(String value) {
+            addCriterion("optimality_tolerance <", value, "optimalityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andOptimalityToleranceLessThanOrEqualTo(String value) {
+            addCriterion("optimality_tolerance <=", value, "optimalityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andOptimalityToleranceLike(String value) {
+            addCriterion("optimality_tolerance like", value, "optimalityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andOptimalityToleranceNotLike(String value) {
+            addCriterion("optimality_tolerance not like", value, "optimalityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andOptimalityToleranceIn(List<String> values) {
+            addCriterion("optimality_tolerance in", values, "optimalityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andOptimalityToleranceNotIn(List<String> values) {
+            addCriterion("optimality_tolerance not in", values, "optimalityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andOptimalityToleranceBetween(String value1, String value2) {
+            addCriterion("optimality_tolerance between", value1, value2, "optimalityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andOptimalityToleranceNotBetween(String value1, String value2) {
+            addCriterion("optimality_tolerance not between", value1, value2, "optimalityTolerance");
+            return (Criteria) this;
+        }
+
+        public Criteria andVerifyLevelIsNull() {
+            addCriterion("verify_level is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andVerifyLevelIsNotNull() {
+            addCriterion("verify_level is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andVerifyLevelEqualTo(String value) {
+            addCriterion("verify_level =", value, "verifyLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andVerifyLevelNotEqualTo(String value) {
+            addCriterion("verify_level <>", value, "verifyLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andVerifyLevelGreaterThan(String value) {
+            addCriterion("verify_level >", value, "verifyLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andVerifyLevelGreaterThanOrEqualTo(String value) {
+            addCriterion("verify_level >=", value, "verifyLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andVerifyLevelLessThan(String value) {
+            addCriterion("verify_level <", value, "verifyLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andVerifyLevelLessThanOrEqualTo(String value) {
+            addCriterion("verify_level <=", value, "verifyLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andVerifyLevelLike(String value) {
+            addCriterion("verify_level like", value, "verifyLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andVerifyLevelNotLike(String value) {
+            addCriterion("verify_level not like", value, "verifyLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andVerifyLevelIn(List<String> values) {
+            addCriterion("verify_level in", values, "verifyLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andVerifyLevelNotIn(List<String> values) {
+            addCriterion("verify_level not in", values, "verifyLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andVerifyLevelBetween(String value1, String value2) {
+            addCriterion("verify_level between", value1, value2, "verifyLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andVerifyLevelNotBetween(String value1, String value2) {
+            addCriterion("verify_level not between", value1, value2, "verifyLevel");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedIsNull() {
+            addCriterion("checked is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedIsNotNull() {
+            addCriterion("checked is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedEqualTo(Short value) {
+            addCriterion("checked =", value, "checked");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedNotEqualTo(Short value) {
+            addCriterion("checked <>", value, "checked");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedGreaterThan(Short value) {
+            addCriterion("checked >", value, "checked");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedGreaterThanOrEqualTo(Short value) {
+            addCriterion("checked >=", value, "checked");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedLessThan(Short value) {
+            addCriterion("checked <", value, "checked");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedLessThanOrEqualTo(Short value) {
+            addCriterion("checked <=", value, "checked");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedIn(List<Short> values) {
+            addCriterion("checked in", values, "checked");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedNotIn(List<Short> values) {
+            addCriterion("checked not in", values, "checked");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedBetween(Short value1, Short value2) {
+            addCriterion("checked between", value1, value2, "checked");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedNotBetween(Short value1, Short value2) {
+            addCriterion("checked not between", value1, value2, "checked");
+            return (Criteria) this;
+        }
+    }
+
+    public static class Criteria extends GeneratedCriteria {
+
+        protected Criteria() {
+            super();
+        }
+    }
+
+    public static class Criterion {
+        private String condition;
+
+        private Object value;
+
+        private Object secondValue;
+
+        private boolean noValue;
+
+        private boolean singleValue;
+
+        private boolean betweenValue;
+
+        private boolean listValue;
+
+        private String typeHandler;
+
+        public String getCondition() {
+            return condition;
+        }
+
+        public Object getValue() {
+            return value;
+        }
+
+        public Object getSecondValue() {
+            return secondValue;
+        }
+
+        public boolean isNoValue() {
+            return noValue;
+        }
+
+        public boolean isSingleValue() {
+            return singleValue;
+        }
+
+        public boolean isBetweenValue() {
+            return betweenValue;
+        }
+
+        public boolean isListValue() {
+            return listValue;
+        }
+
+        public String getTypeHandler() {
+            return typeHandler;
+        }
+
+        protected Criterion(String condition) {
+            super();
+            this.condition = condition;
+            this.typeHandler = null;
+            this.noValue = true;
+        }
+
+        protected Criterion(String condition, Object value, String typeHandler) {
+            super();
+            this.condition = condition;
+            this.value = value;
+            this.typeHandler = typeHandler;
+            if (value instanceof List<?>) {
+                this.listValue = true;
+            } else {
+                this.singleValue = true;
+            }
+        }
+
+        protected Criterion(String condition, Object value) {
+            this(condition, value, null);
+        }
+
+        protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
+            super();
+            this.condition = condition;
+            this.value = value;
+            this.secondValue = secondValue;
+            this.typeHandler = typeHandler;
+            this.betweenValue = true;
+        }
+
+        protected Criterion(String condition, Object value, Object secondValue) {
+            this(condition, value, secondValue, null);
+        }
+    }
+}

modelsrc/com/miniframe/model/mdo/MdoProSurro.java

@@ -0,0 +1,419 @@
+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;
+
+    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;
+    }
+}

modelsrc/com/miniframe/model/mdo/MdoProSurroSQLBuilder.java

@@ -0,0 +1,1450 @@
+package com.miniframe.model.mdo;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class MdoProSurroSQLBuilder {
+    protected String orderByClause;
+
+    protected boolean distinct;
+
+    protected List<Criteria> oredCriteria;
+
+    public MdoProSurroSQLBuilder() {
+        oredCriteria = new ArrayList<Criteria>();
+    }
+
+    public void setOrderByClause(String orderByClause) {
+        this.orderByClause = orderByClause;
+    }
+
+    public String getOrderByClause() {
+        return orderByClause;
+    }
+
+    public void setDistinct(boolean distinct) {
+        this.distinct = distinct;
+    }
+
+    public boolean isDistinct() {
+        return distinct;
+    }
+
+    public List<Criteria> getOredCriteria() {
+        return oredCriteria;
+    }
+
+    public void or(Criteria criteria) {
+        oredCriteria.add(criteria);
+    }
+
+    public Criteria or() {
+        Criteria criteria = createCriteriaInternal();
+        oredCriteria.add(criteria);
+        return criteria;
+    }
+
+    public Criteria createCriteria() {
+        Criteria criteria = createCriteriaInternal();
+        if (oredCriteria.size() == 0) {
+            oredCriteria.add(criteria);
+        }
+        return criteria;
+    }
+
+    protected Criteria createCriteriaInternal() {
+        Criteria criteria = new Criteria();
+        return criteria;
+    }
+
+    public void clear() {
+        oredCriteria.clear();
+        orderByClause = null;
+        distinct = false;
+    }
+
+    protected abstract static class GeneratedCriteria {
+        protected List<Criterion> criteria;
+
+        protected GeneratedCriteria() {
+            super();
+            criteria = new ArrayList<Criterion>();
+        }
+
+        public boolean isValid() {
+            return criteria.size() > 0;
+        }
+
+        public List<Criterion> getAllCriteria() {
+            return criteria;
+        }
+
+        public List<Criterion> getCriteria() {
+            return criteria;
+        }
+
+        protected void addCriterion(String condition) {
+            if (condition == null) {
+                throw new RuntimeException("Value for condition cannot be null");
+            }
+            criteria.add(new Criterion(condition));
+        }
+
+        protected void addCriterion(String condition, Object value, String property) {
+            if (value == null) {
+                throw new RuntimeException("Value for " + property + " cannot be null");
+            }
+            criteria.add(new Criterion(condition, value));
+        }
+
+        protected void addCriterion(String condition, Object value1, Object value2, String property) {
+            if (value1 == null || value2 == null) {
+                throw new RuntimeException("Between values for " + property + " cannot be null");
+            }
+            criteria.add(new Criterion(condition, value1, value2));
+        }
+
+        public Criteria andIdIsNull() {
+            addCriterion("id is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdIsNotNull() {
+            addCriterion("id is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdEqualTo(String value) {
+            addCriterion("id =", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdNotEqualTo(String value) {
+            addCriterion("id <>", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdGreaterThan(String value) {
+            addCriterion("id >", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdGreaterThanOrEqualTo(String value) {
+            addCriterion("id >=", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdLessThan(String value) {
+            addCriterion("id <", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdLessThanOrEqualTo(String value) {
+            addCriterion("id <=", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdLike(String value) {
+            addCriterion("id like", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdNotLike(String value) {
+            addCriterion("id not like", value, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdIn(List<String> values) {
+            addCriterion("id in", values, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdNotIn(List<String> values) {
+            addCriterion("id not in", values, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdBetween(String value1, String value2) {
+            addCriterion("id between", value1, value2, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andIdNotBetween(String value1, String value2) {
+            addCriterion("id not between", value1, value2, "id");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidIsNull() {
+            addCriterion("pid is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidIsNotNull() {
+            addCriterion("pid is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidEqualTo(String value) {
+            addCriterion("pid =", value, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidNotEqualTo(String value) {
+            addCriterion("pid <>", value, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidGreaterThan(String value) {
+            addCriterion("pid >", value, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidGreaterThanOrEqualTo(String value) {
+            addCriterion("pid >=", value, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidLessThan(String value) {
+            addCriterion("pid <", value, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidLessThanOrEqualTo(String value) {
+            addCriterion("pid <=", value, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidLike(String value) {
+            addCriterion("pid like", value, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidNotLike(String value) {
+            addCriterion("pid not like", value, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidIn(List<String> values) {
+            addCriterion("pid in", values, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidNotIn(List<String> values) {
+            addCriterion("pid not in", values, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidBetween(String value1, String value2) {
+            addCriterion("pid between", value1, value2, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andPidNotBetween(String value1, String value2) {
+            addCriterion("pid not between", value1, value2, "pid");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsurroIsNull() {
+            addCriterion("nsurro is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsurroIsNotNull() {
+            addCriterion("nsurro is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsurroEqualTo(String value) {
+            addCriterion("nsurro =", value, "nsurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsurroNotEqualTo(String value) {
+            addCriterion("nsurro <>", value, "nsurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsurroGreaterThan(String value) {
+            addCriterion("nsurro >", value, "nsurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsurroGreaterThanOrEqualTo(String value) {
+            addCriterion("nsurro >=", value, "nsurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsurroLessThan(String value) {
+            addCriterion("nsurro <", value, "nsurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsurroLessThanOrEqualTo(String value) {
+            addCriterion("nsurro <=", value, "nsurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsurroLike(String value) {
+            addCriterion("nsurro like", value, "nsurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsurroNotLike(String value) {
+            addCriterion("nsurro not like", value, "nsurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsurroIn(List<String> values) {
+            addCriterion("nsurro in", values, "nsurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsurroNotIn(List<String> values) {
+            addCriterion("nsurro not in", values, "nsurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsurroBetween(String value1, String value2) {
+            addCriterion("nsurro between", value1, value2, "nsurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsurroNotBetween(String value1, String value2) {
+            addCriterion("nsurro not between", value1, value2, "nsurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andNKrigingIsNull() {
+            addCriterion("n_kriging is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNKrigingIsNotNull() {
+            addCriterion("n_kriging is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNKrigingEqualTo(String value) {
+            addCriterion("n_kriging =", value, "nKriging");
+            return (Criteria) this;
+        }
+
+        public Criteria andNKrigingNotEqualTo(String value) {
+            addCriterion("n_kriging <>", value, "nKriging");
+            return (Criteria) this;
+        }
+
+        public Criteria andNKrigingGreaterThan(String value) {
+            addCriterion("n_kriging >", value, "nKriging");
+            return (Criteria) this;
+        }
+
+        public Criteria andNKrigingGreaterThanOrEqualTo(String value) {
+            addCriterion("n_kriging >=", value, "nKriging");
+            return (Criteria) this;
+        }
+
+        public Criteria andNKrigingLessThan(String value) {
+            addCriterion("n_kriging <", value, "nKriging");
+            return (Criteria) this;
+        }
+
+        public Criteria andNKrigingLessThanOrEqualTo(String value) {
+            addCriterion("n_kriging <=", value, "nKriging");
+            return (Criteria) this;
+        }
+
+        public Criteria andNKrigingLike(String value) {
+            addCriterion("n_kriging like", value, "nKriging");
+            return (Criteria) this;
+        }
+
+        public Criteria andNKrigingNotLike(String value) {
+            addCriterion("n_kriging not like", value, "nKriging");
+            return (Criteria) this;
+        }
+
+        public Criteria andNKrigingIn(List<String> values) {
+            addCriterion("n_kriging in", values, "nKriging");
+            return (Criteria) this;
+        }
+
+        public Criteria andNKrigingNotIn(List<String> values) {
+            addCriterion("n_kriging not in", values, "nKriging");
+            return (Criteria) this;
+        }
+
+        public Criteria andNKrigingBetween(String value1, String value2) {
+            addCriterion("n_kriging between", value1, value2, "nKriging");
+            return (Criteria) this;
+        }
+
+        public Criteria andNKrigingNotBetween(String value1, String value2) {
+            addCriterion("n_kriging not between", value1, value2, "nKriging");
+            return (Criteria) this;
+        }
+
+        public Criteria andIoutIsNull() {
+            addCriterion("iout is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andIoutIsNotNull() {
+            addCriterion("iout is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andIoutEqualTo(String value) {
+            addCriterion("iout =", value, "iout");
+            return (Criteria) this;
+        }
+
+        public Criteria andIoutNotEqualTo(String value) {
+            addCriterion("iout <>", value, "iout");
+            return (Criteria) this;
+        }
+
+        public Criteria andIoutGreaterThan(String value) {
+            addCriterion("iout >", value, "iout");
+            return (Criteria) this;
+        }
+
+        public Criteria andIoutGreaterThanOrEqualTo(String value) {
+            addCriterion("iout >=", value, "iout");
+            return (Criteria) this;
+        }
+
+        public Criteria andIoutLessThan(String value) {
+            addCriterion("iout <", value, "iout");
+            return (Criteria) this;
+        }
+
+        public Criteria andIoutLessThanOrEqualTo(String value) {
+            addCriterion("iout <=", value, "iout");
+            return (Criteria) this;
+        }
+
+        public Criteria andIoutLike(String value) {
+            addCriterion("iout like", value, "iout");
+            return (Criteria) this;
+        }
+
+        public Criteria andIoutNotLike(String value) {
+            addCriterion("iout not like", value, "iout");
+            return (Criteria) this;
+        }
+
+        public Criteria andIoutIn(List<String> values) {
+            addCriterion("iout in", values, "iout");
+            return (Criteria) this;
+        }
+
+        public Criteria andIoutNotIn(List<String> values) {
+            addCriterion("iout not in", values, "iout");
+            return (Criteria) this;
+        }
+
+        public Criteria andIoutBetween(String value1, String value2) {
+            addCriterion("iout between", value1, value2, "iout");
+            return (Criteria) this;
+        }
+
+        public Criteria andIoutNotBetween(String value1, String value2) {
+            addCriterion("iout not between", value1, value2, "iout");
+            return (Criteria) this;
+        }
+
+        public Criteria andIrestartIsNull() {
+            addCriterion("irestart is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andIrestartIsNotNull() {
+            addCriterion("irestart is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andIrestartEqualTo(String value) {
+            addCriterion("irestart =", value, "irestart");
+            return (Criteria) this;
+        }
+
+        public Criteria andIrestartNotEqualTo(String value) {
+            addCriterion("irestart <>", value, "irestart");
+            return (Criteria) this;
+        }
+
+        public Criteria andIrestartGreaterThan(String value) {
+            addCriterion("irestart >", value, "irestart");
+            return (Criteria) this;
+        }
+
+        public Criteria andIrestartGreaterThanOrEqualTo(String value) {
+            addCriterion("irestart >=", value, "irestart");
+            return (Criteria) this;
+        }
+
+        public Criteria andIrestartLessThan(String value) {
+            addCriterion("irestart <", value, "irestart");
+            return (Criteria) this;
+        }
+
+        public Criteria andIrestartLessThanOrEqualTo(String value) {
+            addCriterion("irestart <=", value, "irestart");
+            return (Criteria) this;
+        }
+
+        public Criteria andIrestartLike(String value) {
+            addCriterion("irestart like", value, "irestart");
+            return (Criteria) this;
+        }
+
+        public Criteria andIrestartNotLike(String value) {
+            addCriterion("irestart not like", value, "irestart");
+            return (Criteria) this;
+        }
+
+        public Criteria andIrestartIn(List<String> values) {
+            addCriterion("irestart in", values, "irestart");
+            return (Criteria) this;
+        }
+
+        public Criteria andIrestartNotIn(List<String> values) {
+            addCriterion("irestart not in", values, "irestart");
+            return (Criteria) this;
+        }
+
+        public Criteria andIrestartBetween(String value1, String value2) {
+            addCriterion("irestart between", value1, value2, "irestart");
+            return (Criteria) this;
+        }
+
+        public Criteria andIrestartNotBetween(String value1, String value2) {
+            addCriterion("irestart not between", value1, value2, "irestart");
+            return (Criteria) this;
+        }
+
+        public Criteria andNdoeIsNull() {
+            addCriterion("ndoe is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNdoeIsNotNull() {
+            addCriterion("ndoe is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNdoeEqualTo(String value) {
+            addCriterion("ndoe =", value, "ndoe");
+            return (Criteria) this;
+        }
+
+        public Criteria andNdoeNotEqualTo(String value) {
+            addCriterion("ndoe <>", value, "ndoe");
+            return (Criteria) this;
+        }
+
+        public Criteria andNdoeGreaterThan(String value) {
+            addCriterion("ndoe >", value, "ndoe");
+            return (Criteria) this;
+        }
+
+        public Criteria andNdoeGreaterThanOrEqualTo(String value) {
+            addCriterion("ndoe >=", value, "ndoe");
+            return (Criteria) this;
+        }
+
+        public Criteria andNdoeLessThan(String value) {
+            addCriterion("ndoe <", value, "ndoe");
+            return (Criteria) this;
+        }
+
+        public Criteria andNdoeLessThanOrEqualTo(String value) {
+            addCriterion("ndoe <=", value, "ndoe");
+            return (Criteria) this;
+        }
+
+        public Criteria andNdoeLike(String value) {
+            addCriterion("ndoe like", value, "ndoe");
+            return (Criteria) this;
+        }
+
+        public Criteria andNdoeNotLike(String value) {
+            addCriterion("ndoe not like", value, "ndoe");
+            return (Criteria) this;
+        }
+
+        public Criteria andNdoeIn(List<String> values) {
+            addCriterion("ndoe in", values, "ndoe");
+            return (Criteria) this;
+        }
+
+        public Criteria andNdoeNotIn(List<String> values) {
+            addCriterion("ndoe not in", values, "ndoe");
+            return (Criteria) this;
+        }
+
+        public Criteria andNdoeBetween(String value1, String value2) {
+            addCriterion("ndoe between", value1, value2, "ndoe");
+            return (Criteria) this;
+        }
+
+        public Criteria andNdoeNotBetween(String value1, String value2) {
+            addCriterion("ndoe not between", value1, value2, "ndoe");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsIsNull() {
+            addCriterion("ns is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsIsNotNull() {
+            addCriterion("ns is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsEqualTo(String value) {
+            addCriterion("ns =", value, "ns");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsNotEqualTo(String value) {
+            addCriterion("ns <>", value, "ns");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsGreaterThan(String value) {
+            addCriterion("ns >", value, "ns");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsGreaterThanOrEqualTo(String value) {
+            addCriterion("ns >=", value, "ns");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsLessThan(String value) {
+            addCriterion("ns <", value, "ns");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsLessThanOrEqualTo(String value) {
+            addCriterion("ns <=", value, "ns");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsLike(String value) {
+            addCriterion("ns like", value, "ns");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsNotLike(String value) {
+            addCriterion("ns not like", value, "ns");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsIn(List<String> values) {
+            addCriterion("ns in", values, "ns");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsNotIn(List<String> values) {
+            addCriterion("ns not in", values, "ns");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsBetween(String value1, String value2) {
+            addCriterion("ns between", value1, value2, "ns");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsNotBetween(String value1, String value2) {
+            addCriterion("ns not between", value1, value2, "ns");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxIsNull() {
+            addCriterion("nsmax is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxIsNotNull() {
+            addCriterion("nsmax is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxEqualTo(String value) {
+            addCriterion("nsmax =", value, "nsmax");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxNotEqualTo(String value) {
+            addCriterion("nsmax <>", value, "nsmax");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxGreaterThan(String value) {
+            addCriterion("nsmax >", value, "nsmax");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxGreaterThanOrEqualTo(String value) {
+            addCriterion("nsmax >=", value, "nsmax");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxLessThan(String value) {
+            addCriterion("nsmax <", value, "nsmax");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxLessThanOrEqualTo(String value) {
+            addCriterion("nsmax <=", value, "nsmax");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxLike(String value) {
+            addCriterion("nsmax like", value, "nsmax");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxNotLike(String value) {
+            addCriterion("nsmax not like", value, "nsmax");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxIn(List<String> values) {
+            addCriterion("nsmax in", values, "nsmax");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxNotIn(List<String> values) {
+            addCriterion("nsmax not in", values, "nsmax");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxBetween(String value1, String value2) {
+            addCriterion("nsmax between", value1, value2, "nsmax");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxNotBetween(String value1, String value2) {
+            addCriterion("nsmax not between", value1, value2, "nsmax");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsLfIsNull() {
+            addCriterion("ns_lf is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsLfIsNotNull() {
+            addCriterion("ns_lf is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsLfEqualTo(String value) {
+            addCriterion("ns_lf =", value, "nsLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsLfNotEqualTo(String value) {
+            addCriterion("ns_lf <>", value, "nsLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsLfGreaterThan(String value) {
+            addCriterion("ns_lf >", value, "nsLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsLfGreaterThanOrEqualTo(String value) {
+            addCriterion("ns_lf >=", value, "nsLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsLfLessThan(String value) {
+            addCriterion("ns_lf <", value, "nsLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsLfLessThanOrEqualTo(String value) {
+            addCriterion("ns_lf <=", value, "nsLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsLfLike(String value) {
+            addCriterion("ns_lf like", value, "nsLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsLfNotLike(String value) {
+            addCriterion("ns_lf not like", value, "nsLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsLfIn(List<String> values) {
+            addCriterion("ns_lf in", values, "nsLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsLfNotIn(List<String> values) {
+            addCriterion("ns_lf not in", values, "nsLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsLfBetween(String value1, String value2) {
+            addCriterion("ns_lf between", value1, value2, "nsLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsLfNotBetween(String value1, String value2) {
+            addCriterion("ns_lf not between", value1, value2, "nsLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxLfIsNull() {
+            addCriterion("nsmax_lf is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxLfIsNotNull() {
+            addCriterion("nsmax_lf is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxLfEqualTo(String value) {
+            addCriterion("nsmax_lf =", value, "nsmaxLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxLfNotEqualTo(String value) {
+            addCriterion("nsmax_lf <>", value, "nsmaxLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxLfGreaterThan(String value) {
+            addCriterion("nsmax_lf >", value, "nsmaxLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxLfGreaterThanOrEqualTo(String value) {
+            addCriterion("nsmax_lf >=", value, "nsmaxLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxLfLessThan(String value) {
+            addCriterion("nsmax_lf <", value, "nsmaxLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxLfLessThanOrEqualTo(String value) {
+            addCriterion("nsmax_lf <=", value, "nsmaxLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxLfLike(String value) {
+            addCriterion("nsmax_lf like", value, "nsmaxLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxLfNotLike(String value) {
+            addCriterion("nsmax_lf not like", value, "nsmaxLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxLfIn(List<String> values) {
+            addCriterion("nsmax_lf in", values, "nsmaxLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxLfNotIn(List<String> values) {
+            addCriterion("nsmax_lf not in", values, "nsmaxLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxLfBetween(String value1, String value2) {
+            addCriterion("nsmax_lf between", value1, value2, "nsmaxLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxLfNotBetween(String value1, String value2) {
+            addCriterion("nsmax_lf not between", value1, value2, "nsmaxLf");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsMkIsNull() {
+            addCriterion("ns_mk is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsMkIsNotNull() {
+            addCriterion("ns_mk is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsMkEqualTo(String value) {
+            addCriterion("ns_mk =", value, "nsMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsMkNotEqualTo(String value) {
+            addCriterion("ns_mk <>", value, "nsMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsMkGreaterThan(String value) {
+            addCriterion("ns_mk >", value, "nsMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsMkGreaterThanOrEqualTo(String value) {
+            addCriterion("ns_mk >=", value, "nsMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsMkLessThan(String value) {
+            addCriterion("ns_mk <", value, "nsMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsMkLessThanOrEqualTo(String value) {
+            addCriterion("ns_mk <=", value, "nsMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsMkLike(String value) {
+            addCriterion("ns_mk like", value, "nsMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsMkNotLike(String value) {
+            addCriterion("ns_mk not like", value, "nsMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsMkIn(List<String> values) {
+            addCriterion("ns_mk in", values, "nsMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsMkNotIn(List<String> values) {
+            addCriterion("ns_mk not in", values, "nsMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsMkBetween(String value1, String value2) {
+            addCriterion("ns_mk between", value1, value2, "nsMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsMkNotBetween(String value1, String value2) {
+            addCriterion("ns_mk not between", value1, value2, "nsMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxMkIsNull() {
+            addCriterion("nsmax_mk is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxMkIsNotNull() {
+            addCriterion("nsmax_mk is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxMkEqualTo(String value) {
+            addCriterion("nsmax_mk =", value, "nsmaxMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxMkNotEqualTo(String value) {
+            addCriterion("nsmax_mk <>", value, "nsmaxMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxMkGreaterThan(String value) {
+            addCriterion("nsmax_mk >", value, "nsmaxMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxMkGreaterThanOrEqualTo(String value) {
+            addCriterion("nsmax_mk >=", value, "nsmaxMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxMkLessThan(String value) {
+            addCriterion("nsmax_mk <", value, "nsmaxMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxMkLessThanOrEqualTo(String value) {
+            addCriterion("nsmax_mk <=", value, "nsmaxMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxMkLike(String value) {
+            addCriterion("nsmax_mk like", value, "nsmaxMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxMkNotLike(String value) {
+            addCriterion("nsmax_mk not like", value, "nsmaxMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxMkIn(List<String> values) {
+            addCriterion("nsmax_mk in", values, "nsmaxMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxMkNotIn(List<String> values) {
+            addCriterion("nsmax_mk not in", values, "nsmaxMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxMkBetween(String value1, String value2) {
+            addCriterion("nsmax_mk between", value1, value2, "nsmaxMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andNsmaxMkNotBetween(String value1, String value2) {
+            addCriterion("nsmax_mk not between", value1, value2, "nsmaxMk");
+            return (Criteria) this;
+        }
+
+        public Criteria andXTolIsNull() {
+            addCriterion("x_tol is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andXTolIsNotNull() {
+            addCriterion("x_tol is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andXTolEqualTo(String value) {
+            addCriterion("x_tol =", value, "xTol");
+            return (Criteria) this;
+        }
+
+        public Criteria andXTolNotEqualTo(String value) {
+            addCriterion("x_tol <>", value, "xTol");
+            return (Criteria) this;
+        }
+
+        public Criteria andXTolGreaterThan(String value) {
+            addCriterion("x_tol >", value, "xTol");
+            return (Criteria) this;
+        }
+
+        public Criteria andXTolGreaterThanOrEqualTo(String value) {
+            addCriterion("x_tol >=", value, "xTol");
+            return (Criteria) this;
+        }
+
+        public Criteria andXTolLessThan(String value) {
+            addCriterion("x_tol <", value, "xTol");
+            return (Criteria) this;
+        }
+
+        public Criteria andXTolLessThanOrEqualTo(String value) {
+            addCriterion("x_tol <=", value, "xTol");
+            return (Criteria) this;
+        }
+
+        public Criteria andXTolLike(String value) {
+            addCriterion("x_tol like", value, "xTol");
+            return (Criteria) this;
+        }
+
+        public Criteria andXTolNotLike(String value) {
+            addCriterion("x_tol not like", value, "xTol");
+            return (Criteria) this;
+        }
+
+        public Criteria andXTolIn(List<String> values) {
+            addCriterion("x_tol in", values, "xTol");
+            return (Criteria) this;
+        }
+
+        public Criteria andXTolNotIn(List<String> values) {
+            addCriterion("x_tol not in", values, "xTol");
+            return (Criteria) this;
+        }
+
+        public Criteria andXTolBetween(String value1, String value2) {
+            addCriterion("x_tol between", value1, value2, "xTol");
+            return (Criteria) this;
+        }
+
+        public Criteria andXTolNotBetween(String value1, String value2) {
+            addCriterion("x_tol not between", value1, value2, "xTol");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolRealIsNull() {
+            addCriterion("feasibility_tol_real is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolRealIsNotNull() {
+            addCriterion("feasibility_tol_real is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolRealEqualTo(String value) {
+            addCriterion("feasibility_tol_real =", value, "feasibilityTolReal");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolRealNotEqualTo(String value) {
+            addCriterion("feasibility_tol_real <>", value, "feasibilityTolReal");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolRealGreaterThan(String value) {
+            addCriterion("feasibility_tol_real >", value, "feasibilityTolReal");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolRealGreaterThanOrEqualTo(String value) {
+            addCriterion("feasibility_tol_real >=", value, "feasibilityTolReal");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolRealLessThan(String value) {
+            addCriterion("feasibility_tol_real <", value, "feasibilityTolReal");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolRealLessThanOrEqualTo(String value) {
+            addCriterion("feasibility_tol_real <=", value, "feasibilityTolReal");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolRealLike(String value) {
+            addCriterion("feasibility_tol_real like", value, "feasibilityTolReal");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolRealNotLike(String value) {
+            addCriterion("feasibility_tol_real not like", value, "feasibilityTolReal");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolRealIn(List<String> values) {
+            addCriterion("feasibility_tol_real in", values, "feasibilityTolReal");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolRealNotIn(List<String> values) {
+            addCriterion("feasibility_tol_real not in", values, "feasibilityTolReal");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolRealBetween(String value1, String value2) {
+            addCriterion("feasibility_tol_real between", value1, value2, "feasibilityTolReal");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolRealNotBetween(String value1, String value2) {
+            addCriterion("feasibility_tol_real not between", value1, value2, "feasibilityTolReal");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolSurroIsNull() {
+            addCriterion("feasibility_tol_surro is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolSurroIsNotNull() {
+            addCriterion("feasibility_tol_surro is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolSurroEqualTo(String value) {
+            addCriterion("feasibility_tol_surro =", value, "feasibilityTolSurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolSurroNotEqualTo(String value) {
+            addCriterion("feasibility_tol_surro <>", value, "feasibilityTolSurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolSurroGreaterThan(String value) {
+            addCriterion("feasibility_tol_surro >", value, "feasibilityTolSurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolSurroGreaterThanOrEqualTo(String value) {
+            addCriterion("feasibility_tol_surro >=", value, "feasibilityTolSurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolSurroLessThan(String value) {
+            addCriterion("feasibility_tol_surro <", value, "feasibilityTolSurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolSurroLessThanOrEqualTo(String value) {
+            addCriterion("feasibility_tol_surro <=", value, "feasibilityTolSurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolSurroLike(String value) {
+            addCriterion("feasibility_tol_surro like", value, "feasibilityTolSurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolSurroNotLike(String value) {
+            addCriterion("feasibility_tol_surro not like", value, "feasibilityTolSurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolSurroIn(List<String> values) {
+            addCriterion("feasibility_tol_surro in", values, "feasibilityTolSurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolSurroNotIn(List<String> values) {
+            addCriterion("feasibility_tol_surro not in", values, "feasibilityTolSurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolSurroBetween(String value1, String value2) {
+            addCriterion("feasibility_tol_surro between", value1, value2, "feasibilityTolSurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andFeasibilityTolSurroNotBetween(String value1, String value2) {
+            addCriterion("feasibility_tol_surro not between", value1, value2, "feasibilityTolSurro");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmIsNull() {
+            addCriterion("algorithm is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmIsNotNull() {
+            addCriterion("algorithm is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmEqualTo(String value) {
+            addCriterion("algorithm =", value, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmNotEqualTo(String value) {
+            addCriterion("algorithm <>", value, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmGreaterThan(String value) {
+            addCriterion("algorithm >", value, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmGreaterThanOrEqualTo(String value) {
+            addCriterion("algorithm >=", value, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmLessThan(String value) {
+            addCriterion("algorithm <", value, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmLessThanOrEqualTo(String value) {
+            addCriterion("algorithm <=", value, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmLike(String value) {
+            addCriterion("algorithm like", value, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmNotLike(String value) {
+            addCriterion("algorithm not like", value, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmIn(List<String> values) {
+            addCriterion("algorithm in", values, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmNotIn(List<String> values) {
+            addCriterion("algorithm not in", values, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmBetween(String value1, String value2) {
+            addCriterion("algorithm between", value1, value2, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andAlgorithmNotBetween(String value1, String value2) {
+            addCriterion("algorithm not between", value1, value2, "algorithm");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedIsNull() {
+            addCriterion("checked is null");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedIsNotNull() {
+            addCriterion("checked is not null");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedEqualTo(Short value) {
+            addCriterion("checked =", value, "checked");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedNotEqualTo(Short value) {
+            addCriterion("checked <>", value, "checked");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedGreaterThan(Short value) {
+            addCriterion("checked >", value, "checked");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedGreaterThanOrEqualTo(Short value) {
+            addCriterion("checked >=", value, "checked");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedLessThan(Short value) {
+            addCriterion("checked <", value, "checked");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedLessThanOrEqualTo(Short value) {
+            addCriterion("checked <=", value, "checked");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedIn(List<Short> values) {
+            addCriterion("checked in", values, "checked");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedNotIn(List<Short> values) {
+            addCriterion("checked not in", values, "checked");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedBetween(Short value1, Short value2) {
+            addCriterion("checked between", value1, value2, "checked");
+            return (Criteria) this;
+        }
+
+        public Criteria andCheckedNotBetween(Short value1, Short value2) {
+            addCriterion("checked not between", value1, value2, "checked");
+            return (Criteria) this;
+        }
+    }
+
+    public static class Criteria extends GeneratedCriteria {
+
+        protected Criteria() {
+            super();
+        }
+    }
+
+    public static class Criterion {
+        private String condition;
+
+        private Object value;
+
+        private Object secondValue;
+
+        private boolean noValue;
+
+        private boolean singleValue;
+
+        private boolean betweenValue;
+
+        private boolean listValue;
+
+        private String typeHandler;
+
+        public String getCondition() {
+            return condition;
+        }
+
+        public Object getValue() {
+            return value;
+        }
+
+        public Object getSecondValue() {
+            return secondValue;
+        }
+
+        public boolean isNoValue() {
+            return noValue;
+        }
+
+        public boolean isSingleValue() {
+            return singleValue;
+        }
+
+        public boolean isBetweenValue() {
+            return betweenValue;
+        }
+
+        public boolean isListValue() {
+            return listValue;
+        }
+
+        public String getTypeHandler() {
+            return typeHandler;
+        }
+
+        protected Criterion(String condition) {
+            super();
+            this.condition = condition;
+            this.typeHandler = null;
+            this.noValue = true;
+        }
+
+        protected Criterion(String condition, Object value, String typeHandler) {
+            super();
+            this.condition = condition;
+            this.value = value;
+            this.typeHandler = typeHandler;
+            if (value instanceof List<?>) {
+                this.listValue = true;
+            } else {
+                this.singleValue = true;
+            }
+        }
+
+        protected Criterion(String condition, Object value) {
+            this(condition, value, null);
+        }
+
+        protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
+            super();
+            this.condition = condition;
+            this.value = value;
+            this.secondValue = secondValue;
+            this.typeHandler = typeHandler;
+            this.betweenValue = true;
+        }
+
+        protected Criterion(String condition, Object value, Object secondValue) {
+            this(condition, value, secondValue, null);
+        }
+    }
+}

modelsrc/com/miniframe/model/mdo/dao/MdoProGradMapper.java

@@ -0,0 +1,10 @@
+package com.miniframe.model.mdo.dao;
+
+import com.miniframe.model.mdo.MdoProGrad;
+import com.miniframe.model.mdo.MdoProGradSQLBuilder;
+import com.miniframe.spring.db.MFBaseMapper;
+import com.miniframe.system.MiniserviceBaseDao;
+
+public interface MdoProGradMapper extends MiniserviceBaseDao, MFBaseMapper<MdoProGrad> {
+    long countByExample(MdoProGradSQLBuilder example);
+}

modelsrc/com/miniframe/model/mdo/dao/MdoProSurroMapper.java

@@ -0,0 +1,10 @@
+package com.miniframe.model.mdo.dao;
+
+import com.miniframe.model.mdo.MdoProSurro;
+import com.miniframe.model.mdo.MdoProSurroSQLBuilder;
+import com.miniframe.spring.db.MFBaseMapper;
+import com.miniframe.system.MiniserviceBaseDao;
+
+public interface MdoProSurroMapper extends MiniserviceBaseDao, MFBaseMapper<MdoProSurro> {
+    long countByExample(MdoProSurroSQLBuilder example);
+}

modelsrc/com/miniframe/model/mdo/xml/MdoProGradMapper.xml

@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.miniframe.model.mdo.dao.MdoProGradMapper">
+  <sql id="Example_Where_Clause">
+    <!--
+      WARNING - @mbg.generated
+    -->
+    <where>
+      <foreach collection="oredCriteria" item="criteria" separator="or">
+        <if test="criteria.valid">
+          <trim prefix="(" prefixOverrides="and" suffix=")">
+            <foreach collection="criteria.criteria" item="criterion">
+              <choose>
+                <when test="criterion.noValue">
+                  and ${criterion.condition}
+                </when>
+                <when test="criterion.singleValue">
+                  and ${criterion.condition} #{criterion.value}
+                </when>
+                <when test="criterion.betweenValue">
+                  and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}
+                </when>
+                <when test="criterion.listValue">
+                  and ${criterion.condition}
+                  <foreach close=")" collection="criterion.value" item="listItem" open="(" separator=",">
+                    #{listItem}
+                  </foreach>
+                </when>
+              </choose>
+            </foreach>
+          </trim>
+        </if>
+      </foreach>
+    </where>
+  </sql>
+  <select id="countByExample" parameterType="com.miniframe.model.mdo.MdoProGradSQLBuilder" resultType="java.lang.Long">
+    <!--
+      WARNING - @mbg.generated
+    -->
+    select count(*) from mdo_pro_grad
+    <if test="_parameter != null">
+      <include refid="Example_Where_Clause" />
+    </if>
+  </select>
+  <cache>
+    <!--
+      WARNING - @mbg.generated
+    -->
+  </cache>
+</mapper>

modelsrc/com/miniframe/model/mdo/xml/MdoProSurroMapper.xml

@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.miniframe.model.mdo.dao.MdoProSurroMapper">
+  <sql id="Example_Where_Clause">
+    <!--
+      WARNING - @mbg.generated
+    -->
+    <where>
+      <foreach collection="oredCriteria" item="criteria" separator="or">
+        <if test="criteria.valid">
+          <trim prefix="(" prefixOverrides="and" suffix=")">
+            <foreach collection="criteria.criteria" item="criterion">
+              <choose>
+                <when test="criterion.noValue">
+                  and ${criterion.condition}
+                </when>
+                <when test="criterion.singleValue">
+                  and ${criterion.condition} #{criterion.value}
+                </when>
+                <when test="criterion.betweenValue">
+                  and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}
+                </when>
+                <when test="criterion.listValue">
+                  and ${criterion.condition}
+                  <foreach close=")" collection="criterion.value" item="listItem" open="(" separator=",">
+                    #{listItem}
+                  </foreach>
+                </when>
+              </choose>
+            </foreach>
+          </trim>
+        </if>
+      </foreach>
+    </where>
+  </sql>
+  <select id="countByExample" parameterType="com.miniframe.model.mdo.MdoProSurroSQLBuilder" resultType="java.lang.Long">
+    <!--
+      WARNING - @mbg.generated
+    -->
+    select count(*) from mdo_pro_surro
+    <if test="_parameter != null">
+      <include refid="Example_Where_Clause" />
+    </if>
+  </select>
+  <cache>
+    <!--
+      WARNING - @mbg.generated
+    -->
+  </cache>
+</mapper>

src/main/java/com/miniframe/bisiness/mdo/MDO0031Service.java

@@ -0,0 +1,84 @@
+package com.miniframe.bisiness.mdo;
+
+import java.util.List;
+import java.util.Map;
+import com.miniframe.core.ExecProcessFlow;
+import com.miniframe.core.ext.UtilTools;
+import com.miniframe.generate.business.mdo.model.MDO0031BaseModel;
+import com.miniframe.generate.comm.mdo.D_MDO0031;
+import com.miniframe.model.mdo.MdoProEvolution;
+import com.miniframe.model.mdo.MdoProSurro;
+import com.miniframe.model.mdo.MdoProSurroSQLBuilder;
+import com.miniframe.model.mdo.dao.MdoProSurroMapper;
+
+/**
+ * 西工大系统,“代理优化器参数查询”逻辑处理（重新生成不覆盖）。
+ */
+public class MDO0031Service extends MDO0031BaseModel implements ExecProcessFlow {
+	
+	private static final long serialVersionUID = -7051358269847459502L;
+		
+	/**
+	 * 西工大系统,“代理优化器参数查询”业务核心处理
+ 	 */
+	public void transExecute() throws Exception {
+		String pid =this.getA_mdo0031().getPid();
+		MdoProSurroMapper  suDao = UtilTools.getBean(MdoProSurroMapper.class);
+		MdoProSurroSQLBuilder suSql =new MdoProSurroSQLBuilder();
+		MdoProSurroSQLBuilder.Criteria suCr= suSql.createCriteria();
+		suCr.andPidEqualTo(pid);
+		List<MdoProSurro> suList =suDao.selectByExample(suCr);
+		if(suList!=null&&!suList.isEmpty()){
+			MdoProSurro su = suList.get(0);
+			D_MDO0031 d =new D_MDO0031();
+			d.setAlgorithm(su.getAlgorithm());
+			d.setChecked(su.getChecked());
+			d.setFeasibilitytolreal(su.getFeasibilityTolReal());
+			d.setFeasibilitytolsurro(su.getFeasibilityTolSurro());
+			d.setIout(su.getIout());
+			d.setNdoe(su.getNdoe());
+			d.setIrestart(su.getIrestart());
+			d.setNkriging(su.getnKriging());
+			d.setNs(su.getNs());
+			d.setNslf(su.getNsLf());
+			d.setNsmax(su.getNsmax());
+			d.setNsmaxmk(su.getNsmaxMk());
+			d.setNsurro(su.getNsurro());
+			d.setNsmaxlf(su.getNsmaxLf());
+			d.setPid(su.getPid());
+			d.setSuid(su.getId());
+			d.setXtol(su.getxTol());
+			d.setNsmk(su.getNsMk());
+			this.setD_mdo0031(d);
+		}
+	
+	}
+	
+	/**
+	 * 西工大系统,“代理优化器参数查询”业务前处理
+ 	 */
+	public void preTransFlow() throws Exception {
+		this.validater();
+	}
+	
+	/**
+	 * 西工大系统,“代理优化器参数查询”业务后处理
+ 	 */
+	public void afterTransFlow() throws Exception {
+	
+	}
+	
+	/**
+	 * 西工大系统,“代理优化器参数查询”逻辑入口处理方法
+ 	 */
+ 	@SuppressWarnings("rawtypes")
+	@Override
+	public Map execute(Map vars) throws Exception {
+		this.setTransMap(vars);
+		preTransFlow();// 执行业务开始的规则检查和校验
+		transExecute();// 执行核心业务段
+		afterTransFlow();// 执行核心逻辑完成后的收尾逻辑
+		return this.getTransMap();
+	}
+
+}

src/main/java/com/miniframe/bisiness/mdo/MDO0032Service.java

@@ -0,0 +1,122 @@
+package com.miniframe.bisiness.mdo;
+
+import java.util.List;
+import java.util.Map;
+
+import com.miniframe.bisiness.mdo.service.ProEvoSuGrService;
+import com.miniframe.core.ExecProcessFlow;
+import com.miniframe.core.ext.UtilTools;
+import com.miniframe.generate.business.mdo.model.MDO0032BaseModel;
+import com.miniframe.model.mdo.MdoProSurro;
+import com.miniframe.model.mdo.MdoProSurroSQLBuilder;
+import com.miniframe.model.mdo.dao.MdoProSurroMapper;
+import tk.mybatis.mapper.util.StringUtil;
+
+/**
+ * 西工大系统,“代理优化器参数添加修改”逻辑处理（重新生成不覆盖）。
+ */
+public class MDO0032Service extends MDO0032BaseModel implements ExecProcessFlow {
+	
+	private static final long serialVersionUID = -7051358269847459502L;
+		
+	/**
+	 * 西工大系统,“代理优化器参数添加修改”业务核心处理
+ 	 */
+	public void transExecute() throws Exception {
+		String suid =this.getA_mdo0032().getSuid();
+		String pid =this.getA_mdo0032().getPid();
+		String nsurro =this.getA_mdo0032().getNsurro();
+		String n_kriging =this.getA_mdo0032().getNkriging();
+		String iout=this.getA_mdo0032().getIout();
+		String irestart=this.getA_mdo0032().getIrestart();
+		String ndoe=this.getA_mdo0032().getNdoe();
+		String ns=this.getA_mdo0032().getNs();
+		String nsmax=this.getA_mdo0032().getNsmax();
+		String ns_lf=this.getA_mdo0032().getNslf();
+		String nsmax_lf=this.getA_mdo0032().getNslf();
+		String ns_mk=this.getA_mdo0032().getNsmk();
+		String nsmax_mk=this.getA_mdo0032().getNsmaxmk();
+		String x_tol=this.getA_mdo0032().getXtol();
+		String feasibility_tol_real=this.getA_mdo0032().getFeasibilitytolreal();
+		String feasibility_tol_surro=this.getA_mdo0032().getFeasibilitytolsurro();
+		String algorithm=this.getA_mdo0032().getAlgorithm();
+		Integer checked=this.getA_mdo0032().getChecked();
+
+		MdoProSurroMapper sudao =UtilTools.getBean(MdoProSurroMapper.class);
+		if(StringUtil.isEmpty(suid)) {//添加
+			MdoProSurro su =new MdoProSurro();
+			su.setId(UtilTools.getUUid());
+			su.setPid(pid);
+			su.setNsurro(nsurro);
+			su.setnKriging(n_kriging);
+			su.setIout(iout);
+			su.setIrestart(irestart);
+			su.setNdoe(ndoe);
+			su.setNs(ns);
+			su.setNsmax(nsmax);
+			su.setNsLf(ns_lf);
+			su.setNsmaxLf(nsmax_lf);
+			su.setNsMk(ns_mk);
+			su.setNsmaxMk(nsmax_mk);
+			su.setxTol(x_tol);
+			su.setFeasibilityTolReal(feasibility_tol_real);
+			su.setFeasibilityTolSurro(feasibility_tol_surro);
+			su.setAlgorithm(algorithm);
+			su.setChecked(Short.valueOf(String.valueOf(checked)));
+			sudao.insert(su);
+		}else{
+			MdoProSurro su =sudao.selectByPrimaryKey(suid);
+			if(su!=null){
+				su.setPid(pid);
+				su.setNsurro(nsurro);
+				su.setnKriging(n_kriging);
+				su.setIout(iout);
+				su.setIrestart(irestart);
+				su.setNdoe(ndoe);
+				su.setNs(ns);
+				su.setNsmax(nsmax);
+				su.setNsLf(ns_lf);
+				su.setNsmaxLf(nsmax_lf);
+				su.setNsMk(ns_mk);
+				su.setNsmaxMk(nsmax_mk);
+				su.setxTol(x_tol);
+				su.setFeasibilityTolReal(feasibility_tol_real);
+				su.setFeasibilityTolSurro(feasibility_tol_surro);
+				su.setAlgorithm(algorithm);
+				su.setChecked(Short.valueOf(String.valueOf(checked)));
+				sudao.updateByPrimaryKey(su);
+			}
+		}
+		ProEvoSuGrService.delEvo(pid);
+		ProEvoSuGrService.delGrad(pid);
+
+	}
+	
+	/**
+	 * 西工大系统,“代理优化器参数添加修改”业务前处理
+ 	 */
+	public void preTransFlow() throws Exception {
+		this.validater();
+	}
+	
+	/**
+	 * 西工大系统,“代理优化器参数添加修改”业务后处理
+ 	 */
+	public void afterTransFlow() throws Exception {
+	
+	}
+	
+	/**
+	 * 西工大系统,“代理优化器参数添加修改”逻辑入口处理方法
+ 	 */
+ 	@SuppressWarnings("rawtypes")
+	@Override
+	public Map execute(Map vars) throws Exception {
+		this.setTransMap(vars);
+		preTransFlow();// 执行业务开始的规则检查和校验
+		transExecute();// 执行核心业务段
+		afterTransFlow();// 执行核心逻辑完成后的收尾逻辑
+		return this.getTransMap();
+	}
+
+}

src/main/java/com/miniframe/bisiness/mdo/MDO0033Service.java

@@ -0,0 +1,73 @@
+package com.miniframe.bisiness.mdo;
+
+import java.util.List;
+import java.util.Map;
+import com.miniframe.core.ExecProcessFlow;
+import com.miniframe.core.ext.UtilTools;
+import com.miniframe.generate.business.mdo.model.MDO0033BaseModel;
+import com.miniframe.generate.comm.mdo.D_MDO0033;
+import com.miniframe.model.mdo.MdoProGrad;
+import com.miniframe.model.mdo.MdoProGradSQLBuilder;
+import com.miniframe.model.mdo.dao.MdoProGradMapper;
+
+/**
+ * 西工大系统,“梯度优化器参数查询”逻辑处理（重新生成不覆盖）。
+ */
+public class MDO0033Service extends MDO0033BaseModel implements ExecProcessFlow {
+	
+	private static final long serialVersionUID = -7051358269847459502L;
+		
+	/**
+	 * 西工大系统,“梯度优化器参数查询”业务核心处理
+ 	 */
+	public void transExecute() throws Exception {
+		String pid =this.getA_mdo0033().getPid();
+		MdoProGradMapper grDao = UtilTools.getBean(MdoProGradMapper.class);
+		MdoProGradSQLBuilder grSb =new MdoProGradSQLBuilder();
+		MdoProGradSQLBuilder.Criteria grSc = grSb.createCriteria();
+		grSc.andPidEqualTo(pid);
+		List<MdoProGrad> grList =grDao.selectByExample(grSb);
+		if(!grList.isEmpty()){
+			MdoProGrad gr =grList.get(0);
+			D_MDO0033 d =new D_MDO0033();
+			d.setGrid(gr.getId());
+			d.setAlgorithm(gr.getAlgorithm());
+			d.setMajoriterationslimit(gr.getMajorIterationsLimit());
+			d.setMajorprintlevel(gr.getMajorPrintLevel());
+			d.setLinearfeasibilitytolerance(gr.getLinearFeasibilityTolerance());
+			d.setNonlinearfeasibilitytolerance(gr.getNonlinearFeasibilityTolerance());
+			d.setOptimalitytolerance(gr.getOptimalityTolerance());
+			d.setVerifylevel(gr.getVerifyLevel());
+			d.setChecked(gr.getChecked());
+			this.setD_mdo0033(d);
+		}
+	}
+	
+	/**
+	 * 西工大系统,“梯度优化器参数查询”业务前处理
+ 	 */
+	public void preTransFlow() throws Exception {
+		this.validater();
+	}
+	
+	/**
+	 * 西工大系统,“梯度优化器参数查询”业务后处理
+ 	 */
+	public void afterTransFlow() throws Exception {
+	
+	}
+	
+	/**
+	 * 西工大系统,“梯度优化器参数查询”逻辑入口处理方法
+ 	 */
+ 	@SuppressWarnings("rawtypes")
+	@Override
+	public Map execute(Map vars) throws Exception {
+		this.setTransMap(vars);
+		preTransFlow();// 执行业务开始的规则检查和校验
+		transExecute();// 执行核心业务段
+		afterTransFlow();// 执行核心逻辑完成后的收尾逻辑
+		return this.getTransMap();
+	}
+
+}

src/main/java/com/miniframe/bisiness/mdo/MDO0034Service.java

@@ -0,0 +1,95 @@
+package com.miniframe.bisiness.mdo;
+
+import java.util.Map;
+
+import com.github.pagehelper.util.StringUtil;
+import com.miniframe.bisiness.mdo.service.ProEvoSuGrService;
+import com.miniframe.core.ExecProcessFlow;
+import com.miniframe.core.ext.UtilTools;
+import com.miniframe.generate.business.mdo.model.MDO0034BaseModel;
+import com.miniframe.model.mdo.MdoProGrad;
+import com.miniframe.model.mdo.dao.MdoProGradMapper;
+
+/**
+ * 西工大系统,“梯度优化器参数添加修改”逻辑处理（重新生成不覆盖）。
+ */
+public class MDO0034Service extends MDO0034BaseModel implements ExecProcessFlow {
+	
+	private static final long serialVersionUID = -7051358269847459502L;
+		
+	/**
+	 * 西工大系统,“梯度优化器参数添加修改”业务核心处理
+ 	 */
+	public void transExecute() throws Exception {
+		String grid =this.getA_mdo0034().getGrid();
+		String pid =this.getA_mdo0034().getPid();
+		String algorithm=this.getA_mdo0034().getAlgorithm();
+		String major_iterations_limit=this.getA_mdo0034().getMajoriterationslimit();
+		String major_print_level=this.getA_mdo0034().getMajorprintlevel();
+		String linear_feasibility_tolerance=this.getA_mdo0034().getLinearfeasibilitytolerance();
+		String nonlinear_feasibility_tolerance=this.getA_mdo0034().getNonlinearfeasibilitytolerance();
+		String optimality_tolerance=this.getA_mdo0034().getOptimalitytolerance();
+		String verify_level=this.getA_mdo0034().getVerifylevel();
+		Integer checked=this.getA_mdo0034().getChecked();
+		MdoProGradMapper grDao = UtilTools.getBean(MdoProGradMapper.class);
+		if(StringUtil.isEmpty(grid)){//添加修改
+			MdoProGrad gr =new MdoProGrad();
+			gr.setId(UtilTools.getUUid());
+			gr.setPid(pid);
+			gr.setAlgorithm(algorithm);
+			gr.setMajorIterationsLimit(major_iterations_limit);
+			gr.setMajorPrintLevel(major_print_level);
+			gr.setLinearFeasibilityTolerance(linear_feasibility_tolerance);
+			gr.setNonlinearFeasibilityTolerance(nonlinear_feasibility_tolerance);
+			gr.setOptimalityTolerance(optimality_tolerance);
+			gr.setVerifyLevel(verify_level);
+			gr.setChecked(Short.valueOf(String.valueOf(checked)));
+			grDao.insert(gr);
+		}else{
+			MdoProGrad gr =grDao.selectByPrimaryKey(grid);
+			if(gr != null){
+				gr.setPid(pid);
+				gr.setAlgorithm(algorithm);
+				gr.setMajorIterationsLimit(major_iterations_limit);
+				gr.setMajorPrintLevel(major_print_level);
+				gr.setLinearFeasibilityTolerance(linear_feasibility_tolerance);
+				gr.setNonlinearFeasibilityTolerance(nonlinear_feasibility_tolerance);
+				gr.setOptimalityTolerance(optimality_tolerance);
+				gr.setVerifyLevel(verify_level);
+				gr.setChecked(Short.valueOf(String.valueOf(checked)));
+				grDao.updateByPrimaryKey(gr);
+			}
+		}
+		ProEvoSuGrService.delEvo(pid);
+		ProEvoSuGrService.delSurro(pid);
+
+	}
+	
+	/**
+	 * 西工大系统,“梯度优化器参数添加修改”业务前处理
+ 	 */
+	public void preTransFlow() throws Exception {
+		this.validater();
+	}
+	
+	/**
+	 * 西工大系统,“梯度优化器参数添加修改”业务后处理
+ 	 */
+	public void afterTransFlow() throws Exception {
+	
+	}
+	
+	/**
+	 * 西工大系统,“梯度优化器参数添加修改”逻辑入口处理方法
+ 	 */
+ 	@SuppressWarnings("rawtypes")
+	@Override
+	public Map execute(Map vars) throws Exception {
+		this.setTransMap(vars);
+		preTransFlow();// 执行业务开始的规则检查和校验
+		transExecute();// 执行核心业务段
+		afterTransFlow();// 执行核心逻辑完成后的收尾逻辑
+		return this.getTransMap();
+	}
+
+}

src/main/java/com/miniframe/dbtransfer/MdoProGradDbTransfer.java

@@ -0,0 +1,25 @@
+package com.miniframe.dbtransfer;
+
+import com.miniframe.core.DbTransfer;
+import com.miniframe.model.mdo.MdoProGrad;
+
+import java.io.Serializable;
+import java.util.List;
+import java.util.Map;
+
+
+
+/**
+ * 实体列表,“mdo_pro_grad”数据库数据转化逻辑处理（重新生成不覆盖）。
+ */
+public class MdoProGradDbTransfer extends DbTransfer implements Serializable {
+	
+	private static final long serialVersionUID = -7051358269847459502L;
+
+	@Override
+	public List transfer(final List l,Map map) throws Exception{
+		List<MdoProGrad> list=l;
+		return list;
+	};
+
+}

src/main/java/com/miniframe/dbtransfer/MdoProSurroDbTransfer.java

@@ -0,0 +1,23 @@
+package com.miniframe.dbtransfer;
+
+import com.miniframe.core.DbTransfer;
+import java.io.Serializable;
+import java.util.List;
+import java.util.Map;
+
+import com.miniframe.model.mdo.MdoProSurro;
+
+/**
+ * 实体列表,“mdo_pro_surro”数据库数据转化逻辑处理（重新生成不覆盖）。
+ */
+public class MdoProSurroDbTransfer extends DbTransfer implements Serializable {
+	
+	private static final long serialVersionUID = -7051358269847459502L;
+
+	@Override
+	public List transfer(final List l,Map map) throws Exception{
+		List<MdoProSurro> list=l;
+		return list;
+	};
+
+}