package com.miniframe.model.mdo;

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

@Table(name = "mdo_pro_afnoise")
public class MdoProAfnoise extends MiniserviceBaseModel implements Serializable {
    @Id
    private String id;

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

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

    /**
     * 机翼 是否启用（T/F）
     */
    private String wing;

    /**
     * 缝翼 是否启用（T/F）
     */
    private String slat;

    /**
     * 水平尾翼 是否启用（T/F）
     */
    @Column(name = "horizontal_tail")
    private String horizontalTail;

    /**
     * 垂直尾翼 是否启用（T/F）
     */
    @Column(name = "vertical_tail")
    private String verticalTail;

    /**
     * 襟翼 是否启用（T/F）
     */
    private String flap;

    /**
     * 主起落架 是否启用（T/F）
     */
    @Column(name = "main_landing_gear")
    private String mainLandingGear;

    /**
     * 前起落架 是否启用（T/F）
     */
    @Column(name = "nose_landing_gear")
    private String noseLandingGear;

    /**
     * 机翼面积
     */
    @Column(name = "wing_area")
    private String wingArea;

    /**
     * 机翼展长
     */
    @Column(name = "wing_span")
    private String wingSpan;

    /**
     * 水平尾翼面积
     */
    @Column(name = "horizontal_tail_area")
    private String horizontalTailArea;

    /**
     * 水平尾翼展长
     */
    @Column(name = "horizontal_tail_span")
    private String horizontalTailSpan;

    /**
     * 垂直尾翼面积
     */
    @Column(name = "vertical_tail_area")
    private String verticalTailArea;

    /**
     * 垂直尾翼展长
     */
    @Column(name = "vertical_tail_span")
    private String verticalTailSpan;

    /**
     * 襟翼面积
     */
    @Column(name = "flap_area")
    private String flapArea;

    /**
     * 襟翼展长
     */
    @Column(name = "flap_span")
    private String flapSpan;

    /**
     * 襟翼偏转角度
     */
    @Column(name = "flap_deflection_angle")
    private String flapDeflectionAngle;

    /**
     * 主起落架数量
     */
    @Column(name = "number_of_main_landing_gears")
    private Integer numberOfMainLandingGears;

    /**
     * 主起落架每侧轮数
     */
    @Column(name = "number_of_wheels_per_main_landing_gear")
    private Integer numberOfWheelsPerMainLandingGear;

    /**
     * 主起落架轮直径
     */
    @Column(name = "main_landing_gear_wheel_diameter")
    private String mainLandingGearWheelDiameter;

    /**
     * 主起落架支柱长度
     */
    @Column(name = "main_landing_gear_strut_length")
    private String mainLandingGearStrutLength;

    /**
     * 前起落架数量
     */
    @Column(name = "number_of_nose_landing_gears")
    private Integer numberOfNoseLandingGears;

    /**
     * 前起落架每侧轮数
     */
    @Column(name = "number_of_wheels_per_nose_landing_gear")
    private Integer numberOfWheelsPerNoseLandingGear;

    /**
     * 前起落架轮直径
     */
    @Column(name = "nose_landing_gear_wheel_diameter")
    private String noseLandingGearWheelDiameter;

    /**
     * 前起落架支柱长度
     */
    @Column(name = "nose_landing_gear_strut_length")
    private String noseLandingGearStrutLength;

    /**
     * 是否启用（T/F）
     */
    @Column(name = "conventional_transport_aircraft")
    private String conventionalTransportAircraft;

    /**
     * 是否启用（T/F）
     */
    @Column(name = "aerodynamically_clean")
    private String aerodynamicallyClean;

    /**
     * 当前选中项指示
     */
    @Column(name = "selected_configs")
    private String selectedConfigs;

    /**
     * 是否启用（T/F）
     */
    @Column(name = "delta_wing")
    private String deltaWing;

    /**
     * 是否启用（T/F）
     */
    @Column(name = "rectangular_wing")
    private String rectangularWing;

    /**
     * 当前选中项指示
     */
    @Column(name = "selected_wing")
    private String selectedWing;

    /**
     * 是否启用（T/F）
     */
    @Column(name = "triple_slotted_flaps")
    private String tripleSlottedFlaps;

    /**
     * 是否启用（T/F）
     */
    @Column(name = "single_or_double_slotted_flaps")
    private String singleOrDoubleSlottedFlaps;

    /**
     * 当前选中项指示
     */
    @Column(name = "selected_flaps")
    private String selectedFlaps;

    /**
     * 声速
     */
    private String a;

    /**
     * 马赫数
     */
    private String ma;

    /**
     * 空气密度
     */
    private String density;

    /**
     * 动力黏度
     */
    @Column(name = "dynamic_viscosity")
    private String dynamicViscosity;

    /**
     * 是否启用（T/F）
     */
    private String fink;

    /**
     * 是否启用（T/F）
     */
    private String esdu;

    /**
     * 当前选中项指示
     */
    private String selected;

    /**
     * 起始频率(Hz)
     */
    @Column(name = "starting_fre")
    private String startingFre;

    /**
     * 截止频率(Hz)
     */
    @Column(name = "cutoff_fre")
    private String cutoffFre;

    /**
     * 麦克风数量
     */
    private Integer num;

    /**
     * 各麦克风距离
     */
    private String distances;

    /**
     * 极角
     */
    @Column(name = "polar_emission_angle")
    private String polarEmissionAngle;

    /**
     * 方位角
     */
    @Column(name = "azimuthal_angle")
    private String azimuthalAngle;

    /**
     * 频率
     */
    private String frequency;

    /**
     * 不同观测点对应的各频率的声压级
     */
    private String componentspl;

    /**
     * 不同观测点的总声压
     */
    private String oaspl;

    private static final long serialVersionUID = 1L;

    /**
     * @return id
     */
    public String getId() {
        return id;
    }

    /**
     * @param 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();
    }

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

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

    /**
     * 获取机翼 是否启用（T/F）
     *
     * @return wing - 机翼 是否启用（T/F）
     */
    public String getWing() {
        return wing;
    }

    /**
     * 设置机翼 是否启用（T/F）
     *
     * @param wing 机翼 是否启用（T/F）
     */
    public void setWing(String wing) {
        this.wing = wing == null ? null : wing.trim();
    }

    /**
     * 获取缝翼 是否启用（T/F）
     *
     * @return slat - 缝翼 是否启用（T/F）
     */
    public String getSlat() {
        return slat;
    }

    /**
     * 设置缝翼 是否启用（T/F）
     *
     * @param slat 缝翼 是否启用（T/F）
     */
    public void setSlat(String slat) {
        this.slat = slat == null ? null : slat.trim();
    }

    /**
     * 获取水平尾翼 是否启用（T/F）
     *
     * @return horizontal_tail - 水平尾翼 是否启用（T/F）
     */
    public String getHorizontalTail() {
        return horizontalTail;
    }

    /**
     * 设置水平尾翼 是否启用（T/F）
     *
     * @param horizontalTail 水平尾翼 是否启用（T/F）
     */
    public void setHorizontalTail(String horizontalTail) {
        this.horizontalTail = horizontalTail == null ? null : horizontalTail.trim();
    }

    /**
     * 获取垂直尾翼 是否启用（T/F）
     *
     * @return vertical_tail - 垂直尾翼 是否启用（T/F）
     */
    public String getVerticalTail() {
        return verticalTail;
    }

    /**
     * 设置垂直尾翼 是否启用（T/F）
     *
     * @param verticalTail 垂直尾翼 是否启用（T/F）
     */
    public void setVerticalTail(String verticalTail) {
        this.verticalTail = verticalTail == null ? null : verticalTail.trim();
    }

    /**
     * 获取襟翼 是否启用（T/F）
     *
     * @return flap - 襟翼 是否启用（T/F）
     */
    public String getFlap() {
        return flap;
    }

    /**
     * 设置襟翼 是否启用（T/F）
     *
     * @param flap 襟翼 是否启用（T/F）
     */
    public void setFlap(String flap) {
        this.flap = flap == null ? null : flap.trim();
    }

    /**
     * 获取主起落架 是否启用（T/F）
     *
     * @return main_landing_gear - 主起落架 是否启用（T/F）
     */
    public String getMainLandingGear() {
        return mainLandingGear;
    }

    /**
     * 设置主起落架 是否启用（T/F）
     *
     * @param mainLandingGear 主起落架 是否启用（T/F）
     */
    public void setMainLandingGear(String mainLandingGear) {
        this.mainLandingGear = mainLandingGear == null ? null : mainLandingGear.trim();
    }

    /**
     * 获取前起落架 是否启用（T/F）
     *
     * @return nose_landing_gear - 前起落架 是否启用（T/F）
     */
    public String getNoseLandingGear() {
        return noseLandingGear;
    }

    /**
     * 设置前起落架 是否启用（T/F）
     *
     * @param noseLandingGear 前起落架 是否启用（T/F）
     */
    public void setNoseLandingGear(String noseLandingGear) {
        this.noseLandingGear = noseLandingGear == null ? null : noseLandingGear.trim();
    }

    /**
     * 获取机翼面积
     *
     * @return wing_area - 机翼面积
     */
    public String getWingArea() {
        return wingArea;
    }

    /**
     * 设置机翼面积
     *
     * @param wingArea 机翼面积
     */
    public void setWingArea(String wingArea) {
        this.wingArea = wingArea == null ? null : wingArea.trim();
    }

    /**
     * 获取机翼展长
     *
     * @return wing_span - 机翼展长
     */
    public String getWingSpan() {
        return wingSpan;
    }

    /**
     * 设置机翼展长
     *
     * @param wingSpan 机翼展长
     */
    public void setWingSpan(String wingSpan) {
        this.wingSpan = wingSpan == null ? null : wingSpan.trim();
    }

    /**
     * 获取水平尾翼面积
     *
     * @return horizontal_tail_area - 水平尾翼面积
     */
    public String getHorizontalTailArea() {
        return horizontalTailArea;
    }

    /**
     * 设置水平尾翼面积
     *
     * @param horizontalTailArea 水平尾翼面积
     */
    public void setHorizontalTailArea(String horizontalTailArea) {
        this.horizontalTailArea = horizontalTailArea == null ? null : horizontalTailArea.trim();
    }

    /**
     * 获取水平尾翼展长
     *
     * @return horizontal_tail_span - 水平尾翼展长
     */
    public String getHorizontalTailSpan() {
        return horizontalTailSpan;
    }

    /**
     * 设置水平尾翼展长
     *
     * @param horizontalTailSpan 水平尾翼展长
     */
    public void setHorizontalTailSpan(String horizontalTailSpan) {
        this.horizontalTailSpan = horizontalTailSpan == null ? null : horizontalTailSpan.trim();
    }

    /**
     * 获取垂直尾翼面积
     *
     * @return vertical_tail_area - 垂直尾翼面积
     */
    public String getVerticalTailArea() {
        return verticalTailArea;
    }

    /**
     * 设置垂直尾翼面积
     *
     * @param verticalTailArea 垂直尾翼面积
     */
    public void setVerticalTailArea(String verticalTailArea) {
        this.verticalTailArea = verticalTailArea == null ? null : verticalTailArea.trim();
    }

    /**
     * 获取垂直尾翼展长
     *
     * @return vertical_tail_span - 垂直尾翼展长
     */
    public String getVerticalTailSpan() {
        return verticalTailSpan;
    }

    /**
     * 设置垂直尾翼展长
     *
     * @param verticalTailSpan 垂直尾翼展长
     */
    public void setVerticalTailSpan(String verticalTailSpan) {
        this.verticalTailSpan = verticalTailSpan == null ? null : verticalTailSpan.trim();
    }

    /**
     * 获取襟翼面积
     *
     * @return flap_area - 襟翼面积
     */
    public String getFlapArea() {
        return flapArea;
    }

    /**
     * 设置襟翼面积
     *
     * @param flapArea 襟翼面积
     */
    public void setFlapArea(String flapArea) {
        this.flapArea = flapArea == null ? null : flapArea.trim();
    }

    /**
     * 获取襟翼展长
     *
     * @return flap_span - 襟翼展长
     */
    public String getFlapSpan() {
        return flapSpan;
    }

    /**
     * 设置襟翼展长
     *
     * @param flapSpan 襟翼展长
     */
    public void setFlapSpan(String flapSpan) {
        this.flapSpan = flapSpan == null ? null : flapSpan.trim();
    }

    /**
     * 获取襟翼偏转角度
     *
     * @return flap_deflection_angle - 襟翼偏转角度
     */
    public String getFlapDeflectionAngle() {
        return flapDeflectionAngle;
    }

    /**
     * 设置襟翼偏转角度
     *
     * @param flapDeflectionAngle 襟翼偏转角度
     */
    public void setFlapDeflectionAngle(String flapDeflectionAngle) {
        this.flapDeflectionAngle = flapDeflectionAngle == null ? null : flapDeflectionAngle.trim();
    }

    /**
     * 获取主起落架数量
     *
     * @return number_of_main_landing_gears - 主起落架数量
     */
    public Integer getNumberOfMainLandingGears() {
        return numberOfMainLandingGears;
    }

    /**
     * 设置主起落架数量
     *
     * @param numberOfMainLandingGears 主起落架数量
     */
    public void setNumberOfMainLandingGears(Integer numberOfMainLandingGears) {
        this.numberOfMainLandingGears = numberOfMainLandingGears;
    }

    /**
     * 获取主起落架每侧轮数
     *
     * @return number_of_wheels_per_main_landing_gear - 主起落架每侧轮数
     */
    public Integer getNumberOfWheelsPerMainLandingGear() {
        return numberOfWheelsPerMainLandingGear;
    }

    /**
     * 设置主起落架每侧轮数
     *
     * @param numberOfWheelsPerMainLandingGear 主起落架每侧轮数
     */
    public void setNumberOfWheelsPerMainLandingGear(Integer numberOfWheelsPerMainLandingGear) {
        this.numberOfWheelsPerMainLandingGear = numberOfWheelsPerMainLandingGear;
    }

    /**
     * 获取主起落架轮直径
     *
     * @return main_landing_gear_wheel_diameter - 主起落架轮直径
     */
    public String getMainLandingGearWheelDiameter() {
        return mainLandingGearWheelDiameter;
    }

    /**
     * 设置主起落架轮直径
     *
     * @param mainLandingGearWheelDiameter 主起落架轮直径
     */
    public void setMainLandingGearWheelDiameter(String mainLandingGearWheelDiameter) {
        this.mainLandingGearWheelDiameter = mainLandingGearWheelDiameter == null ? null : mainLandingGearWheelDiameter.trim();
    }

    /**
     * 获取主起落架支柱长度
     *
     * @return main_landing_gear_strut_length - 主起落架支柱长度
     */
    public String getMainLandingGearStrutLength() {
        return mainLandingGearStrutLength;
    }

    /**
     * 设置主起落架支柱长度
     *
     * @param mainLandingGearStrutLength 主起落架支柱长度
     */
    public void setMainLandingGearStrutLength(String mainLandingGearStrutLength) {
        this.mainLandingGearStrutLength = mainLandingGearStrutLength == null ? null : mainLandingGearStrutLength.trim();
    }

    /**
     * 获取前起落架数量
     *
     * @return number_of_nose_landing_gears - 前起落架数量
     */
    public Integer getNumberOfNoseLandingGears() {
        return numberOfNoseLandingGears;
    }

    /**
     * 设置前起落架数量
     *
     * @param numberOfNoseLandingGears 前起落架数量
     */
    public void setNumberOfNoseLandingGears(Integer numberOfNoseLandingGears) {
        this.numberOfNoseLandingGears = numberOfNoseLandingGears;
    }

    /**
     * 获取前起落架每侧轮数
     *
     * @return number_of_wheels_per_nose_landing_gear - 前起落架每侧轮数
     */
    public Integer getNumberOfWheelsPerNoseLandingGear() {
        return numberOfWheelsPerNoseLandingGear;
    }

    /**
     * 设置前起落架每侧轮数
     *
     * @param numberOfWheelsPerNoseLandingGear 前起落架每侧轮数
     */
    public void setNumberOfWheelsPerNoseLandingGear(Integer numberOfWheelsPerNoseLandingGear) {
        this.numberOfWheelsPerNoseLandingGear = numberOfWheelsPerNoseLandingGear;
    }

    /**
     * 获取前起落架轮直径
     *
     * @return nose_landing_gear_wheel_diameter - 前起落架轮直径
     */
    public String getNoseLandingGearWheelDiameter() {
        return noseLandingGearWheelDiameter;
    }

    /**
     * 设置前起落架轮直径
     *
     * @param noseLandingGearWheelDiameter 前起落架轮直径
     */
    public void setNoseLandingGearWheelDiameter(String noseLandingGearWheelDiameter) {
        this.noseLandingGearWheelDiameter = noseLandingGearWheelDiameter == null ? null : noseLandingGearWheelDiameter.trim();
    }

    /**
     * 获取前起落架支柱长度
     *
     * @return nose_landing_gear_strut_length - 前起落架支柱长度
     */
    public String getNoseLandingGearStrutLength() {
        return noseLandingGearStrutLength;
    }

    /**
     * 设置前起落架支柱长度
     *
     * @param noseLandingGearStrutLength 前起落架支柱长度
     */
    public void setNoseLandingGearStrutLength(String noseLandingGearStrutLength) {
        this.noseLandingGearStrutLength = noseLandingGearStrutLength == null ? null : noseLandingGearStrutLength.trim();
    }

    /**
     * 获取是否启用（T/F）
     *
     * @return conventional_transport_aircraft - 是否启用（T/F）
     */
    public String getConventionalTransportAircraft() {
        return conventionalTransportAircraft;
    }

    /**
     * 设置是否启用（T/F）
     *
     * @param conventionalTransportAircraft 是否启用（T/F）
     */
    public void setConventionalTransportAircraft(String conventionalTransportAircraft) {
        this.conventionalTransportAircraft = conventionalTransportAircraft == null ? null : conventionalTransportAircraft.trim();
    }

    /**
     * 获取是否启用（T/F）
     *
     * @return aerodynamically_clean - 是否启用（T/F）
     */
    public String getAerodynamicallyClean() {
        return aerodynamicallyClean;
    }

    /**
     * 设置是否启用（T/F）
     *
     * @param aerodynamicallyClean 是否启用（T/F）
     */
    public void setAerodynamicallyClean(String aerodynamicallyClean) {
        this.aerodynamicallyClean = aerodynamicallyClean == null ? null : aerodynamicallyClean.trim();
    }

    /**
     * 获取当前选中项指示
     *
     * @return selected_configs - 当前选中项指示
     */
    public String getSelectedConfigs() {
        return selectedConfigs;
    }

    /**
     * 设置当前选中项指示
     *
     * @param selectedConfigs 当前选中项指示
     */
    public void setSelectedConfigs(String selectedConfigs) {
        this.selectedConfigs = selectedConfigs == null ? null : selectedConfigs.trim();
    }

    /**
     * 获取是否启用（T/F）
     *
     * @return delta_wing - 是否启用（T/F）
     */
    public String getDeltaWing() {
        return deltaWing;
    }

    /**
     * 设置是否启用（T/F）
     *
     * @param deltaWing 是否启用（T/F）
     */
    public void setDeltaWing(String deltaWing) {
        this.deltaWing = deltaWing == null ? null : deltaWing.trim();
    }

    /**
     * 获取是否启用（T/F）
     *
     * @return rectangular_wing - 是否启用（T/F）
     */
    public String getRectangularWing() {
        return rectangularWing;
    }

    /**
     * 设置是否启用（T/F）
     *
     * @param rectangularWing 是否启用（T/F）
     */
    public void setRectangularWing(String rectangularWing) {
        this.rectangularWing = rectangularWing == null ? null : rectangularWing.trim();
    }

    /**
     * 获取当前选中项指示
     *
     * @return selected_wing - 当前选中项指示
     */
    public String getSelectedWing() {
        return selectedWing;
    }

    /**
     * 设置当前选中项指示
     *
     * @param selectedWing 当前选中项指示
     */
    public void setSelectedWing(String selectedWing) {
        this.selectedWing = selectedWing == null ? null : selectedWing.trim();
    }

    /**
     * 获取是否启用（T/F）
     *
     * @return triple_slotted_flaps - 是否启用（T/F）
     */
    public String getTripleSlottedFlaps() {
        return tripleSlottedFlaps;
    }

    /**
     * 设置是否启用（T/F）
     *
     * @param tripleSlottedFlaps 是否启用（T/F）
     */
    public void setTripleSlottedFlaps(String tripleSlottedFlaps) {
        this.tripleSlottedFlaps = tripleSlottedFlaps == null ? null : tripleSlottedFlaps.trim();
    }

    /**
     * 获取是否启用（T/F）
     *
     * @return single_or_double_slotted_flaps - 是否启用（T/F）
     */
    public String getSingleOrDoubleSlottedFlaps() {
        return singleOrDoubleSlottedFlaps;
    }

    /**
     * 设置是否启用（T/F）
     *
     * @param singleOrDoubleSlottedFlaps 是否启用（T/F）
     */
    public void setSingleOrDoubleSlottedFlaps(String singleOrDoubleSlottedFlaps) {
        this.singleOrDoubleSlottedFlaps = singleOrDoubleSlottedFlaps == null ? null : singleOrDoubleSlottedFlaps.trim();
    }

    /**
     * 获取当前选中项指示
     *
     * @return selected_flaps - 当前选中项指示
     */
    public String getSelectedFlaps() {
        return selectedFlaps;
    }

    /**
     * 设置当前选中项指示
     *
     * @param selectedFlaps 当前选中项指示
     */
    public void setSelectedFlaps(String selectedFlaps) {
        this.selectedFlaps = selectedFlaps == null ? null : selectedFlaps.trim();
    }

    /**
     * 获取声速
     *
     * @return a - 声速
     */
    public String getA() {
        return a;
    }

    /**
     * 设置声速
     *
     * @param a 声速
     */
    public void setA(String a) {
        this.a = a == null ? null : a.trim();
    }

    /**
     * 获取马赫数
     *
     * @return ma - 马赫数
     */
    public String getMa() {
        return ma;
    }

    /**
     * 设置马赫数
     *
     * @param ma 马赫数
     */
    public void setMa(String ma) {
        this.ma = ma == null ? null : ma.trim();
    }

    /**
     * 获取空气密度
     *
     * @return density - 空气密度
     */
    public String getDensity() {
        return density;
    }

    /**
     * 设置空气密度
     *
     * @param density 空气密度
     */
    public void setDensity(String density) {
        this.density = density == null ? null : density.trim();
    }

    /**
     * 获取动力黏度
     *
     * @return dynamic_viscosity - 动力黏度
     */
    public String getDynamicViscosity() {
        return dynamicViscosity;
    }

    /**
     * 设置动力黏度
     *
     * @param dynamicViscosity 动力黏度
     */
    public void setDynamicViscosity(String dynamicViscosity) {
        this.dynamicViscosity = dynamicViscosity == null ? null : dynamicViscosity.trim();
    }

    /**
     * 获取是否启用（T/F）
     *
     * @return fink - 是否启用（T/F）
     */
    public String getFink() {
        return fink;
    }

    /**
     * 设置是否启用（T/F）
     *
     * @param fink 是否启用（T/F）
     */
    public void setFink(String fink) {
        this.fink = fink == null ? null : fink.trim();
    }

    /**
     * 获取是否启用（T/F）
     *
     * @return esdu - 是否启用（T/F）
     */
    public String getEsdu() {
        return esdu;
    }

    /**
     * 设置是否启用（T/F）
     *
     * @param esdu 是否启用（T/F）
     */
    public void setEsdu(String esdu) {
        this.esdu = esdu == null ? null : esdu.trim();
    }

    /**
     * 获取当前选中项指示
     *
     * @return selected - 当前选中项指示
     */
    public String getSelected() {
        return selected;
    }

    /**
     * 设置当前选中项指示
     *
     * @param selected 当前选中项指示
     */
    public void setSelected(String selected) {
        this.selected = selected == null ? null : selected.trim();
    }

    /**
     * 获取起始频率(Hz)
     *
     * @return starting_fre - 起始频率(Hz)
     */
    public String getStartingFre() {
        return startingFre;
    }

    /**
     * 设置起始频率(Hz)
     *
     * @param startingFre 起始频率(Hz)
     */
    public void setStartingFre(String startingFre) {
        this.startingFre = startingFre == null ? null : startingFre.trim();
    }

    /**
     * 获取截止频率(Hz)
     *
     * @return cutoff_fre - 截止频率(Hz)
     */
    public String getCutoffFre() {
        return cutoffFre;
    }

    /**
     * 设置截止频率(Hz)
     *
     * @param cutoffFre 截止频率(Hz)
     */
    public void setCutoffFre(String cutoffFre) {
        this.cutoffFre = cutoffFre == null ? null : cutoffFre.trim();
    }

    /**
     * 获取麦克风数量
     *
     * @return num - 麦克风数量
     */
    public Integer getNum() {
        return num;
    }

    /**
     * 设置麦克风数量
     *
     * @param num 麦克风数量
     */
    public void setNum(Integer num) {
        this.num = num;
    }

    /**
     * 获取各麦克风距离
     *
     * @return distances - 各麦克风距离
     */
    public String getDistances() {
        return distances;
    }

    /**
     * 设置各麦克风距离
     *
     * @param distances 各麦克风距离
     */
    public void setDistances(String distances) {
        this.distances = distances == null ? null : distances.trim();
    }

    /**
     * 获取极角
     *
     * @return polar_emission_angle - 极角
     */
    public String getPolarEmissionAngle() {
        return polarEmissionAngle;
    }

    /**
     * 设置极角
     *
     * @param polarEmissionAngle 极角
     */
    public void setPolarEmissionAngle(String polarEmissionAngle) {
        this.polarEmissionAngle = polarEmissionAngle == null ? null : polarEmissionAngle.trim();
    }

    /**
     * 获取方位角
     *
     * @return azimuthal_angle - 方位角
     */
    public String getAzimuthalAngle() {
        return azimuthalAngle;
    }

    /**
     * 设置方位角
     *
     * @param azimuthalAngle 方位角
     */
    public void setAzimuthalAngle(String azimuthalAngle) {
        this.azimuthalAngle = azimuthalAngle == null ? null : azimuthalAngle.trim();
    }

    /**
     * 获取频率
     *
     * @return frequency - 频率
     */
    public String getFrequency() {
        return frequency;
    }

    /**
     * 设置频率
     *
     * @param frequency 频率
     */
    public void setFrequency(String frequency) {
        this.frequency = frequency == null ? null : frequency.trim();
    }

    /**
     * 获取不同观测点对应的各频率的声压级
     *
     * @return componentspl - 不同观测点对应的各频率的声压级
     */
    public String getComponentspl() {
        return componentspl;
    }

    /**
     * 设置不同观测点对应的各频率的声压级
     *
     * @param componentspl 不同观测点对应的各频率的声压级
     */
    public void setComponentspl(String componentspl) {
        this.componentspl = componentspl == null ? null : componentspl.trim();
    }

    /**
     * 获取不同观测点的总声压
     *
     * @return oaspl - 不同观测点的总声压
     */
    public String getOaspl() {
        return oaspl;
    }

    /**
     * 设置不同观测点的总声压
     *
     * @param oaspl 不同观测点的总声压
     */
    public void setOaspl(String oaspl) {
        this.oaspl = oaspl == null ? null : oaspl.trim();
    }
}