using DataEntity;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.ComponentModel;
using System.Collections.ObjectModel;

namespace XImagingXhandler.XDAL
{
    /// <summary>
    /// ºÄ²ÄʵÌåÀà
    /// </summary>
    [SugarTable("labware")]
    public class Labware:IEntity
    {
        private string _labware_id { get; set; } = "";
        /// <summary>
        /// ºÄ²ÄId
        /// </summary>
        [SugarColumn(ColumnName = "labware_id", IsPrimaryKey = true)]
        [Description("ºÄ²ÄId")]
        public string labware_id
        {
            get { return _labware_id; }
            set
            {
                if (labware_id == value) return; // ±ÜÃâÖظ´ÉèÖÃÏàͬµÄÖµ
                _labware_id = value;
                OnPropertyChanged(nameof(labware_id));
            }
        }

        private string _labware_name = "";
        /// <summary>
        /// ºÄ²ÄÃû³Æ
        /// </summary>
        [SugarColumn(ColumnName = "labware_name")]
        [Description("ºÄ²ÄÃû³Æ")]
        public string labware_name 
        {
            get { return _labware_name; }
            set
            {
                if (labware_name == value) return;
                _labware_name = value;
                OnPropertyChanged(nameof(labware_name));
            }
        }

        /// <summary>
        /// ºÄ²ÄÔŲ́ÃæÉϵÄÃû³Æ
        /// </summary>
        [SugarColumn(IsIgnore = true,IsOnlyIgnoreInsert =true,IsOnlyIgnoreUpdate =true)]
        [Description("ºÄ²ÄÔŲ́ÃæÉϵÄÃû³Æ")]
        public string labware_sname { get; set; }

        /// <summary>
        /// ºÄ²ÄµÄbarcode
        /// </summary>
        [SugarColumn(IsIgnore = true, IsOnlyIgnoreInsert = true, IsOnlyIgnoreUpdate = true)]
        [Description("ºÄ²ÄµÄbarcode")]
        public string labware_barcode { get; set; } = "";

        private string _brand = "";
        /// <summary>
        /// ºÄ²ÄÆ·ÅÆ
        /// </summary>
        [SugarColumn(ColumnName = "brand")]
        [Description("ºÄ²ÄÆ·ÅÆ")]
        public string brand
        {
            get { return _brand; }
            set
            {
                if (brand == value) return; 
                _brand = value;
                OnPropertyChanged(nameof(brand));
            }
        }

        private string _number = "";
        /// <summary>
        /// ºÄ²Ä±àºÅ
        /// </summary>
        [SugarColumn(ColumnName = "number")]
        [Description("ºÄ²Ä±àºÅ")]
        public string number
        {
            get { return _number; }
            set
            {
                if (number == value) return;
                _number = value;
                OnPropertyChanged(nameof(number));
            }
        }
        
        private string _labware_type { get; set; }
        /// <summary>
        /// ºÄ²ÄÀàÐÍÃû³Æ
        /// </summary>
        [SugarColumn(ColumnName = "labware_type")]
        [Description("ºÄ²ÄÀàÐÍÃû³Æ")]
        public string labware_type
        {
            get { return _labware_type; }
            set
            {
                if (labware_type == value) return; 
                _labware_type = value;
                OnPropertyChanged(nameof(labware_type));
            }
        }

        private string _labware_type_id { get; set; }
        /// <summary>
        /// ºÄ²ÄÀàÐÍId
        /// </summary>
        [SugarColumn(ColumnName = "labware_type_id")]
        [Description("ºÄ²ÄÀàÐÍId")]
        public string labware_type_id
        {
            get { return _labware_type_id; }
            set
            {
                if (labware_type_id == value) return;
                _labware_type_id = value;
                OnPropertyChanged(nameof(labware_type_id));
            }
        }

        private string _labware_well_id { get; set; } = "0";
        /// <summary>
        /// ¿×ÊýÁ¿ÀàÐÍId
        /// </summary>
        [SugarColumn(ColumnName = "labware_well_id")]
        [Description("¿×ÊýÁ¿ÀàÐÍId")]
        public string labware_well_id
        {
            get { return _labware_well_id; }
            set
            {
                if (labware_well_id == value) return;
                _labware_well_id = value;
                OnPropertyChanged(nameof(labware_well_id));
            }
        }

        private string _content = "";
        /// <summary>
        /// ºÄ²Ä˵Ã÷±¸×¢
        /// </summary>
        [SugarColumn(ColumnName = "content")]
        [Description("ºÄ²Ä˵Ã÷±¸×¢")]
        public string content
        {
            get { return _content; }
            set
            {
                if (content == value) return;
                _content = value;
                OnPropertyChanged(nameof(content));
            }
        }

        private int _nw = 0;
        /// <summary>
        /// Î÷±±È±¿Ú
        /// </summary>
        [SugarColumn(ColumnName = "nw")]
        [Description("Î÷±±È±¿Ú")]
        public int nw
        {
            get { return _nw; }
            set
            {
                if (nw == value) return;
                _nw = value;
                OnPropertyChanged(nameof(nw));
            }
        }

        private int _sw = 0;
        /// <summary>
        /// Äϱ±È±¿Ú
        /// </summary>
        [SugarColumn(ColumnName = "sw")]
        [Description("Äϱ±È±¿Ú")]
        public int sw
        {
            get { return _sw; }
            set
            {
                if (sw == value) return;
                _sw = value;
                OnPropertyChanged(nameof(sw));
            }
        }

        private int _ne = 0;
        /// <summary>
        /// ¶«±±È±¿Ú
        /// </summary>
        [SugarColumn(ColumnName = "ne")]
        [Description("¶«±±È±¿Ú")]
        public int ne
        {
            get { return _ne; }
            set
            {
                if (ne == value) return;
                _ne = value;
                OnPropertyChanged(nameof(ne));
            }
        }

        private int _se = 0;
        /// <summary>
        /// ¶«ÄÏȱ¿Ú
        /// </summary>
        [SugarColumn(ColumnName = "se")]
        [Description("¶«ÄÏȱ¿Ú")]
        public int se
        {
            get { return _se; }
            set
            {
                if (se == value) return;
                _se = value;
                OnPropertyChanged(nameof(se));
            }
        }

        private int _number_row = 0;
        /// <summary>
        /// ºÄ²Ä×ÜÐÐÊý
        /// </summary>
        [SugarColumn(ColumnName = "number_row")]
        [Description("ºÄ²Ä×ÜÐÐÊý")]
        public int number_row
        {
            get { return _number_row; }
            set
            {
                if (number_row == value) return;
                _number_row = value;
                OnPropertyChanged(nameof(number_row));
            }
        }
        private int _number_column = 0;
        /// <summary>
        /// ºÄ²Ä×ÜÁÐÊý
        /// </summary>
        [SugarColumn(ColumnName = "number_column")]
        [Description("ºÄ²Ä×ÜÁÐÊý")]
        public int number_column
        {
            get { return _number_column; }
            set
            {
                if (number_column == value) return;
                _number_column = value;
                OnPropertyChanged(nameof(number_column));
            }
        }
        private double _labware_length = 0;
        /// <summary>
        /// ºÄ²Ä³¤¶È
        /// </summary>
        [SugarColumn(ColumnName = "labware_length")]
        [Description("ºÄ²Ä³¤¶È")]
        public double labware_length
        {
            get { return _labware_length; }
            set
            {
                if (labware_length == value) return;
                _labware_length = value;
                OnPropertyChanged(nameof(labware_length));
            }
        }
        private double _labware_width = 0;
        /// <summary>
        /// ºÄ²Ä¿í¶È
        /// </summary>
        [SugarColumn(ColumnName = "labware_width")]
        [Description("ºÄ²Ä¿í¶È")]
        public double labware_width
        {
            get { return _labware_width; }
            set
            {
                if (labware_width == value) return;
                _labware_width = value;
                OnPropertyChanged(nameof(labware_width));
            }
        }
        private double _labware_height = 0;
        /// <summary>
        /// ºÄ²Ä¸ß¶È
        /// </summary>
        [SugarColumn(ColumnName = "labware_height")]
        [Description("ºÄ²Ä¸ß¶È")]
        public double labware_height
        {
            get { return _labware_height; }
            set
            {
                if (labware_height == value) return;
                _labware_height = value;
                OnPropertyChanged(nameof(labware_height));
            }
        }

        private ObservableCollection<LabwareWellInfo> _labwareWellInfoList = null;
        /// <summary>
        /// ¿×λÖÃÊý¾Ý
        /// </summary>
        [SugarColumn(IsIgnore =true)]
        [Description("¿×λÖÃÊý¾Ý")]
        public ObservableCollection<LabwareWellInfo> labwareWellInfoList
        {
            get { return _labwareWellInfoList; }
            set
            {
                if (labwareWellInfoList == value) return; 
                _labwareWellInfoList = value;
                OnPropertyChanged(nameof(labwareWellInfoList));
            }
        }

        private double _a1_distance_x = 0;
        /// <summary>
        /// A1¿×ÖÐÐľà¶Ì±ßµÄ¾àÀ룬µ¥Î»£ººÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "a1_distance_x")]
        [Description("A1¿×ÖÐÐľà¶Ì±ßµÄ¾àÀë")]
        public double a1_distance_x
        {
            get { return _a1_distance_x; }
            set
            {
                if (a1_distance_x == value) return;
                _a1_distance_x = value;
                OnPropertyChanged(nameof(a1_distance_x));
            }
        }
        private double _a1_distance_y = 0;
        /// <summary>
        /// A1¿×ÖÐÐľ೤±ßµÄ¾àÀ룬µ¥Î»£ººÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "a1_distance_y")]
        [Description("A1¿×ÖÐÐľ೤±ßµÄ¾àÀë")]
        public double a1_distance_y
        {
            get { return _a1_distance_y; }
            set
            {
                if (a1_distance_y == value) return;
                _a1_distance_y = value;
                OnPropertyChanged(nameof(a1_distance_y));
            }
        }
        private double _a1_a2_distance = 0;
        /// <summary>
        /// ×óÓÒÏàÁÚÁ½¿×Ö®¼äµÄ¾àÀ룬µ¥Î»£ººÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "a1_a2_distance")]
        [Description("×óÓÒÏàÁÚÁ½¿×Ö®¼äµÄ¾àÀë")]
        public double a1_a2_distance
        {
            get { return _a1_a2_distance; }
            set
            {
                if (a1_a2_distance == value) return;
                _a1_a2_distance = value;
                OnPropertyChanged(nameof(a1_a2_distance));
            }
        }
        private double _a1_b1_distance = 0;
        /// <summary>
        /// ÉÏÏÂÏàÁÚÁ½¿×Ö®¼äµÄ¾àÀ룬µ¥Î»£ººÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "a1_b1_distance")]
        [Description("ÉÏÏÂÏàÁÚÁ½¿×Ö®¼äµÄ¾àÀë")]
        public double a1_b1_distance
        {
            get { return _a1_b1_distance; }
            set
            {
                if (a1_b1_distance == value) return;
                _a1_b1_distance = value;
                OnPropertyChanged(nameof(a1_b1_distance));
            }
        }
        private double _well_maximum_volume = 0;
        /// <summary>
        /// ¿××î´óÌå»ý£¬µ¥Î»£ºÎ¢Éý£¨¦Ìl£©
        /// </summary>
        [SugarColumn(ColumnName = "well_maximum_volume")]
        [Description("¿××î´óÌå»ý")]
        public double well_maximum_volume
        {
            get { return _well_maximum_volume; }
            set
            {
                if (well_maximum_volume == value) return;
                _well_maximum_volume = value;
                OnPropertyChanged(nameof(well_maximum_volume));
            }
        }
        private double _well_available_volume = 0;
        /// <summary>
        /// ¿×¿ÉÓÃÌå»ý£¬µ¥Î»£ºÎ¢Éý£¨¦Ìl£©
        /// </summary>
        [SugarColumn(ColumnName = "well_available_volume")]
        [Description("¿×¿ÉÓÃÌå»ý")]
        public double well_available_volume
        {
            get { return _well_available_volume; }
            set
            {
                if (well_available_volume == value) return;
                _well_available_volume = value;
                OnPropertyChanged(nameof(well_available_volume));
            }
        }
        private string _well_mix_points = "";
        /// <summary>
        /// ÿ¿×»ìºÏµÄµãλÐÅÏ¢Êý¾Ý¼¯ºÏ£¬·ÖºÅ·Ö¸î£»Èç90,1;0,1
        /// </summary>
        [SugarColumn(ColumnName = "well_mix_points")]
        [Description("ÿ¿×»ìºÏµÄµãλÐÅÏ¢Êý¾Ý¼¯ºÏ")]
        public string well_mix_points
        {
            get { return _well_mix_points; }
            set
            {
                if (well_mix_points == value) return;
                _well_mix_points = value;
                OnPropertyChanged(nameof(well_mix_points));
            }
        }
        private double _well_depth = 0;
        /// <summary>
        /// ¿×Éî¶È£¬µ¥Î»£ººÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "well_depth")]
        [Description("¿×Éî¶È")]
        public double well_depth
        {
            get { return _well_depth; }
            set
            {
                if (well_depth == value) return;
                _well_depth = value;
                OnPropertyChanged(nameof(well_depth));
            }
        }
        private int _well_shape = 0;
        /// <summary>
        /// ¿×¶´ÐÎ×´£¬1:Ô²ÖùÌ壻2£ºÁ¢·½Ìå
        /// </summary>
        [SugarColumn(ColumnName = "well_shape")]
        [Description("¿×¶´ÐÎ×´")]
        public int well_shape
        {
            get { return _well_shape; }
            set
            {
                if (well_shape == value) return;
                _well_shape = value;
                OnPropertyChanged(nameof(well_shape));
            }
        }
        private double _well_mouth_radius = 0;
        /// <summary>
        /// µ±ÐÎ״ΪԲÖùÌåʱ£¬¿×¿ÚÓа뾶ֵ£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "well_mouth_radius")]
        [Description("¿×¿ÚÐÎ״ΪԲʱ,°ë¾¶Öµ")]
        public double well_mouth_radius
        {
            get { return _well_mouth_radius; }
            set
            {
                if (well_mouth_radius == value) return;
                _well_mouth_radius = value;
                OnPropertyChanged(nameof(well_mouth_radius));
            }
        }
        private double _well_bottom_randius = 0;
        /// <summary>
        /// µ±ÐÎ״ΪԲÖùÌåʱ£¬¿×±Ûµ×²¿¿ÚÓа뾶ֵ£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "well_bottom_randius")]
        [Description("¿×µ×ÐÎ״ΪԲʱ,°ë¾¶Öµ")]
        public double well_bottom_randius
        {
            get { return _well_bottom_randius; }
            set
            {
                if (well_bottom_randius == value) return;
                _well_bottom_randius = value;
                OnPropertyChanged(nameof(well_bottom_randius));
            }
        }
        private double _well_height = 0;
        /// <summary>
        /// µ±ÐÎ״ΪԲÖùÌåʱ£¬¿×±ÛµÄ¸ß¶ÈÖµ£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "well_height")]
        [Description("¿×ÐÎ״ΪԲÖùʱ,¿×Äڸ߶ÈÖµ")]
        public double well_height
        {
            get { return _well_height; }
            set
            {
                if (well_height == value) return;
                _well_height = value;
                OnPropertyChanged(nameof(well_height));
            }
        }
        private double _well_top_x = 0;
        /// <summary>
        /// ¿×¶¥²¿ÉÏÃæºáÏò¿í¶ÈÖµ£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "well_top_x")]
        [Description("¿×¶¥²¿ÉÏÃæºáÏò¿í¶ÈÖµ")]
        public double well_top_x
        {
            get { return _well_top_x; }
            set
            {
                if (well_top_x == value) return;
                _well_top_x = value;
                OnPropertyChanged(nameof(well_top_x));
            }
        }
        private double _well_top_y = 0;
        /// <summary>
        /// ¿×¶¥²¿ÉÏÃæ×ÝÏò¿í¶ÈÖµ£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "well_top_y")]
        [Description("¿×¶¥²¿ÉÏÃæ×ÝÏò¿í¶ÈÖµ")]
        public double well_top_y
        {
            get { return _well_top_y; }
            set
            {
                if (well_top_y == value) return;
                _well_top_y = value;
                OnPropertyChanged(nameof(well_top_y));
            }
        }
        private double _well_down_x = 0;
        /// <summary>
        /// ¿×¶¥²¿ÏÂÃæºáÏò¿í¶ÈÖµ£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "well_down_x")]
        [Description("¿×¶¥²¿ÏÂÃæºáÏò¿í¶ÈÖµ")]
        public double well_down_x
        {
            get { return _well_down_x; }
            set
            {
                if (well_down_x == value) return;
                _well_down_x = value;
                OnPropertyChanged(nameof(well_down_x));
            }
        }
        private double _well_down_y = 0;
        /// <summary>
        /// ¿×¶¥²¿ÏÂÃæ×ÝÏò¿í¶ÈÖµ£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "well_down_y")]
        [Description("¿×¶¥²¿ÏÂÃæ×ÝÏò¿í¶ÈÖµ")]
        public double well_down_y
        {
            get { return _well_down_y; }
            set
            {
                if (well_down_y == value) return;
                _well_down_y = value;
                OnPropertyChanged(nameof(well_down_y));
            }
        }
        private int _well_bottom_shape = 0;
        /// <summary>
        /// ¿×µ×²¿ÐÎ×´£¬1.׶ÐΣ»2.Ô²ÐΣ»3£ºÆ½µ×
        /// </summary>
        [SugarColumn(ColumnName = "well_bottom_shape")]
        [Description("¿×µ×²¿ÐÎ×´")]
        public int well_bottom_shape
        {
            get { return _well_bottom_shape; }
            set
            {
                if (well_bottom_shape == value) return;
                _well_bottom_shape = value;
                OnPropertyChanged(nameof(well_bottom_shape));
            }
        }
        private double _well_bottom_height = 0;
        /// <summary>
        /// µ±¿×µ×²¿ÐÎ״Ϊ׶ÐΣ¬Ô²ÐÎʱ£¬µ×²¿Óи߶ÈÖµÎÞ¿í¶È³¤¶ÈÖµ£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "well_bottom_height")]
        [Description("¿×µ×²¿ÐÎ×´¸ß¶ÈÖµ")]
        public double well_bottom_height
        {
            get { return _well_bottom_height; }
            set
            {
                if (well_bottom_height == value) return;
                _well_bottom_height = value;
                OnPropertyChanged(nameof(well_bottom_height));
            }
        }
        private double _well_bottom_width = 0;
        /// <summary>
        /// µ±¿×µ×²¿ÐÎ״Ϊƽµ×ʱ£¬µ×²¿Óпí¶ÈÖµ£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "well_bottom_width")]
        [Description("¿×µ×²¿Æ½ÐÎ×´¿í¶ÈÖµ")]
        public double well_bottom_width
        {
            get { return _well_bottom_width; }
            set
            {
                if (well_bottom_width == value) return;
                _well_bottom_width = value;
                OnPropertyChanged(nameof(well_bottom_width));
            }
        }
        private double _well_bottom_length = 0;
        /// <summary>
        /// µ±¿×µ×²¿ÐÎ״Ϊƽµ×ʱ£¬µ×²¿Ó㤶ÈÖµ£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "well_bottom_length")]
        [Description("¿×µ×²¿Æ½ÐÎ×´³¤¶ÈÖµ")]
        public double well_bottom_length
        {
            get { return _well_bottom_length; }
            set
            {
                if (well_bottom_length == value) return;
                _well_bottom_length = value;
                OnPropertyChanged(nameof(well_bottom_length));
            }
        }
        private int _is_moved = 0;
        /// <summary>
        /// ÊÇ·ñ¿ÉÒƶ¯£¬1:¿ÉÒƶ¯£»0£º²»¿ÉÒƶ¯
        /// </summary>
        [SugarColumn(ColumnName = "is_moved")]
        [Description("ºÄ²ÄÊÇ·ñ¿ÉÒƶ¯")]
        public int is_moved
        {
            get { return _is_moved; }
            set
            {
                if (is_moved == value) return;
                _is_moved = value;
                OnPropertyChanged(nameof(is_moved));
            }
        }
        private double _gripper_x_offset = 0;
        /// <summary>
        /// ×¥ÊÖxÖá×ø±êÆ«ÒÆÖµ,µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "gripper_x_offset")]
        [Description("×¥ÊÖxÖá×ø±êÆ«ÒÆÖµ")]
        public double gripper_x_offset
        {
            get { return _gripper_x_offset; }
            set
            {
                if (gripper_x_offset == value) return;
                _gripper_x_offset = value;
                OnPropertyChanged(nameof(gripper_x_offset));
            }
        }
        private double _gripper_y_offset = 0;
        /// <summary>
        /// ×¥ÊÖyÖá×ø±êÆ«ÒÆÖµ,µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "gripper_y_offset")]
        [Description("×¥ÊÖyÖá×ø±êÆ«ÒÆÖµ")]
        public double gripper_y_offset
        {
            get { return _gripper_y_offset; }
            set
            {
                if (gripper_y_offset == value) return;
                _gripper_y_offset = value;
                OnPropertyChanged(nameof(gripper_y_offset));
            }
        }
        private double _gripper_z_offset = 0;
        /// <summary>
        /// ×¥ÊÖzÖá×ø±êÆ«ÒÆÖµ,µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "gripper_z_offset")]
        [Description("×¥ÊÖzÖá×ø±êÆ«ÒÆÖµ")]
        public double gripper_z_offset
        {
            get { return _gripper_z_offset; }
            set
            {
                if (gripper_z_offset == value) return;
                _gripper_z_offset = value;
                OnPropertyChanged(nameof(gripper_z_offset));
            }
        }
        private double _gripper_squeeze = 0;
        /// <summary>
        /// ×¥ÊÖÏòÄڼнôµÄ¾àÀ룬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "gripper_squeeze")]
        [Description("×¥ÊÖÏòÄڼнôµÄ¾àÀë")]
        public double gripper_squeeze
        {
            get { return _gripper_squeeze; }
            set
            {
                if (gripper_squeeze == value) return;
                _gripper_squeeze = value;
                OnPropertyChanged(nameof(gripper_squeeze));
            }
        }
        private double _gripper_power = 0;
        /// <summary>
        /// ×¥ÊÖÏäÄڼнôµÄÁ¦°Ù·Ö±È
        /// </summary>
        [SugarColumn(ColumnName = "gripper_power")]
        [Description("×¥ÊÖÏäÄڼнôµÄÁ¦°Ù·Ö±È")]
        public double gripper_power
        {
            get { return _gripper_power; }
            set
            {
                if (gripper_power == value) return;
                _gripper_power = value;
                OnPropertyChanged(nameof(gripper_power));
            }
        }
        private double _gripper_spread = 0;
        /// <summary>
        /// ×¥ÊÖÏòÍâÕÅ¿ªµÄ¾àÀ룬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "gripper_spread")]
        [Description("×¥ÊÖÏòÍâÕÅ¿ªµÄ¾àÀë")]
        public double gripper_spread
        {
            get { return _gripper_spread; }
            set
            {
                if (gripper_spread == value) return;
                _gripper_spread = value;
                OnPropertyChanged(nameof(gripper_spread));
            }
        }
        private double _gripper_speed = 0;
        /// <summary>
        /// ×¥°åµÄËٶȣ¬µ¥Î»°Ù·Ö±È
        /// </summary>
        [SugarColumn(ColumnName = "gripper_speed")]
        [Description("×¥°åµÄËÙ¶È")]
        public double gripper_speed
        {
            get { return _gripper_speed; }
            set
            {
                if (gripper_speed == value) return;
                _gripper_speed = value;
                OnPropertyChanged(nameof(gripper_speed));
            }
        }
        private double _gripper_rotational = 0;
        /// <summary>
        /// ×¥ÊÖÐýתµÄ½Ç¶È,µ¥Î»¶È
        /// </summary>
        [SugarColumn(ColumnName = "gripper_rotational")]
        [Description("×¥ÊÖÐýתµÄ½Ç¶È")]
        public double gripper_rotational
        {
            get { return _gripper_rotational; }
            set
            {
                if (gripper_rotational == value) return;
                _gripper_rotational = value;
                OnPropertyChanged(nameof(gripper_rotational));
            }
        }
        private int _is_with_lid = 0;
        /// <summary>
        /// ÊÇ·ñÓиÇ×Ó£¬1:ÓиÇ×Ó£»0£ºÎÞ¸Ç×Ó
        /// </summary>
        [SugarColumn(ColumnName = "is_with_lid")]
        [Description("ÊÇ·ñÓиÇ×Ó")]
        public int is_with_lid
        {
            get { return _is_with_lid; }
            set
            {
                if (is_with_lid == value) return;
                _is_with_lid = value;
                OnPropertyChanged(nameof(is_with_lid));
            }
        }
        private double _with_lid_height = 0;
        /// <summary>
        /// ¸Ç×ӵĺñ¶È£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "with_lid_height")]
        [Description("¸Ç×ӵĺñ¶È")]
        public double with_lid_height
        {
            get { return _with_lid_height; }
            set
            {
                if (with_lid_height == value) return;
                _with_lid_height = value;
                OnPropertyChanged(nameof(with_lid_height));
            }
        }
        private double _with_lid_pile_height = 0;
        /// <summary>
        /// ¼Ó¸Çºóµþ·ÅµÄ¸ß¶È£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "with_lid_pile_height")]
        [Description("¼Ó¸Çºóµþ·ÅµÄ¸ß¶È")]
        public double with_lid_pile_height
        {
            get { return _with_lid_pile_height; }
            set
            {
                if (with_lid_pile_height == value) return;
                _with_lid_pile_height = value;
                OnPropertyChanged(nameof(with_lid_pile_height));
            }
        }
        private double _total_without_lid_height = 0;
        /// <summary>
        /// È¡¸Ç£¬¸ÕºÃÀ뿪ʱµÄ×ܸ߶ȣ¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "total_without_lid_height")]
        [Description("¸ÕºÃÀ뿪ʱµÄ×ܸ߶È")]
        public double total_without_lid_height
        {
            get { return _total_without_lid_height; }
            set
            {
                if (total_without_lid_height == value) return;
                _total_without_lid_height = value;
                OnPropertyChanged(nameof(total_without_lid_height));
            }
        }
        private double _total_with_lid_height = 0;
        /// <summary>
        /// ·ÅÖøÇ×ÓʱµÄ×ܸ߶ȣ¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "total_with_lid_height")]
        [Description("·ÅÖøÇ×ÓʱµÄ×ܸ߶È")]
        public double total_with_lid_height
        {
            get { return _total_with_lid_height; }
            set
            {
                if (total_with_lid_height == value) return;
                _total_with_lid_height = value;
                OnPropertyChanged(nameof(total_with_lid_height));
            }
        }
        private double _gripper_lid_offset = 0;
        /// <summary>
        /// ×¥ÊÖÆ«ÒÆÁ¿,µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "gripper_lid_offset")]
        [Description("×¥ÊÖÆ«ÒÆÁ¿")]
        public double gripper_lid_offset
        {
            get { return _gripper_lid_offset; }
            set
            {
                if (gripper_lid_offset == value) return;
                _gripper_lid_offset = value;
                OnPropertyChanged(nameof(gripper_lid_offset));
            }
        }
        private int _is_piling = 0;
        /// <summary>
        /// ÊÇ·ñ¿Éµþ·Å£¬1:¿ÉÒÔµþ·Å£»0£º²»¿Éµþ·Å
        /// </summary>
        [SugarColumn(ColumnName = "is_piling")]
        [Description("ÊÇ·ñ¿Éµþ·Å")]
        public int is_piling
        {
            get { return _is_piling; }
            set
            {
                if (is_piling == value) return;
                _is_piling = value;
                OnPropertyChanged(nameof(is_piling));
            }
        }
        private int _is_piled = 0;
        /// <summary>
        /// ÊÇ·ñÄܱ»µþ·Å£¬1:Äܱ»µþ·Å£»0£º²»Äܱ»µþ·Å
        /// </summary>
        [SugarColumn(ColumnName = "is_piled")]
        [Description("ÊÇ·ñÄܱ»µþ·Å")]
        public int is_piled
        {
            get { return _is_piled; }
            set
            {
                if (is_piled == value) return;
                _is_piled = value;
                OnPropertyChanged(nameof(is_piled));
            }
        }
        private string _piled_script = "";
        /// <summary>
        /// ±»ÆäËûµþ·ÅµÄÆäÉϵĺIJÄÆ«ÒÆ×ø±ê£¬ÓÃjsonÊý×é±íʾ£¬È磺{list:[{labwereid:111,x:10,y:10,z:10},{labwereid:112,x:10,y:10,z:10}]}
        /// </summary>
        [SugarColumn(ColumnName = "piled_script")]
        [Description("±»ÆäËûµþ·ÅµÄÆäÉϵĺIJÄÆ«ÒÆ×ø±êJson")]
        public string piled_script
        {
            get { return _piled_script; }
            set
            {
                if (piled_script == value) return;
                _piled_script = value;
                OnPropertyChanged(nameof(piled_script));
            }
        }
        private int _is_pilingon = 0;
        /// <summary>
        /// ÊÇ·ñÄܵþ·Åµ½ÆäËûÉÏ£¬1£ºÄÜ£»0£º·ñ
        /// </summary>
        [SugarColumn(ColumnName = "is_pilingon")]
        [Description("ÊÇ·ñÄܵþ·Åµ½ÆäËûÉÏ")]
        public int is_pilingon
        {
            get { return _is_pilingon; }
            set
            {
                if (is_pilingon == value) return;
                _is_pilingon = value;
                OnPropertyChanged(nameof(is_pilingon));
            }
        }
        private string _pilingon_script = "";
        /// <summary>
        /// ±»µþ·Åµ½µÄÆäËûºÄ²ÄÉÏʱƫÒÆ×ø±ê£¬ÓÃjsonÊý×é±íʾ£¬È磺{list:[{labwereid:111},{labwereid:112}]}
        /// </summary>
        [SugarColumn(ColumnName = "pilingon_script")]
        [Description("±»µþ·Åµ½µÄÆäËûºÄ²ÄÉÏʱƫÒÆ×ø±êJson")]
        public string pilingon_script
        {
            get { return _pilingon_script; }
            set
            {
                if (pilingon_script == value) return;
                _pilingon_script = value;
                OnPropertyChanged(nameof(pilingon_script));
            }
        }
        private double _piled_x = 0;
        /// <summary>
        /// µþ·ÅºóµÄƫת¾àÀëx
        /// </summary>
        [SugarColumn(ColumnName = "piled_x")]
        [Description("µþ·ÅºóµÄƫת¾àÀëx")]
        public double piled_x
        {
            get { return _piled_x; }
            set
            {
                if (piled_x == value) return;
                _piled_x = value;
                OnPropertyChanged(nameof(piled_x));
            }
        }
        private double _piled_y = 0;
        /// <summary>
        /// µþ·ÅºóµÄƫת¾àÀëy
        /// </summary>
        [SugarColumn(ColumnName = "piled_y")]
        [Description("µþ·ÅºóµÄƫת¾àÀëy")]
        public double piled_y
        {
            get { return _piled_y; }
            set
            {
                if (piled_y == value) return;
                _piled_y = value;
                OnPropertyChanged(nameof(piled_y));
            }
        }
        private double _piled_height = 0;
        /// <summary>
        /// µþ·ÅµÄºóµÄµ¥²ã¸ß¶È£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "piled_height")]
        [Description("µþ·ÅµÄºóµÄµ¥²ã¸ß¶È")]
        public double piled_height
        {
            get { return _piled_height; }
            set
            {
                if (piled_height == value) return;
                _piled_height = value;
                OnPropertyChanged(nameof(piled_height));
            }
        }
        private double _piled_speed = 0;
        /// <summary>
        /// µþ·ÅËÙ¶È,µ¥Î»°Ù·Ö±È
        /// </summary>
        [SugarColumn(ColumnName = "piled_speed")]
        [Description("µþ·ÅËÙ¶È")]
        public double piled_speed
        {
            get { return _piled_speed; }
            set
            {
                if (piled_speed == value) return;
                _piled_speed = value;
                OnPropertyChanged(nameof(piled_speed));
            }
        }
        private int _is_seal = 0;
        /// <summary>
        /// ÊÇ·ñ¿ÉÃܷ⣬1:¿ÉÒÔÃܷ⣻0£º²»¿ÉÃÜ·â
        /// </summary>
        [SugarColumn(ColumnName = "is_seal")]
        [Description("ÊÇ·ñ¿ÉÃÜ·â")]
        public int is_seal
        {
            get { return _is_seal; }
            set
            {
                if (is_seal == value) return;
                _is_seal = value;
                OnPropertyChanged(nameof(is_seal));
            }
        }
        private double _sealed_height = 0;
        /// <summary>
        /// ÃÜ·âºóµÄ¸ß¶È£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "sealed_height")]
        [Description("ÃÜ·âºóµÄ¸ß¶È")]
        public double sealed_height
        {
            get { return _sealed_height; }
            set
            {
                if (sealed_height == value) return;
                _sealed_height = value;
                OnPropertyChanged(nameof(sealed_height));
            }
        }
        private double _sealed_piled_height = 0;
        /// <summary>
        /// ÃÜ·â²¢µþ·ÅµÄµ¥²ã¸ß¶È£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "sealed_piled_height")]
        [Description("ÃÜ·â²¢µþ·ÅµÄµ¥²ã¸ß¶È")]
        public double sealed_piled_height
        {
            get { return _sealed_piled_height; }
            set
            {
                if (sealed_piled_height == value) return;
                _sealed_piled_height = value;
                OnPropertyChanged(nameof(sealed_piled_height));
            }
        }
        private string _tip_name = "";
        /// <summary>
        /// ǹͷÃû³Æ
        /// </summary>
        [SugarColumn(ColumnName = "tip_name")]
        [Description("ǹͷÃû³Æ")]
        public string tip_name
        {
            get { return _tip_name; }
            set
            {
                if (tip_name == value) return;
                _tip_name = value;
                OnPropertyChanged(nameof(tip_name));
            }
        }
        private double _tip_volume_max = 0;
        /// <summary>
        /// ǹͷ×î´óÈÝÁ¿£¬µ¥Î»£ºÎ¢Éý£¨¦Ìl£©
        /// </summary>
        [SugarColumn(ColumnName = "tip_volume_max")]
        [Description("ǹͷ×î´óÈÝÁ¿")]
        public double tip_volume_max
        {
            get { return _tip_volume_max; }
            set
            {
                if (tip_volume_max == value) return;
                _tip_volume_max = value;
                OnPropertyChanged(nameof(tip_volume_max));
            }
        }
        private double _tip_use_volume_max = 0;
        /// <summary>
        /// ǹͷ¿ÉÓÃ×î´óÌå»ýÁ¿£¬µ¥Î»£ºÎ¢Éý£¨¦Ìl£©
        /// </summary>
        [SugarColumn(ColumnName = "tip_use_volume_max")]
        [Description("ǹͷ¿ÉÓÃ×î´óÌå»ýÁ¿")]
        public double tip_use_volume_max
        {
            get { return _tip_use_volume_max; }
            set
            {
                if (tip_use_volume_max == value) return;
                _tip_use_volume_max = value;
                OnPropertyChanged(nameof(tip_use_volume_max));
            }
        }
        private double _tip_air_volume = 0;
        /// <summary>
        /// ǹͷ¿ÕÆøÈÝ»ý£¨ul)
        /// </summary>
        [SugarColumn(ColumnName = "tip_air_volume")]
        [Description("ǹͷ¿ÕÆøÈÝ»ý")]
        public double tip_air_volume
        {
            get { return _tip_air_volume; }
            set
            {
                if (tip_air_volume == value) return; 
                _tip_air_volume = value;
                OnPropertyChanged(nameof(tip_air_volume));
            }
        }
        private double _tip_length = 0;
        /// <summary>
        /// ǹͷ×ܳ¤¶ÈÖµ,µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "tip_length")]
        [Description("ǹͷ×ܳ¤¶ÈÖµ")]
        public double tip_length
        {
            get { return _tip_length; }
            set
            {
                if (tip_length == value) return;
                _tip_length = value;
                OnPropertyChanged(nameof(tip_length));
            }
        }
        private double _tip_header_height = 0;
        /// <summary>
        /// ǹͷͷ²¿¸ß¶ÈÖµ,µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "tip_header_height")]
        [Description("ǹͷͷ²¿¸ß¶ÈÖµ")]
        public double tip_header_height
        {
            get { return _tip_header_height; }
            set
            {
                if (tip_header_height == value) return;
                _tip_header_height = value;
                OnPropertyChanged(nameof(tip_header_height));
            }
        }
        private double _tip_cone_height = 0;
        /// <summary>
        /// Բ׶µÄ¸ß¶ÈÖµ,µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "tip_cone_height")]
        [Description("Բ׶µÄ¸ß¶ÈÖµ")]
        public double tip_cone_height
        {
            get { return _tip_cone_height; }
            set
            {
                if (tip_cone_height == value) return;
                _tip_cone_height = value;
                OnPropertyChanged(nameof(tip_cone_height));
            }
        }
        private double _tip_cone_radius_max = 0;
        /// <summary>
        /// Բ׶²¿·Ö×î´ó°ë¾¶£¬µ¥Î»£ººÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "tip_cone_radius_max")]
        [Description("Բ׶²¿·Ö×î´ó°ë¾¶")]
        public double tip_cone_radius_max
        {
            get { return _tip_cone_radius_max; }
            set
            {
                if (tip_cone_radius_max == value) return;
                _tip_cone_radius_max = value;
                OnPropertyChanged(nameof(tip_cone_radius_max));
            }
        }
        private double _tip_cone_radius_min = 0;
        /// <summary>
        /// Բ׶²¿·Ö×îС°ë¾¶£¬µ¥Î»£ººÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "tip_cone_radius_min")]
        [Description("Բ׶²¿·Ö×îС°ë¾¶")]
        public double tip_cone_radius_min
        {
            get { return _tip_cone_radius_min; }
            set
            {
                if (tip_cone_radius_min == value) return;
                _tip_cone_radius_min = value;
                OnPropertyChanged(nameof(tip_cone_radius_min));
            }
        }
        private double _press_tip_depth = 0;
        /// <summary>
        /// ÔúǹͷÏÂѹÉî¶È£¬µ¥Î»£ººÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "press_tip_depth")]
        [Description("ÔúǹͷÏÂѹÉî¶È")]
        public double press_tip_depth
        {
            get { return _press_tip_depth; }
            set
            {
                if (press_tip_depth == value) return;
                _press_tip_depth = value;
                OnPropertyChanged(nameof(press_tip_depth));
            }
        }
        private double _press_tip_power = 0;
        /// <summary>
        /// ÏÂѹʱµÄÁ¦¾Ø°Ù·Ö±È£¬ÓÃÓÚÁ¦¾Øǹ
        /// </summary>
        [SugarColumn(ColumnName = "press_tip_power")]
        [Description("ÏÂѹʱµÄÁ¦¾Ø°Ù·Ö±È")]
        public double press_tip_power
        {
            get { return _press_tip_power; }
            set
            {
                if (press_tip_power == value) return;
                _press_tip_power = value;
                OnPropertyChanged(nameof(press_tip_power));
            }
        }

        private double _press_tipinto_depth = 0;
        /// <summary>
        /// ÔúǹͷÔúÈëµÄʵ¼ÊÉî¶È£¬µ¥Î»£ººÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "press_tipinto_depth")]
        [Description("ÔúǹͷÔúÈëµÄʵ¼ÊÉî¶È")]
        public double press_tipinto_depth
        {
            get { return _press_tipinto_depth; }
            set
            {
                if (press_tipinto_depth == value) return;
                _press_tipinto_depth = value;
                OnPropertyChanged(nameof(press_tipinto_depth));
            }
        }
        private int _quit_tip = 0;
        /// <summary>
        /// ÍËǹͷ´ÎÊý
        /// </summary>
        [SugarColumn(ColumnName = "quit_tip")]
        [Description("ÍËǹͷ´ÎÊý")]
        public int quit_tip
        {
            get { return _quit_tip; }
            set
            {
                if (quit_tip == value) return;
                _quit_tip = value;
                OnPropertyChanged(nameof(quit_tip));
            }
        }
        private int _is_filter = 0;
        /// <summary>
        /// ÊÇ·ñ´ø¹ýÂËÂËо
        /// </summary>
        [SugarColumn(ColumnName = "is_filter")]
        [Description("ÊÇ·ñ´ø¹ýÂËÂËо")]
        public int is_filter
        {
            get { return _is_filter; }
            set
            {
                if (is_filter == value) return;
                _is_filter = value;
                OnPropertyChanged(nameof(is_filter));
            }
        }
        private int _is_lls = 0;
        /// <summary>
        /// ÊÇ·ñ´øµ¼µçÐÔ
        /// </summary>
        [SugarColumn(ColumnName = "is_lls")]
        [Description("ÊÇ·ñ´øµ¼µçÐÔ")]
        public int is_lls
        {
            get { return _is_lls; }
            set
            {
                if (is_lls == value) return;
                _is_lls = value;
                OnPropertyChanged(nameof(is_lls));
            }
        }
        private string _tip_loaded_type = "";
        /// <summary>
        /// ¿É·ÅÖõÄǹͷ¹æ¸ñ£¬¶ººÅ·Ö¸î
        /// </summary>
        [SugarColumn(ColumnName = "tip_loaded_type")]
        [Description("¿É·ÅÖõÄǹͷ¹æ¸ñ")]
        public string tip_loaded_type
        {
            get { return _tip_loaded_type; }
            set
            {
                if (tip_loaded_type == value) return;
                _tip_loaded_type = value;
                OnPropertyChanged(nameof(tip_loaded_type));
            }
        }
        private int _labware_status = 1;
        /// <summary>
        /// Êý¾ÝÌõĿ״̬£º1£º¿ÉÓã»0£ºÉ¾³ý
        /// </summary>
        [SugarColumn(ColumnName = "labware_status")]
        [Description("Êý¾ÝÌõĿ״̬")]
        public int labware_status
        {
            get { return _labware_status; }
            set
            {
                if (labware_status == value) return;
                _labware_status = value;
                OnPropertyChanged(nameof(labware_status));
            }
        }

        private string _labware_picture = "";
        /// <summary>
        /// ͼ±êÃû³Æ,¹Ì¶¨Â·¾¶ÏµÄͼƬÎļþÃû³Æ£¬´øºó׺
        /// </summary>
        [SugarColumn(ColumnName = "labware_picture")]
        [Description("ͼ±êÃû³Æ")]
        public string labware_picture
        {
            get { return _labware_picture; }
            set
            {
                if (labware_picture == value) return;
                _labware_picture = value;
                OnPropertyChanged(nameof(labware_picture));
            }
        }


        private string _labware_color_lside = "LightGreen";
        /// <summary>
        /// ºÄ²Äͼ±ê×ó²àÃæÑÕÉ«£¬²Ù×÷ϵͳ¹Ì¶¨ÑÕÉ«Ãû³ÆÎı¾
        /// </summary>
        [SugarColumn(ColumnName = "labware_color_lside")]
        [Description("ºÄ²Äͼ±ê×ó²àÃæÑÕÉ«")]
        public string labware_color_lside
        {
            get { return _labware_color_lside; }
            set
            {
                if (labware_color_lside == value) return;
                _labware_color_lside = value;
                OnPropertyChanged(nameof(labware_color_lside));
            }
        }

        private string _labware_color_front = "LightGreen";
        /// <summary>
        /// ºÄ²Äͼ±êǰбÃæÑÕÉ«£¬²Ù×÷ϵͳ¹Ì¶¨ÑÕÉ«Ãû³ÆÎı¾
        /// </summary>
        [SugarColumn(ColumnName = "labware_color_front")]
        [Description("ºÄ²Äͼ±êǰбÃæÑÕÉ«")]
        public string labware_color_front
        {
            get { return _labware_color_front; }
            set
            {
                if (labware_color_front == value) return;
                _labware_color_front = value;
                OnPropertyChanged(nameof(labware_color_front));
            }
        }

        private string _labware_color_top =  "LightGreen";
        /// <summary>
        /// ºÄ²Äͼ±êÕýÉÏÃæÑÕÉ«£¬²Ù×÷ϵͳ¹Ì¶¨ÑÕÉ«Ãû³ÆÎı¾, (ÓÃÓÚ±£´æÔ²ÐÎÃóµÄÑÕÉ«)
        /// </summary>
        [SugarColumn(ColumnName = "labware_color_top")]
        [Description("ºÄ²Äͼ±êÕýÉÏÃæÑÕÉ«")]
        public string labware_color_top
        {
            get { return _labware_color_top; } 
            set
            {
                if (labware_color_top == value) return;
                _labware_color_top = value;
                OnPropertyChanged(nameof(labware_color_top));
            }
        }
        
        private string _labware_color_well = "LightGreen";
        /// <summary>
        /// ºÄ²Äͼ±ê¿×λÑÕÉ«£¬²Ù×÷ϵͳ¹Ì¶¨ÑÕÉ«Ãû³ÆÎı¾
        /// </summary>
        [SugarColumn(ColumnName = "labware_color_well")]
        [Description("ºÄ²Äͼ±ê¿×λÑÕÉ«")]
        public string labware_color_well
        {
            get { return _labware_color_well; }
            set
            {
                if (labware_color_well == value) return;
                _labware_color_well = value;
                OnPropertyChanged(nameof(labware_color_well));
            }
        }

        private string _labware_color_line = "Gray";
        /// <summary>
        /// ºÄ²Äͼ±ê±ßÏßÑÕÉ«£¬²Ù×÷ϵͳ¹Ì¶¨ÑÕÉ«Ãû³ÆÎı¾
        /// </summary>
        [SugarColumn(ColumnName = "labware_color_line")]
        [Description("ºÄ²Äͼ±ê±ßÏßÑÕÉ«")]
        public string labware_color_line
        {
            get { return _labware_color_line; }
            set
            {
                if (labware_color_line == value) return;
                _labware_color_line = value;
                OnPropertyChanged(nameof(labware_color_line));
            }
        }

        private int _is_default_type = 0;
        /// <summary>
        /// ÊÇ·ñÊÇĬÈÏÀàÐÍ£º1£º ĬÈÏ£»0£º×Ô¶¨Òå
        /// </summary>
        [SugarColumn(ColumnName = "is_default_type")]
        [Description("ÊÇ·ñÊÇĬÈÏÀàÐÍ")]
        public int is_default_type
        {
            get { return _is_default_type; }
            set
            {
                if (is_default_type == value) return;
                _is_default_type = value;
                OnPropertyChanged(nameof(is_default_type));
            }
        }

        private DateTime _timestamp = System.DateTime.Now;
        /// <summary>
        /// Êý¾ÝÐиüÐÂʱ¼ä
        /// </summary>
        [SugarColumn(ColumnName = "timestamp")]
        [Description("Êý¾ÝÐиüÐÂʱ¼ä")]
        public DateTime timestamp
        {
            get { return _timestamp; }
            set
            {
                if (timestamp == value) return;
                _timestamp = value;
                OnPropertyChanged(nameof(timestamp));
            }
        }

        private int _labware_round_division = 0;
        /// <summary>
        /// Ô²ÐÎÃóºÄ²Ä·Ö³É¸ñ×ÓµÄ×ÜÊý
        /// </summary>
        [SugarColumn(ColumnName = "labware_round_division")]
        [Description("Ô²ÐÎÃóºÄ²Ä·Ö³É¸ñ×ÓµÄ×ÜÊý")]
        public int labware_round_division
        {
            get { return _labware_round_division; }
            set
            {
                if (labware_round_division == value) return;
                _labware_round_division = value;
                OnPropertyChanged(nameof(labware_round_division));
            }
        }
        private double _labware_round_diameter = 0;
        /// <summary>
        /// Ô²ÐÎÃóºÄ²ÄÖ±¾¶£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "labware_round_diameter")]
        [Description("Ô²ÐÎÃóºÄ²ÄÖ±¾¶")]
        public double labware_round_diameter
        {
            get { return _labware_round_diameter; }
            set
            {
                if (labware_round_diameter == value) return;
                _labware_round_diameter = value;
                OnPropertyChanged(nameof(labware_round_diameter));
            }
        }
        private double _labware_round_height = 0;
        /// <summary>
        /// Ô²ÐÎÃóºÄ²Ä¸ß¶È£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "labware_round_height")]
        [Description("Ô²ÐÎÃóºÄ²Ä¸ß¶È")]
        public double labware_round_height
        {
            get { return _labware_round_height; }
            set
            {
                if (labware_round_height == value) return;
                _labware_round_height = value;
                OnPropertyChanged(nameof(labware_round_height));
            }
        }
        private double _labware_round_bottom_indiameter = 0;
        /// <summary>
        /// Ô²ÐÎÃóºÄ²Äµ×²¿ÄÚ²¿Ö±¾¶£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "labware_round_bottom_indiameter")]
        [Description("Ô²ÐÎÃóºÄ²Äµ×²¿ÄÚ²¿Ö±¾¶")]
        public double labware_round_bottom_indiameter
        {
            get { return _labware_round_bottom_indiameter; }
            set
            {
                if (labware_round_bottom_indiameter == value) return;
                _labware_round_bottom_indiameter = value;
                OnPropertyChanged(nameof(labware_round_bottom_indiameter));
            }
        }
        private double _labware_round_bottom_outdiameter = 0;
        /// <summary>
        /// Ô²ÐÎÃóºÄ²Äµ×²¿Íⲿֱ¾¶£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "labware_round_bottom_outdiameter")]
        [Description("Ô²ÐÎÃóºÄ²Äµ×²¿Íⲿֱ¾¶")]
        public double labware_round_bottom_outdiameter
        {
            get { return _labware_round_bottom_outdiameter; }
            set
            {
                if (labware_round_bottom_outdiameter == value) return;
                _labware_round_bottom_outdiameter = value;
                OnPropertyChanged(nameof(labware_round_bottom_outdiameter));
            }
        }
        private double _labware_round_bottom_inheight = 0;
        /// <summary>
        /// Ô²ÐÎÃóºÄ²Äµ×²¿ÄÚ²¿¸ß¶È£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "labware_round_bottom_inheight")]
        [Description("Ô²ÐÎÃóºÄ²Äµ×²¿ÄÚ²¿¸ß¶È")]
        public double labware_round_bottom_inheight
        {
            get { return _labware_round_bottom_inheight; }
            set
            {
                if (labware_round_bottom_inheight == value) return;
                _labware_round_bottom_inheight = value;
                OnPropertyChanged(nameof(labware_round_bottom_inheight));
            }
        }
        private double _labware_round_bottom_outheight = 0;
        /// <summary>
        /// Ô²ÐÎÃóºÄ²Äµ×²¿Íⲿ¸ß¶È£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "labware_round_bottom_outheight")]
        [Description("Ô²ÐÎÃóºÄ²Äµ×²¿Íⲿ¸ß¶È")]
        public double labware_round_bottom_outheight
        {
            get { return _labware_round_bottom_outheight; }
            set
            {
                if (labware_round_bottom_outheight == value) return;
                _labware_round_bottom_outheight = value;
                OnPropertyChanged(nameof(labware_round_bottom_outheight));
            }
        }
        private double _labware_round_lid_indiameter = 0;
        /// <summary>
        /// Ô²ÐÎÃóºÄ²Ä¸Ç×ÓÄÚ²¿Ö±¾¶£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "labware_round_lid_indiameter")]
        [Description("Ô²ÐÎÃóºÄ²Ä¸Ç×ÓÄÚ²¿Ö±¾¶")]
        public double labware_round_lid_indiameter
        {
            get { return _labware_round_lid_indiameter; }
            set
            {
                if (labware_round_lid_indiameter == value) return;
                _labware_round_lid_indiameter = value;
                OnPropertyChanged(nameof(labware_round_lid_indiameter));
            }
        }
        private double _labware_round_lid_outdiameter = 0;
        /// <summary>
        /// Ô²ÐÎÃóºÄ²Ä¸Ç×ÓÍⲿֱ¾¶£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "labware_round_lid_outdiameter")]
        [Description("Ô²ÐÎÃóºÄ²Ä¸Ç×ÓÍⲿֱ¾¶")]
        public double labware_round_lid_outdiameter
        {
            get { return _labware_round_lid_outdiameter; }
            set
            {
                if (labware_round_lid_outdiameter == value) return;
                _labware_round_lid_outdiameter = value;
                OnPropertyChanged(nameof(labware_round_lid_outdiameter));
            }
        }
        private double _labware_round_lid_height = 0;
        /// <summary>
        /// Ô²ÐÎÃóºÄ²Ä¸Ç×ÓÍⲿ¸ß¶È£¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "labware_round_lid_height")]
        [Description("Ô²ÐÎÃóºÄ²Ä¸Ç×ÓÍⲿ¸ß¶È")]
        public double labware_round_lid_height
        {
            get { return _labware_round_lid_height; }
            set
            {
                if (labware_round_lid_height == value) return;
                _labware_round_lid_height = value;
                OnPropertyChanged(nameof(labware_round_lid_height));
            }
        }
        private double _labware_round_totalheight = 0;
        /// <summary>
        /// Ô²ÐÎÃóºÄ²Ä×ܸ߶ȣ¬µ¥Î»ºÁÃ×
        /// </summary>
        [SugarColumn(ColumnName = "labware_round_totalheight")]
        [Description("Ô²ÐÎÃóºÄ²Ä×ܸ߶È")]
        public double labware_round_totalheight
        {
            get { return _labware_round_totalheight; }
            set
            {
                if (labware_round_totalheight == value) return;
                _labware_round_totalheight = value;
                OnPropertyChanged(nameof(labware_round_totalheight));
            }
        }
        private double _labware_round_top_indiameter = 0;
        /// <summary>
        /// Ô²ÐÎÃóÉÏÄÚÖ±¾¶
        /// </summary>
        [SugarColumn(ColumnName = "labware_round_top_indiameter")]
        [Description("Ô²ÐÎÃóÉÏÄÚÖ±¾¶")]
        public double labware_round_top_indiameter
        {
            get { return _labware_round_top_indiameter; }
            set
            {
                if (labware_round_top_indiameter == value) return;
                _labware_round_top_indiameter = value;
                OnPropertyChanged(nameof(labware_round_top_indiameter));
            }
        }
        private double _labware_round_top_outdiameter = 0;
        /// <summary>
        /// Ô²ÐÎÃóÉÏÍâÖ±¾¶
        /// </summary>
        [SugarColumn(ColumnName = "labware_round_top_outdiameter")]
        [Description("Ô²ÐÎÃóÉÏÍâÖ±¾¶")]
        public double labware_round_top_outdiameter
        {
            get { return _labware_round_top_outdiameter; }
            set
            {
                if (labware_round_top_outdiameter == value) return;
                _labware_round_top_outdiameter = value;
                OnPropertyChanged(nameof(labware_round_top_outdiameter));
            }
        }

        private string _x = "0.0";
        /// <summary>
        /// µþ·Åƫתx
        /// </summary>
        [SugarColumn(IsIgnore = true, IsOnlyIgnoreInsert = true, IsOnlyIgnoreUpdate = true)]
        [Description("µþ·Åƫתx")]
        public string x
        {
            get { return _x; }
            set
            {
                if (x == value) return;
                _x = value;
                OnPropertyChanged(nameof(x));
            }
        }

        private string _y = "0.0";
        /// <summary>
        /// µþ·Åƫתy
        /// </summary>
        [SugarColumn(IsIgnore = true, IsOnlyIgnoreInsert = true, IsOnlyIgnoreUpdate = true)]
        [Description("µþ·Åƫתy")]
        public string y
        {
            get { return _y; }
            set
            {
                if (y == value) return;
                _y = value;
                OnPropertyChanged(nameof(y));
            }
        }
        private string _z = "0.0";
        /// <summary>
        /// µþ·Åƫתz
        /// </summary>
        [SugarColumn(IsIgnore = true, IsOnlyIgnoreInsert = true, IsOnlyIgnoreUpdate = true)]
        [Description("µþ·Åƫתz")]
        public string z
        {
            get { return _z; }
            set
            {
                if (z == value) return;
                _z = value;
                OnPropertyChanged(nameof(z));
            }
        }

        private double _lattice_pixel_x { get; set; } = 0;
        /// <summary>
        /// °åλ×óÉϽÇÔŲ́ÃæÉϵÄÏñËØ×ø±êx
        /// </summary>
        [SugarColumn(IsIgnore = true)]
        [Description("°åλ×óÉϽÇÔŲ́ÃæÉϵÄÏñËØ×ø±êx")]
        public double lattice_pixel_x
        {
            get { return _lattice_pixel_x; }
            set
            {
                if (lattice_pixel_x == value) return;
                _lattice_pixel_x = value;
                OnPropertyChanged(nameof(lattice_pixel_x));
            }
        }

        private double _lattice_pixel_y { get; set; } = 0;
        /// <summary>
        /// °åλ×óÉϽÇÔŲ́ÃæÉϵÄÏñËØ×ø±êy
        /// </summary>
        [SugarColumn(IsIgnore = true)]
        [Description("°åλ×óÉϽÇÔŲ́ÃæÉϵÄÏñËØ×ø±êy")]
        public double lattice_pixel_y
        {
            get { return _lattice_pixel_y; }
            set
            {
                if (lattice_pixel_y == value) return;
                _lattice_pixel_y = value;
                OnPropertyChanged(nameof(lattice_pixel_y));
            }
        }

        private int _labware_tubeshelf_type { get; set; } = 0;
        /// <summary>
        /// 0:ĬÈϹܼܣ»1ÒìÐιܼܣ»
        /// </summary>
        [SugarColumn(ColumnName = "labware_tubeshelf_type")]
        [Description("0:ĬÈϹܼܣ»1ÒìÐιܼܣ»")]
        public int labware_tubeshelf_type
        {
            get { return _labware_tubeshelf_type; }
            set
            {
                if (labware_tubeshelf_type == value) return;
                _labware_tubeshelf_type = value;
                OnPropertyChanged(nameof(labware_tubeshelf_type));
            }
        }

        private double _lid_height { get; set; } = 0d;
        /// <summary>
        /// ÀëÐĹܸÇ×ÓÍⲿ¸ß¶È
        /// </summary>
        [SugarColumn(ColumnName = "lid_height")]
        [Description("ÀëÐĹܸÇ×ÓÍⲿ¸ß¶È")]
        public double lid_height
        {
            get { return _lid_height; }
            set
            {
                if (lid_height == value) return;
                _lid_height = value;
                OnPropertyChanged(nameof(lid_height));
            }
        }

        private double _well_mouth_out_radius { get; set; } = 0d;
        /// <summary>
        /// ÀëÐĹÜÖ÷ÌåÔ²ÖùÍⲿ°ë¾¶
        /// </summary>
        [SugarColumn(ColumnName = "well_mouth_out_radius")]
        [Description("ÀëÐĹÜÖ÷ÌåÔ²ÖùÍⲿ°ë¾¶")]
        public double well_mouth_out_radius
        {
            get { return _well_mouth_out_radius; }
            set
            {
                if (well_mouth_out_radius == value) return;
                _well_mouth_out_radius = value;
                OnPropertyChanged(nameof(well_mouth_out_radius));
            }
        }

        private double _lid_out_radius { get; set; } = 0d;
        /// <summary>
        /// ÀëÐĹܸÇÍⲿ°ë¾¶
        /// </summary>
        [SugarColumn(ColumnName = "lid_out_radius")]
        [Description("ÀëÐĹܸÇÍⲿ°ë¾¶")]
        public double lid_out_radius
        {
            get { return _lid_out_radius; }
            set
            {
                if (lid_out_radius == value) return;
                _lid_out_radius = value;
                OnPropertyChanged(nameof(lid_out_radius));
            }
        }

        private double _lid_in_radius { get; set; } = 0d;
        /// <summary>
        /// ÀëÐĹܸÇÄÚ²¿°ë¾¶
        /// </summary>
        [SugarColumn(ColumnName = "lid_in_radius")]
        [Description("ÀëÐĹܸÇÄÚ²¿°ë¾¶")]
        public double lid_in_radius
        {
            get { return _lid_in_radius; }
            set
            {
                if (lid_in_radius == value) return;
                _lid_in_radius = value;
                OnPropertyChanged(nameof(lid_in_radius));
            }
        }

        private double _well_helical_distance { get; set; } = 0d;
        /// <summary>
        /// ÀëÐĹܿÚÂÝÎƼä¾à
        /// </summary>
        [SugarColumn(ColumnName = "well_helical_distance")]
        [Description("ÀëÐĹܿÚÂÝÎƼä¾à")]
        public double well_helical_distance
        {
            get { return _well_helical_distance; }
            set
            {
                if (well_helical_distance == value) return;
                _well_helical_distance = value;
                OnPropertyChanged(nameof(well_helical_distance));
            }
        }

        private double _well_helical_circle { get; set; } = 0d;
        /// <summary>
        /// ÀëÐĹܿÚÂÝÎÆȦÊý
        /// </summary>
        [SugarColumn(ColumnName = "well_helical_circle")]
        [Description("ÀëÐĹܿÚÂÝÎÆȦÊý")]
        public double well_helical_circle
        {
            get { return _well_helical_circle; }
            set
            {
                if (well_helical_circle == value) return;
                _well_helical_circle = value;
                OnPropertyChanged(nameof(well_helical_circle));
            }
        }

        private double _upgripper_spread { get; set; } = 0d;
        /// <summary>
        /// ¿ª¹Ø¸Ç-ÉϼÐצÕÅ¿ªµÄ¾àÀëmm
        /// </summary>
        [SugarColumn(ColumnName = "upgripper_spread")]
        [Description("¿ª¹Ø¸Ç-ÉϼÐצÕÅ¿ªµÄ¾àÀëmm")]
        public double upgripper_spread
        {
            get { return _upgripper_spread; }
            set
            {
                if (upgripper_spread == value) return;
                _upgripper_spread = value;
                OnPropertyChanged(nameof(upgripper_spread));
            }
        }

        private double _upgripper_squeeze { get; set; } = 0d;
        /// <summary>
        /// ¿ª¹Ø¸Ç-ÉϼÐצ¼Ð½ôµÄ¾àÀëmm
        /// </summary>
        [SugarColumn(ColumnName = "upgripper_squeeze")]
        [Description("¿ª¹Ø¸Ç-ÉϼÐצ¼Ð½ôµÄ¾àÀëmm")]
        public double upgripper_squeeze
        {
            get { return _upgripper_squeeze; }
            set
            {
                if (upgripper_squeeze == value) return;
                _upgripper_squeeze = value;
                OnPropertyChanged(nameof(upgripper_squeeze));
            }
        }

        private double _upgripper_power { get; set; } = 0d;
        /// <summary>
        /// ¿ª¹Ø¸Ç-ÉϼÐצ¼ÐÁ¦%
        /// </summary>
        [SugarColumn(ColumnName = "upgripper_power")]
        [Description("¿ª¹Ø¸Ç-ÉϼÐצ¼ÐÁ¦%")]
        public double upgripper_power
        {
            get { return _upgripper_power; }
            set
            {
                if (upgripper_power == value) return;
                _upgripper_power = value;
                OnPropertyChanged(nameof(upgripper_power));
            }
        }

        private double _upgripper_zoffset { get; set; } = 0d;
        /// <summary>
        /// ¿ª¹Ø¸Ç-ÉϼÐצ¹Ü¿ÚÏòϼеľàÀëmm
        /// </summary>
        [SugarColumn(ColumnName = "upgripper_zoffset")]
        [Description("¿ª¹Ø¸Ç-ÉϼÐצ¹Ü¿ÚÏòϼеľàÀëmm")]
        public double upgripper_zoffset
        {
            get { return _upgripper_zoffset; }
            set
            {
                if (upgripper_zoffset == value) return;
                _upgripper_zoffset = value;
                OnPropertyChanged(nameof(upgripper_zoffset));
            }
        }

        private double _downgripper_spread { get; set; } = 0d;
        /// <summary>
        /// ¿ª¹Ø¸Ç-ϼÐצÕÅ¿ªµÄ¾àÀëmm
        /// </summary>
        [SugarColumn(ColumnName = "downgripper_spread")]
        [Description("¿ª¹Ø¸Ç-ϼÐצÕÅ¿ªµÄ¾àÀëmm")]
        public double downgripper_spread
        {
            get { return _downgripper_spread; }
            set
            {
                if (downgripper_spread == value) return;
                _downgripper_spread = value;
                OnPropertyChanged(nameof(downgripper_spread));
            }
        }

        private double _downgripper_squeeze { get; set; } = 0d;
        /// <summary>
        /// ¿ª¹Ø¸Ç-ϼÐצ¼Ð½ôµÄ¾àÀëmm
        /// </summary>
        [SugarColumn(ColumnName = "downgripper_squeeze")]
        [Description("¿ª¹Ø¸Ç-ϼÐצ¼Ð½ôµÄ¾àÀëmm")]
        public double downgripper_squeeze
        {
            get { return _downgripper_squeeze; }
            set
            {
                if (downgripper_squeeze == value) return;
                _downgripper_squeeze = value;
                OnPropertyChanged(nameof(downgripper_squeeze));
            }
        }

        private double _downgripper_power { get; set; } = 0d;
        /// <summary>
        /// ¿ª¹Ø¸Ç-ϼÐצ¼ÐÁ¦%
        /// </summary>
        [SugarColumn(ColumnName = "downgripper_power")]
        [Description("¿ª¹Ø¸Ç-ϼÐצ¼ÐÁ¦%")]
        public double downgripper_power
        {
            get { return _downgripper_power; }
            set
            {
                if (downgripper_power == value) return;
                _downgripper_power = value;
                OnPropertyChanged(nameof(downgripper_power));
            }
        }

        private double _downgripper_zoffset { get; set; } = 0d;
        /// <summary>
        /// ¿ª¹Ø¸Ç-ϼÐצ¹Ü¿ÚÏòÉϼеľàÀëmm
        /// </summary>
        [SugarColumn(ColumnName = "downgripper_zoffset")]
        [Description("¿ª¹Ø¸Ç-ϼÐצ¹Ü¿ÚÏòÉϼеľàÀëmm")]
        public double downgripper_zoffset
        {
            get { return _downgripper_zoffset; }
            set
            {
                if (downgripper_zoffset == value) return;
                _downgripper_zoffset = value;
                OnPropertyChanged(nameof(downgripper_zoffset));
            }
        }

        /// <summary>
        /// »ñȡDZ¿½±´¶ÔÏó
        /// </summary>
        /// <returns></returns>
        public object Clone()
        {
            return (object)this.MemberwiseClone();
        }

        /// <summary>
        /// ¸´ÖƺIJÄÀà¶ÔÏó£¬ËùÓÐÊôÐÔÒÀ´Î¸³Öµ
        /// </summary>
        /// <param name="labware">ºÄ²Ä¶ÔÏó</param>
        public void Copy(Labware labware)
        {
            labware_id = labware.labware_id;
            labware_name = labware.labware_name;
            labware_barcode = labware.labware_barcode;
            brand = labware.brand;
            number = labware.number;
            labware_type = labware.labware_type;
            labware_type_id = labware.labware_type_id;
            labware_well_id = labware.labware_well_id;
            content = labware.content;
            nw = labware.nw;
            sw = labware.sw;
            ne = labware.ne;
            se = labware.se;
            number_row = labware.number_row;
            number_column = labware.number_column;
            labware_length = labware.labware_length;
            labware_width = labware.labware_width;
            labware_height = labware.labware_height;
            a1_distance_x = labware.a1_distance_x;
            a1_distance_y = labware.a1_distance_y;
            a1_a2_distance = labware.a1_a2_distance;
            a1_b1_distance = labware.a1_b1_distance;
            well_maximum_volume = labware.well_maximum_volume;
            well_available_volume = labware.well_available_volume;
            well_mix_points = labware.well_mix_points;
            well_depth = labware.well_depth;
            well_shape = labware.well_shape;
            well_mouth_radius = labware.well_mouth_radius;
            well_bottom_randius = labware.well_bottom_randius;
            well_height = labware.well_height;
            well_top_x = labware.well_top_x;
            well_top_y = labware.well_top_y;
            well_down_x = labware.well_down_x;
            well_down_y = labware.well_down_y;
            well_bottom_shape = labware.well_bottom_shape;
            well_bottom_height = labware.well_bottom_height;
            well_bottom_width = labware.well_bottom_width;
            well_bottom_length = labware.well_bottom_length;
            is_moved = labware.is_moved;
            gripper_x_offset = labware.gripper_x_offset;
            gripper_y_offset = labware.gripper_y_offset;
            gripper_z_offset = labware.gripper_z_offset;
            gripper_squeeze = labware.gripper_squeeze;
            gripper_power = labware.gripper_power;
            gripper_spread = labware.gripper_spread;
            gripper_speed = labware.gripper_speed;
            gripper_rotational = labware.gripper_rotational;
            is_with_lid = labware.is_with_lid;
            with_lid_height = labware.with_lid_height;
            with_lid_pile_height = labware.with_lid_pile_height;
            total_without_lid_height = labware.total_without_lid_height;
            total_with_lid_height = labware.total_with_lid_height;
            gripper_lid_offset = labware.gripper_lid_offset;
            is_piling = labware.is_piling;
            is_piled = labware.is_piled;
            piled_script = labware.piled_script;
            piled_height = labware.piled_height;
            piled_speed = labware.piled_speed;
            is_pilingon = labware.is_pilingon;
            pilingon_script = labware.pilingon_script;
            piled_x = labware.piled_x;
            piled_y = labware.piled_y;
            is_seal = labware.is_seal;
            sealed_height = labware.sealed_height;
            sealed_piled_height = labware.sealed_piled_height;
            tip_name = labware.tip_name;
            tip_volume_max = labware.tip_volume_max;
            tip_use_volume_max = labware.tip_use_volume_max;
            tip_air_volume = labware.tip_air_volume;
            tip_length = labware.tip_length;
            tip_header_height = labware.tip_header_height;
            tip_cone_height = labware.tip_cone_height;
            tip_cone_radius_max = labware.tip_cone_radius_max;
            tip_cone_radius_min = labware.tip_cone_radius_min;
            press_tip_power = labware.press_tip_power;
            press_tip_depth = labware.press_tip_depth;
            press_tipinto_depth = labware.press_tipinto_depth;
            quit_tip = labware.quit_tip;
            is_filter = labware.is_filter;
            is_lls = labware.is_lls;
            tip_loaded_type = labware.tip_loaded_type;
            labware_status = labware.labware_status;
            labware_picture = labware.labware_picture;
            labware_color_lside = labware.labware_color_lside;
            labware_color_front = labware.labware_color_front;
            labware_color_top = labware.labware_color_top;
            labware_color_well = labware.labware_color_well;
            labware_color_line = labware.labware_color_line;
            is_default_type = labware.is_default_type;
            timestamp = labware.timestamp;
            labware_round_division = labware.labware_round_division;
            labware_round_diameter = labware.labware_round_diameter;
            labware_round_height = labware.labware_round_height;
            labware_round_bottom_indiameter = labware.labware_round_bottom_indiameter;
            labware_round_bottom_outdiameter = labware.labware_round_bottom_outdiameter;
            labware_round_bottom_inheight = labware.labware_round_bottom_inheight;
            labware_round_bottom_outheight = labware.labware_round_bottom_outheight;
            labware_round_lid_indiameter = labware.labware_round_lid_indiameter;
            labware_round_lid_outdiameter = labware.labware_round_lid_outdiameter;
            labware_round_lid_height = labware.labware_round_lid_height;
            labware_round_totalheight = labware.labware_round_totalheight;
            labware_round_top_indiameter = labware.labware_round_top_indiameter;
            labware_round_top_outdiameter = labware.labware_round_top_outdiameter;
            lid_height = labware.lid_height;
            well_mouth_out_radius = labware.well_mouth_out_radius;
            lid_out_radius = labware.lid_out_radius;
            lid_in_radius = labware.lid_in_radius;
            well_helical_distance = labware.well_helical_distance;
            well_helical_circle = labware.well_helical_circle;
            upgripper_spread = labware.upgripper_spread;
            upgripper_squeeze = labware.upgripper_squeeze;
            upgripper_power = labware.upgripper_power;
            upgripper_zoffset = labware.upgripper_zoffset;
            downgripper_spread = labware.downgripper_spread;
            downgripper_squeeze = labware.downgripper_squeeze;
            downgripper_power = labware.downgripper_power;
            downgripper_zoffset = labware.downgripper_zoffset;

            if (labware.labware_type_id=="4")
            {
                labwareWellInfoList = labware.labwareWellInfoList;
                labware_tubeshelf_type = labware.labware_tubeshelf_type;
            }
        }
    }
}