eis/inc/dbinc/Pr.h

//-- Version:		2018.7.9  10:44:17
////////////////////////////////////////////////////////////////////////
#ifndef _Pr_H
#define _Pr_H
#include <common/BasicStruct.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

using namespace baosight;

#include "dao/MatStruct.h"

#include  "T_PDO_PH.h"
#include  "T_PDO_LO.h"
#include  "T_PDO_OR.h"
class Pr {
protected:
//
//A S S O T I A T I O N S
//=======================
//
T_PDO_PH *ptrPrPhyPro;
T_PDO_LO *ptrPrLogPro;
T_PDO_OR *ptrPrOrdPro;
public:
//
//A T T R I B U T E S
//===================
//
	bool dbAccess;
	//
	char* dbMessage;	// pointer for the return values of DBAX methodes
	char messageBuffer[200];	// temporary message buffer
//
//C O N S T R U C T O R S
//=======================
//
public:
Pr();
//
//D E S T R U C T O R 
//====================
virtual ~Pr();
//
// C O P Y   C O N S T R U C T O R 
//=================================
Pr(const Pr &inst);
//
//
// For Constructors with parameters the flag dbAccess 
// informs you if the access was successfully or not
//	Parameters of table:PrLogPro
//	muCode1
//	arg2 =  source = 所有者
//	Parameters of table:PrOrdPro
//	muCode3
//	arg4 =  source = 所有者
//	Parameters of table:PrPhyPro
//	muCode5
//	arg6 =  source = 所有者
Pr(  MU_CODE muCode1 ,const  char* arg2 , MU_CODE muCode3 ,const  char* arg4 , MU_CODE muCode5 ,const  char* arg6 );
//	muCode1
//	arg2 = source = 所有者
Pr(  MU_CODE muCode1 ,const  char* arg2 );
//
//M E T H O D E S
//===============
//
public:
//get creation time
char*  getCreationTime() {return (char*)"2018.7.9  10:44:17";};
//read data
char*  readDB();
//update data
char*  updateDB();
//insert data
char*  insertDB();
//store data
//this methode inserts DB records, when the insert fails , the methode
//tries an update of the failed record
char*  storeDB();
//delete data
char*  deleteDB();

char*  execute(const char* sql , int* count   );

char*  dbCommit();

char*  dbRollback();
//create empty objects
void   emptyObjects();
//set key attributtes for insert
void	initInsertKeys(  MU_CODE muCode1 ,const  char* arg2 , MU_CODE muCode3 ,const  char* arg4 , MU_CODE muCode5 ,const  char* arg6 );
void	initInsertKeys(  MU_CODE muCode1 ,const  char* arg2 );
//set primary keys
void	setPrimKey(  MU_CODE muCode1 ,const  char* arg2 , MU_CODE muCode3 ,const  char* arg4 , MU_CODE muCode5 ,const  char* arg6 );
void	setPrimKey(  MU_CODE muCode1 ,const  char* arg2 );
//
//O P E R A T O R  + 
//===================
//
public:
Pr operator+(const Pr &inst) const;

//
//O P E R A T O R  = 
//===================
//
public:
const Pr& operator=(const Pr &inst);

//int muId= Material idendification number
int muId_PhPr()
{
	return( ptrPrPhyPro->muId() );
}

void set_muId_PhPr(int arg  )
{
	ptrPrPhyPro->set_muId( arg  );
}

//char muCreator= Material owner
char* muCreator_PhPr()
{
	return( ptrPrPhyPro->muCreator() );
}

void set_muCreator_PhPr(const char* arg  )
{
	ptrPrPhyPro->set_muCreator( arg  );
}

//short musId= Line status
short musId_PhPr()
{
	return( ptrPrPhyPro->musId() );
}

void set_musId_PhPr(short arg  )
{
	ptrPrPhyPro->set_musId( arg  );
}


//char* toc= Time of creattion
char* toc_PhPr()
{
	return( ptrPrPhyPro->toc() );
}

short toc_PhPrZi()
{
	return( ptrPrPhyPro->tocZi() );
}

//char* tom= Time of modification
char* tom_PhPr()
{
	return( ptrPrPhyPro->tom() );
}

short tom_PhPrZi()
{
	return( ptrPrPhyPro->tomZi() );
}

//char* mop= Modification process
char* mop_PhPr()
{
	return( ptrPrPhyPro->mop() );
}

short mop_PhPrZi()
{
	return( ptrPrPhyPro->mopZi() );
}

//char* mou= Modification User
char* mou_PhPr()
{
	return( ptrPrPhyPro->mou() );
}

short mou_PhPrZi()
{
	return( ptrPrPhyPro->mouZi() );
}


//char* source = 记录状态
char* source_PhPr(){
	return( ptrPrPhyPro->source() );
}

void set_source_PhPr(const char* arg  ){
	ptrPrPhyPro->set_source( arg );
}

int EnCoilIdArraySize(){
	return(4);
}

//char* EnCoilId = 入口卷号
char* EnCoilId(int colInd){
	return( ptrPrPhyPro->EnCoilId(colInd ) );
}

void set_EnCoilId(int colInd, const char* arg  ){
	ptrPrPhyPro->set_EnCoilId(colInd , arg );
}

short EnCoilIdZi(int colInd) {
	return( ptrPrPhyPro->EnCoilIdZi(colInd ) );
}

void set_EnCoilIdZi(int colInd, short arg ){
	ptrPrPhyPro->set_EnCoilIdZi(colInd , arg );
}

//char* ExCoilId = 出口卷号
char* ExCoilId(){
	return( ptrPrPhyPro->ExCoilId() );
}

void set_ExCoilId(const char* arg  ){
	ptrPrPhyPro->set_ExCoilId( arg );
}

short ExCoilIdZi() {
	return( ptrPrPhyPro->ExCoilIdZi() );
}

void set_ExCoilIdZi(short arg ){
	ptrPrPhyPro->set_ExCoilIdZi( arg );
}


//int coilLengthX = 出口钢卷长度
int coilLengthX(){
	return( ptrPrPhyPro->coilLengthX() );
}

void set_coilLengthX(int arg  ){
	ptrPrPhyPro->set_coilLengthX( arg );
}

short coilLengthXZi() {
	return( ptrPrPhyPro->coilLengthXZi() );
}

void set_coilLengthXZi(short arg ){
	ptrPrPhyPro->set_coilLengthXZi( arg );
}


//int coilInnerDiam = 钢卷内径
int coilInnerDiam(){
	return( ptrPrPhyPro->coilInnerDiam() );
}

void set_coilInnerDiam(int arg  ){
	ptrPrPhyPro->set_coilInnerDiam( arg );
}

short coilInnerDiamZi() {
	return( ptrPrPhyPro->coilInnerDiamZi() );
}

void set_coilInnerDiamZi(short arg ){
	ptrPrPhyPro->set_coilInnerDiamZi( arg );
}


//int coilOutDiaX = 出口钢卷外径
int coilOutDiaX(){
	return( ptrPrPhyPro->coilOutDiaX() );
}

void set_coilOutDiaX(int arg  ){
	ptrPrPhyPro->set_coilOutDiaX( arg );
}

short coilOutDiaXZi() {
	return( ptrPrPhyPro->coilOutDiaXZi() );
}

void set_coilOutDiaXZi(short arg ){
	ptrPrPhyPro->set_coilOutDiaXZi( arg );
}


//char* ProdEnd = 生产结束时间
char* ProdEnd(){
	return( ptrPrPhyPro->ProdEnd() );
}

void set_ProdEnd(char* arg  ){
	ptrPrPhyPro->set_ProdEnd( arg );
}

short ProdEndZi() {
	return( ptrPrPhyPro->ProdEndZi() );
}

void set_ProdEndZi(short arg ){
	ptrPrPhyPro->set_ProdEndZi( arg );
}


//char* ProdStart = 生产开始时间
char* ProdStart(){
	return( ptrPrPhyPro->ProdStart() );
}

void set_ProdStart(char* arg  ){
	ptrPrPhyPro->set_ProdStart( arg );
}

short ProdStartZi() {
	return( ptrPrPhyPro->ProdStartZi() );
}

void set_ProdStartZi(short arg ){
	ptrPrPhyPro->set_ProdStartZi( arg );
}


//int ProdTime = 生产总时间
int ProdTime(){
	return( ptrPrPhyPro->ProdTime() );
}

void set_ProdTime(int arg  ){
	ptrPrPhyPro->set_ProdTime( arg );
}

short ProdTimeZi() {
	return( ptrPrPhyPro->ProdTimeZi() );
}

void set_ProdTimeZi(short arg ){
	ptrPrPhyPro->set_ProdTimeZi( arg );
}


//int finalSign = 最后钢卷标志
int finalSign(){
	return( ptrPrPhyPro->finalSign() );
}

void set_finalSign(int arg  ){
	ptrPrPhyPro->set_finalSign( arg );
}

short finalSignZi() {
	return( ptrPrPhyPro->finalSignZi() );
}

void set_finalSignZi(short arg ){
	ptrPrPhyPro->set_finalSignZi( arg );
}


//int noOrder = 合同卷数目
int noOrder(){
	return( ptrPrPhyPro->noOrder() );
}

void set_noOrder(int arg  ){
	ptrPrPhyPro->set_noOrder( arg );
}

short noOrderZi() {
	return( ptrPrPhyPro->noOrderZi() );
}

void set_noOrderZi(short arg ){
	ptrPrPhyPro->set_noOrderZi( arg );
}


//int noStripping = 并卷数目
int noStripping(){
	return( ptrPrPhyPro->noStripping() );
}

void set_noStripping(int arg  ){
	ptrPrPhyPro->set_noStripping( arg );
}

short noStrippingZi() {
	return( ptrPrPhyPro->noStrippingZi() );
}

void set_noStrippingZi(short arg ){
	ptrPrPhyPro->set_noStrippingZi( arg );
}


//int noWeldseams = 包含的焊缝数目
int noWeldseams(){
	return( ptrPrPhyPro->noWeldseams() );
}

void set_noWeldseams(int arg  ){
	ptrPrPhyPro->set_noWeldseams( arg );
}

short noWeldseamsZi() {
	return( ptrPrPhyPro->noWeldseamsZi() );
}

void set_noWeldseamsZi(short arg ){
	ptrPrPhyPro->set_noWeldseamsZi( arg );
}


//char* shift = 班次
char* shift(){
	return( ptrPrPhyPro->shift() );
}

void set_shift(const char* arg  ){
	ptrPrPhyPro->set_shift( arg );
}

short shiftZi() {
	return( ptrPrPhyPro->shiftZi() );
}

void set_shiftZi(short arg ){
	ptrPrPhyPro->set_shiftZi( arg );
}


//char* shiftcode = 班组
char* shiftcode(){
	return( ptrPrPhyPro->shiftcode() );
}

void set_shiftcode(const char* arg  ){
	ptrPrPhyPro->set_shiftcode( arg );
}

short shiftcodeZi() {
	return( ptrPrPhyPro->shiftcodeZi() );
}

void set_shiftcodeZi(short arg ){
	ptrPrPhyPro->set_shiftcodeZi( arg );
}


//char* statusL3 = L3通讯状态
char* statusL3(){
	return( ptrPrPhyPro->statusL3() );
}

void set_statusL3(const char* arg  ){
	ptrPrPhyPro->set_statusL3( arg );
}

short statusL3Zi() {
	return( ptrPrPhyPro->statusL3Zi() );
}

void set_statusL3Zi(short arg ){
	ptrPrPhyPro->set_statusL3Zi( arg );
}


//char* booktime = 入口卷焊上时刻
char* booktime(){
	return( ptrPrPhyPro->booktime() );
}

void set_booktime(char* arg  ){
	ptrPrPhyPro->set_booktime( arg );
}

short booktimeZi() {
	return( ptrPrPhyPro->booktimeZi() );
}

void set_booktimeZi(short arg ){
	ptrPrPhyPro->set_booktimeZi( arg );
}


//int weight = 出口实际卷重
int weight(){
	return( ptrPrPhyPro->weight() );
}

void set_weight(int arg  ){
	ptrPrPhyPro->set_weight( arg );
}

short weightZi() {
	return( ptrPrPhyPro->weightZi() );
}

void set_weightZi(short arg ){
	ptrPrPhyPro->set_weightZi( arg );
}


//int weightCalc = 出口理论重量
int weightCalc(){
	return( ptrPrPhyPro->weightCalc() );
}

void set_weightCalc(int arg  ){
	ptrPrPhyPro->set_weightCalc( arg );
}

short weightCalcZi() {
	return( ptrPrPhyPro->weightCalcZi() );
}

void set_weightCalcZi(short arg ){
	ptrPrPhyPro->set_weightCalcZi( arg );
}


//char* remark = 备注
char* remark(){
	return( ptrPrPhyPro->remark() );
}

void set_remark(const char* arg  ){
	ptrPrPhyPro->set_remark( arg );
}

short remarkZi() {
	return( ptrPrPhyPro->remarkZi() );
}

void set_remarkZi(short arg ){
	ptrPrPhyPro->set_remarkZi( arg );
}


//double hEntry = 入口钢卷厚度
double hEntry(){
	return( ptrPrPhyPro->hEntry() );
}

void set_hEntry(double arg  ){
	ptrPrPhyPro->set_hEntry( arg );
}

short hEntryZi() {
	return( ptrPrPhyPro->hEntryZi() );
}

void set_hEntryZi(short arg ){
	ptrPrPhyPro->set_hEntryZi( arg );
}


//double widthEntry = 入口钢卷宽度
double widthEntry(){
	return( ptrPrPhyPro->widthEntry() );
}

void set_widthEntry(double arg  ){
	ptrPrPhyPro->set_widthEntry( arg );
}

short widthEntryZi() {
	return( ptrPrPhyPro->widthEntryZi() );
}

void set_widthEntryZi(short arg ){
	ptrPrPhyPro->set_widthEntryZi( arg );
}


//double hExit = 出口厚度
double hExit(){
	return( ptrPrPhyPro->hExit() );
}

void set_hExit(double arg  ){
	ptrPrPhyPro->set_hExit( arg );
}

short hExitZi() {
	return( ptrPrPhyPro->hExitZi() );
}

void set_hExitZi(short arg ){
	ptrPrPhyPro->set_hExitZi( arg );
}


//double widthExit = 出口宽度
double widthExit(){
	return( ptrPrPhyPro->widthExit() );
}

void set_widthExit(double arg  ){
	ptrPrPhyPro->set_widthExit( arg );
}

short widthExitZi() {
	return( ptrPrPhyPro->widthExitZi() );
}

void set_widthExitZi(short arg ){
	ptrPrPhyPro->set_widthExitZi( arg );
}


//int weightEntry = 入口钢卷重量
int weightEntry(){
	return( ptrPrPhyPro->weightEntry() );
}

void set_weightEntry(int arg  ){
	ptrPrPhyPro->set_weightEntry( arg );
}

short weightEntryZi() {
	return( ptrPrPhyPro->weightEntryZi() );
}

void set_weightEntryZi(short arg ){
	ptrPrPhyPro->set_weightEntryZi( arg );
}


//int LengthEntry = 入口钢卷长度
int LengthEntry(){
	return( ptrPrPhyPro->LengthEntry() );
}

void set_LengthEntry(int arg  ){
	ptrPrPhyPro->set_LengthEntry( arg );
}

short LengthEntryZi() {
	return( ptrPrPhyPro->LengthEntryZi() );
}

void set_LengthEntryZi(short arg ){
	ptrPrPhyPro->set_LengthEntryZi( arg );
}


//int IndiaEntry = 入口钢卷内径
int IndiaEntry(){
	return( ptrPrPhyPro->IndiaEntry() );
}

void set_IndiaEntry(int arg  ){
	ptrPrPhyPro->set_IndiaEntry( arg );
}

short IndiaEntryZi() {
	return( ptrPrPhyPro->IndiaEntryZi() );
}

void set_IndiaEntryZi(short arg ){
	ptrPrPhyPro->set_IndiaEntryZi( arg );
}


//int OutdiaEntry = 入口钢卷外径
int OutdiaEntry(){
	return( ptrPrPhyPro->OutdiaEntry() );
}

void set_OutdiaEntry(int arg  ){
	ptrPrPhyPro->set_OutdiaEntry( arg );
}

short OutdiaEntryZi() {
	return( ptrPrPhyPro->OutdiaEntryZi() );
}

void set_OutdiaEntryZi(short arg ){
	ptrPrPhyPro->set_OutdiaEntryZi( arg );
}


//char* standard = 执行标准
char* standard(){
	return( ptrPrPhyPro->standard() );
}

void set_standard(const char* arg  ){
	ptrPrPhyPro->set_standard( arg );
}

short standardZi() {
	return( ptrPrPhyPro->standardZi() );
}

void set_standardZi(short arg ){
	ptrPrPhyPro->set_standardZi( arg );
}


//char* nextProcCode = 下道机组代码
char* nextProcCode(){
	return( ptrPrPhyPro->nextProcCode() );
}

void set_nextProcCode(const char* arg  ){
	ptrPrPhyPro->set_nextProcCode( arg );
}

short nextProcCodeZi() {
	return( ptrPrPhyPro->nextProcCodeZi() );
}

void set_nextProcCodeZi(short arg ){
	ptrPrPhyPro->set_nextProcCodeZi( arg );
}


//char* OrderNo = 合同号
char* OrderNo(){
	return( ptrPrPhyPro->OrderNo() );
}

void set_OrderNo(const char* arg  ){
	ptrPrPhyPro->set_OrderNo( arg );
}

short OrderNoZi() {
	return( ptrPrPhyPro->OrderNoZi() );
}

void set_OrderNoZi(short arg ){
	ptrPrPhyPro->set_OrderNoZi( arg );
}


//char* SpecChange = 是否改规标志
char* SpecChange(){
	return( ptrPrPhyPro->SpecChange() );
}

void set_SpecChange(const char* arg  ){
	ptrPrPhyPro->set_SpecChange( arg );
}

short SpecChangeZi() {
	return( ptrPrPhyPro->SpecChangeZi() );
}

void set_SpecChangeZi(short arg ){
	ptrPrPhyPro->set_SpecChangeZi( arg );
}


//double ExitCoilTargetWidth = 出口材料目标宽度（设定值）
double ExitCoilTargetWidth(){
	return( ptrPrPhyPro->ExitCoilTargetWidth() );
}

void set_ExitCoilTargetWidth(double arg  ){
	ptrPrPhyPro->set_ExitCoilTargetWidth( arg );
}

short ExitCoilTargetWidthZi() {
	return( ptrPrPhyPro->ExitCoilTargetWidthZi() );
}

void set_ExitCoilTargetWidthZi(short arg ){
	ptrPrPhyPro->set_ExitCoilTargetWidthZi( arg );
}


//double ExitCoilThickness = 出口材料实际厚度
double ExitCoilThickness(){
	return( ptrPrPhyPro->ExitCoilThickness() );
}

void set_ExitCoilThickness(double arg  ){
	ptrPrPhyPro->set_ExitCoilThickness( arg );
}

short ExitCoilThicknessZi() {
	return( ptrPrPhyPro->ExitCoilThicknessZi() );
}

void set_ExitCoilThicknessZi(short arg ){
	ptrPrPhyPro->set_ExitCoilThicknessZi( arg );
}


//double ExitCoilThickMin = 出口材料厚度最小值
double ExitCoilThickMin(){
	return( ptrPrPhyPro->ExitCoilThickMin() );
}

void set_ExitCoilThickMin(double arg  ){
	ptrPrPhyPro->set_ExitCoilThickMin( arg );
}

short ExitCoilThickMinZi() {
	return( ptrPrPhyPro->ExitCoilThickMinZi() );
}

void set_ExitCoilThickMinZi(short arg ){
	ptrPrPhyPro->set_ExitCoilThickMinZi( arg );
}


//double ExitCoilThickMax = 出口材料厚度最大值
double ExitCoilThickMax(){
	return( ptrPrPhyPro->ExitCoilThickMax() );
}

void set_ExitCoilThickMax(double arg  ){
	ptrPrPhyPro->set_ExitCoilThickMax( arg );
}

short ExitCoilThickMaxZi() {
	return( ptrPrPhyPro->ExitCoilThickMaxZi() );
}

void set_ExitCoilThickMaxZi(short arg ){
	ptrPrPhyPro->set_ExitCoilThickMaxZi( arg );
}


//double ExitCoilWidth = 出口材料实际宽度
double ExitCoilWidth(){
	return( ptrPrPhyPro->ExitCoilWidth() );
}

void set_ExitCoilWidth(double arg  ){
	ptrPrPhyPro->set_ExitCoilWidth( arg );
}

short ExitCoilWidthZi() {
	return( ptrPrPhyPro->ExitCoilWidthZi() );
}

void set_ExitCoilWidthZi(short arg ){
	ptrPrPhyPro->set_ExitCoilWidthZi( arg );
}


//double ExitCoilWidthMin = 出口材料宽度最小值
double ExitCoilWidthMin(){
	return( ptrPrPhyPro->ExitCoilWidthMin() );
}

void set_ExitCoilWidthMin(double arg  ){
	ptrPrPhyPro->set_ExitCoilWidthMin( arg );
}

short ExitCoilWidthMinZi() {
	return( ptrPrPhyPro->ExitCoilWidthMinZi() );
}

void set_ExitCoilWidthMinZi(short arg ){
	ptrPrPhyPro->set_ExitCoilWidthMinZi( arg );
}


//double ExitCoilWidthMax = 出口材料宽度最大值
double ExitCoilWidthMax(){
	return( ptrPrPhyPro->ExitCoilWidthMax() );
}

void set_ExitCoilWidthMax(double arg  ){
	ptrPrPhyPro->set_ExitCoilWidthMax( arg );
}

short ExitCoilWidthMaxZi() {
	return( ptrPrPhyPro->ExitCoilWidthMaxZi() );
}

void set_ExitCoilWidthMaxZi(short arg ){
	ptrPrPhyPro->set_ExitCoilWidthMaxZi( arg );
}


//char* TrimFlag = 切边标记
char* TrimFlag(){
	return( ptrPrPhyPro->TrimFlag() );
}

void set_TrimFlag(const char* arg  ){
	ptrPrPhyPro->set_TrimFlag( arg );
}

short TrimFlagZi() {
	return( ptrPrPhyPro->TrimFlagZi() );
}

void set_TrimFlagZi(short arg ){
	ptrPrPhyPro->set_TrimFlagZi( arg );
}


//short ActTrimWidth = 实际切边宽度
short ActTrimWidth(){
	return( ptrPrPhyPro->ActTrimWidth() );
}

void set_ActTrimWidth(short arg  ){
	ptrPrPhyPro->set_ActTrimWidth( arg );
}

short ActTrimWidthZi() {
	return( ptrPrPhyPro->ActTrimWidthZi() );
}

void set_ActTrimWidthZi(short arg ){
	ptrPrPhyPro->set_ActTrimWidthZi( arg );
}


//short EntScrapHeadLenth = 入口废料长度(头)
short EntScrapHeadLenth(){
	return( ptrPrPhyPro->EntScrapHeadLenth() );
}

void set_EntScrapHeadLenth(short arg  ){
	ptrPrPhyPro->set_EntScrapHeadLenth( arg );
}

short EntScrapHeadLenthZi() {
	return( ptrPrPhyPro->EntScrapHeadLenthZi() );
}

void set_EntScrapHeadLenthZi(short arg ){
	ptrPrPhyPro->set_EntScrapHeadLenthZi( arg );
}


//short EntScrapTailLenth = 入口废料长度(尾)
short EntScrapTailLenth(){
	return( ptrPrPhyPro->EntScrapTailLenth() );
}

void set_EntScrapTailLenth(short arg  ){
	ptrPrPhyPro->set_EntScrapTailLenth( arg );
}

short EntScrapTailLenthZi() {
	return( ptrPrPhyPro->EntScrapTailLenthZi() );
}

void set_EntScrapTailLenthZi(short arg ){
	ptrPrPhyPro->set_EntScrapTailLenthZi( arg );
}


//short ExtScrapHeadLenth = 出口废料长度(头)
short ExtScrapHeadLenth(){
	return( ptrPrPhyPro->ExtScrapHeadLenth() );
}

void set_ExtScrapHeadLenth(short arg  ){
	ptrPrPhyPro->set_ExtScrapHeadLenth( arg );
}

short ExtScrapHeadLenthZi() {
	return( ptrPrPhyPro->ExtScrapHeadLenthZi() );
}

void set_ExtScrapHeadLenthZi(short arg ){
	ptrPrPhyPro->set_ExtScrapHeadLenthZi( arg );
}


//short ExtScrapTailLenth = 出口废料长度(尾)
short ExtScrapTailLenth(){
	return( ptrPrPhyPro->ExtScrapTailLenth() );
}

void set_ExtScrapTailLenth(short arg  ){
	ptrPrPhyPro->set_ExtScrapTailLenth( arg );
}

short ExtScrapTailLenthZi() {
	return( ptrPrPhyPro->ExtScrapTailLenthZi() );
}

void set_ExtScrapTailLenthZi(short arg ){
	ptrPrPhyPro->set_ExtScrapTailLenthZi( arg );
}


//char* CoilCombinationFlag = 材料并卷标记
char* CoilCombinationFlag(){
	return( ptrPrPhyPro->CoilCombinationFlag() );
}

void set_CoilCombinationFlag(const char* arg  ){
	ptrPrPhyPro->set_CoilCombinationFlag( arg );
}

short CoilCombinationFlagZi() {
	return( ptrPrPhyPro->CoilCombinationFlagZi() );
}

void set_CoilCombinationFlagZi(short arg ){
	ptrPrPhyPro->set_CoilCombinationFlagZi( arg );
}


//char* EntCoilNo1 = 入口材料号1
char* EntCoilNo1(){
	return( ptrPrPhyPro->EntCoilNo1() );
}

void set_EntCoilNo1(const char* arg  ){
	ptrPrPhyPro->set_EntCoilNo1( arg );
}

short EntCoilNo1Zi() {
	return( ptrPrPhyPro->EntCoilNo1Zi() );
}

void set_EntCoilNo1Zi(short arg ){
	ptrPrPhyPro->set_EntCoilNo1Zi( arg );
}


//int EntCoilUsedWeight1 = 入口材料号1使用重量
int EntCoilUsedWeight1(){
	return( ptrPrPhyPro->EntCoilUsedWeight1() );
}

void set_EntCoilUsedWeight1(int arg  ){
	ptrPrPhyPro->set_EntCoilUsedWeight1( arg );
}

short EntCoilUsedWeight1Zi() {
	return( ptrPrPhyPro->EntCoilUsedWeight1Zi() );
}

void set_EntCoilUsedWeight1Zi(short arg ){
	ptrPrPhyPro->set_EntCoilUsedWeight1Zi( arg );
}


//char* EntCoilNo2 = 入口材料号2
char* EntCoilNo2(){
	return( ptrPrPhyPro->EntCoilNo2() );
}

void set_EntCoilNo2(const char* arg  ){
	ptrPrPhyPro->set_EntCoilNo2( arg );
}

short EntCoilNo2Zi() {
	return( ptrPrPhyPro->EntCoilNo2Zi() );
}

void set_EntCoilNo2Zi(short arg ){
	ptrPrPhyPro->set_EntCoilNo2Zi( arg );
}


//int EntCoilUsedWeight2 = 入口材料号1使用重量
int EntCoilUsedWeight2(){
	return( ptrPrPhyPro->EntCoilUsedWeight2() );
}

void set_EntCoilUsedWeight2(int arg  ){
	ptrPrPhyPro->set_EntCoilUsedWeight2( arg );
}

short EntCoilUsedWeight2Zi() {
	return( ptrPrPhyPro->EntCoilUsedWeight2Zi() );
}

void set_EntCoilUsedWeight2Zi(short arg ){
	ptrPrPhyPro->set_EntCoilUsedWeight2Zi( arg );
}


//char* EntCoilNo3 = 入口材料号3
char* EntCoilNo3(){
	return( ptrPrPhyPro->EntCoilNo3() );
}

void set_EntCoilNo3(const char* arg  ){
	ptrPrPhyPro->set_EntCoilNo3( arg );
}

short EntCoilNo3Zi() {
	return( ptrPrPhyPro->EntCoilNo3Zi() );
}

void set_EntCoilNo3Zi(short arg ){
	ptrPrPhyPro->set_EntCoilNo3Zi( arg );
}


//int EntCoilUsedWeight3 = 入口材料号3使用重量
int EntCoilUsedWeight3(){
	return( ptrPrPhyPro->EntCoilUsedWeight3() );
}

void set_EntCoilUsedWeight3(int arg  ){
	ptrPrPhyPro->set_EntCoilUsedWeight3( arg );
}

short EntCoilUsedWeight3Zi() {
	return( ptrPrPhyPro->EntCoilUsedWeight3Zi() );
}

void set_EntCoilUsedWeight3Zi(short arg ){
	ptrPrPhyPro->set_EntCoilUsedWeight3Zi( arg );
}


//short WeldPoints = 焊缝个数
short WeldPoints(){
	return( ptrPrPhyPro->WeldPoints() );
}

void set_WeldPoints(short arg  ){
	ptrPrPhyPro->set_WeldPoints( arg );
}

short WeldPointsZi() {
	return( ptrPrPhyPro->WeldPointsZi() );
}

void set_WeldPointsZi(short arg ){
	ptrPrPhyPro->set_WeldPointsZi( arg );
}


//char* Weldtype1 = 焊缝1类型
char* Weldtype1(){
	return( ptrPrPhyPro->Weldtype1() );
}

void set_Weldtype1(const char* arg  ){
	ptrPrPhyPro->set_Weldtype1( arg );
}

short Weldtype1Zi() {
	return( ptrPrPhyPro->Weldtype1Zi() );
}

void set_Weldtype1Zi(short arg ){
	ptrPrPhyPro->set_Weldtype1Zi( arg );
}


//int Weldposition1 = 焊缝位置1
int Weldposition1(){
	return( ptrPrPhyPro->Weldposition1() );
}

void set_Weldposition1(int arg  ){
	ptrPrPhyPro->set_Weldposition1( arg );
}

short Weldposition1Zi() {
	return( ptrPrPhyPro->Weldposition1Zi() );
}

void set_Weldposition1Zi(short arg ){
	ptrPrPhyPro->set_Weldposition1Zi( arg );
}


//char* Weldtype2 = 焊缝2类型
char* Weldtype2(){
	return( ptrPrPhyPro->Weldtype2() );
}

void set_Weldtype2(const char* arg  ){
	ptrPrPhyPro->set_Weldtype2( arg );
}

short Weldtype2Zi() {
	return( ptrPrPhyPro->Weldtype2Zi() );
}

void set_Weldtype2Zi(short arg ){
	ptrPrPhyPro->set_Weldtype2Zi( arg );
}


//int Weldposition2 = 焊缝位置2
int Weldposition2(){
	return( ptrPrPhyPro->Weldposition2() );
}

void set_Weldposition2(int arg  ){
	ptrPrPhyPro->set_Weldposition2( arg );
}

short Weldposition2Zi() {
	return( ptrPrPhyPro->Weldposition2Zi() );
}

void set_Weldposition2Zi(short arg ){
	ptrPrPhyPro->set_Weldposition2Zi( arg );
}


//char* Weldtype3 = 焊缝3类型
char* Weldtype3(){
	return( ptrPrPhyPro->Weldtype3() );
}

void set_Weldtype3(const char* arg  ){
	ptrPrPhyPro->set_Weldtype3( arg );
}

short Weldtype3Zi() {
	return( ptrPrPhyPro->Weldtype3Zi() );
}

void set_Weldtype3Zi(short arg ){
	ptrPrPhyPro->set_Weldtype3Zi( arg );
}


//int Weldposition3 = 焊缝位置3
int Weldposition3(){
	return( ptrPrPhyPro->Weldposition3() );
}

void set_Weldposition3(int arg  ){
	ptrPrPhyPro->set_Weldposition3( arg );
}

short Weldposition3Zi() {
	return( ptrPrPhyPro->Weldposition3Zi() );
}

void set_Weldposition3Zi(short arg ){
	ptrPrPhyPro->set_Weldposition3Zi( arg );
}


//char* CoatingCode = 涂油种类代码
char* CoatingCode(){
	return( ptrPrPhyPro->CoatingCode() );
}

void set_CoatingCode(const char* arg  ){
	ptrPrPhyPro->set_CoatingCode( arg );
}

short CoatingCodeZi() {
	return( ptrPrPhyPro->CoatingCodeZi() );
}

void set_CoatingCodeZi(short arg ){
	ptrPrPhyPro->set_CoatingCodeZi( arg );
}


//short TopCoatingAmount = 上表面涂油量
short TopCoatingAmount(){
	return( ptrPrPhyPro->TopCoatingAmount() );
}

void set_TopCoatingAmount(short arg  ){
	ptrPrPhyPro->set_TopCoatingAmount( arg );
}

short TopCoatingAmountZi() {
	return( ptrPrPhyPro->TopCoatingAmountZi() );
}

void set_TopCoatingAmountZi(short arg ){
	ptrPrPhyPro->set_TopCoatingAmountZi( arg );
}


//short BotCoatingAmount = 下表面涂油量
short BotCoatingAmount(){
	return( ptrPrPhyPro->BotCoatingAmount() );
}

void set_BotCoatingAmount(short arg  ){
	ptrPrPhyPro->set_BotCoatingAmount( arg );
}

short BotCoatingAmountZi() {
	return( ptrPrPhyPro->BotCoatingAmountZi() );
}

void set_BotCoatingAmountZi(short arg ){
	ptrPrPhyPro->set_BotCoatingAmountZi( arg );
}


//short PreClearLiquidPitPos = 预清洗槽液位
short PreClearLiquidPitPos(){
	return( ptrPrPhyPro->PreClearLiquidPitPos() );
}

void set_PreClearLiquidPitPos(short arg  ){
	ptrPrPhyPro->set_PreClearLiquidPitPos( arg );
}

short PreClearLiquidPitPosZi() {
	return( ptrPrPhyPro->PreClearLiquidPitPosZi() );
}

void set_PreClearLiquidPitPosZi(short arg ){
	ptrPrPhyPro->set_PreClearLiquidPitPosZi( arg );
}




//int muId= Material idendification number
int muId_LoPr()
{
	return( ptrPrLogPro->muId() );
}

void set_muId_LoPr(int arg  )
{
	ptrPrLogPro->set_muId( arg  );
}

//char muCreator= Material owner
char* muCreator_LoPr()
{
	return( ptrPrLogPro->muCreator() );
}

void set_muCreator_LoPr(const char* arg  )
{
	ptrPrLogPro->set_muCreator( arg  );
}

//short musId= Line status
short musId_LoPr()
{
	return( ptrPrLogPro->musId() );
}

void set_musId_LoPr(short arg  )
{
	ptrPrLogPro->set_musId( arg  );
}


//char* toc= Time of creattion
char* toc_LoPr()
{
	return( ptrPrLogPro->toc() );
}

short toc_LoPrZi()
{
	return( ptrPrLogPro->tocZi() );
}

//char* tom= Time of modification
char* tom_LoPr()
{
	return( ptrPrLogPro->tom() );
}

short tom_LoPrZi()
{
	return( ptrPrLogPro->tomZi() );
}

//char* mop= Modification process
char* mop_LoPr()
{
	return( ptrPrLogPro->mop() );
}

short mop_LoPrZi()
{
	return( ptrPrLogPro->mopZi() );
}

//char* mou= Modification User
char* mou_LoPr()
{
	return( ptrPrLogPro->mou() );
}

short mou_LoPrZi()
{
	return( ptrPrLogPro->mouZi() );
}


//char* source = Owner
char* source_LoPr(){
	return( ptrPrLogPro->source() );
}

void set_source_LoPr(const char* arg  ){
	ptrPrLogPro->set_source( arg );
}



//int muId= Material idendification number
int muId_OrPr()
{
	return( ptrPrOrdPro->muId() );
}

void set_muId_OrPr(int arg  )
{
	ptrPrOrdPro->set_muId( arg  );
}

//char muCreator= Material owner
char* muCreator_OrPr()
{
	return( ptrPrOrdPro->muCreator() );
}

void set_muCreator_OrPr(const char* arg  )
{
	ptrPrOrdPro->set_muCreator( arg  );
}

//short musId= Line status
short musId_OrPr()
{
	return( ptrPrOrdPro->musId() );
}

void set_musId_OrPr(short arg  )
{
	ptrPrOrdPro->set_musId( arg  );
}


//char* toc= Time of creattion
char* toc_OrPr()
{
	return( ptrPrOrdPro->toc() );
}

short toc_OrPrZi()
{
	return( ptrPrOrdPro->tocZi() );
}

//char* tom= Time of modification
char* tom_OrPr()
{
	return( ptrPrOrdPro->tom() );
}

short tom_OrPrZi()
{
	return( ptrPrOrdPro->tomZi() );
}

//char* mop= Modification process
char* mop_OrPr()
{
	return( ptrPrOrdPro->mop() );
}

short mop_OrPrZi()
{
	return( ptrPrOrdPro->mopZi() );
}

//char* mou= Modification User
char* mou_OrPr()
{
	return( ptrPrOrdPro->mou() );
}

short mou_OrPrZi()
{
	return( ptrPrOrdPro->mouZi() );
}


//char* source = 记录状态
char* source_OrPr(){
	return( ptrPrOrdPro->source() );
}

void set_source_OrPr(const char* arg  ){
	ptrPrOrdPro->set_source( arg );
}

//double width = 出口宽度
double width(){
	return( ptrPrOrdPro->width() );
}

void set_width(double arg  ){
	ptrPrOrdPro->set_width( arg );
}

short widthZi() {
	return( ptrPrOrdPro->widthZi() );
}

void set_widthZi(short arg ){
	ptrPrOrdPro->set_widthZi( arg );
}


//int UseWeight = 已使用重量
int UseWeight(){
	return( ptrPrOrdPro->UseWeight() );
}

void set_UseWeight(int arg  ){
	ptrPrOrdPro->set_UseWeight( arg );
}

short UseWeightZi() {
	return( ptrPrOrdPro->UseWeightZi() );
}

void set_UseWeightZi(short arg ){
	ptrPrOrdPro->set_UseWeightZi( arg );
}


//char* alloyCode = 钢种
char* alloyCode(){
	return( ptrPrOrdPro->alloyCode() );
}

void set_alloyCode(const char* arg  ){
	ptrPrOrdPro->set_alloyCode( arg );
}

short alloyCodeZi() {
	return( ptrPrOrdPro->alloyCodeZi() );
}

void set_alloyCodeZi(short arg ){
	ptrPrOrdPro->set_alloyCodeZi( arg );
}


//char* holdingReason = 封闭原因代码
char* holdingReason(){
	return( ptrPrOrdPro->holdingReason() );
}

void set_holdingReason(const char* arg  ){
	ptrPrOrdPro->set_holdingReason( arg );
}

short holdingReasonZi() {
	return( ptrPrOrdPro->holdingReasonZi() );
}

void set_holdingReasonZi(short arg ){
	ptrPrOrdPro->set_holdingReasonZi( arg );
}


//char* holdingUserID = 封锁责任者代码
char* holdingUserID(){
	return( ptrPrOrdPro->holdingUserID() );
}

void set_holdingUserID(const char* arg  ){
	ptrPrOrdPro->set_holdingUserID( arg );
}

short holdingUserIDZi() {
	return( ptrPrOrdPro->holdingUserIDZi() );
}

void set_holdingUserIDZi(short arg ){
	ptrPrOrdPro->set_holdingUserIDZi( arg );
}


//short EntSpeedAvg = 入口速度平均值
short EntSpeedAvg(){
	return( ptrPrOrdPro->EntSpeedAvg() );
}

void set_EntSpeedAvg(short arg  ){
	ptrPrOrdPro->set_EntSpeedAvg( arg );
}

short EntSpeedAvgZi() {
	return( ptrPrOrdPro->EntSpeedAvgZi() );
}

void set_EntSpeedAvgZi(short arg ){
	ptrPrOrdPro->set_EntSpeedAvgZi( arg );
}


//short EntSpeedMax = 入口速度最大值
short EntSpeedMax(){
	return( ptrPrOrdPro->EntSpeedMax() );
}

void set_EntSpeedMax(short arg  ){
	ptrPrOrdPro->set_EntSpeedMax( arg );
}

short EntSpeedMaxZi() {
	return( ptrPrOrdPro->EntSpeedMaxZi() );
}

void set_EntSpeedMaxZi(short arg ){
	ptrPrOrdPro->set_EntSpeedMaxZi( arg );
}


//short EntSpeedMin = 入口速度最小值
short EntSpeedMin(){
	return( ptrPrOrdPro->EntSpeedMin() );
}

void set_EntSpeedMin(short arg  ){
	ptrPrOrdPro->set_EntSpeedMin( arg );
}

short EntSpeedMinZi() {
	return( ptrPrOrdPro->EntSpeedMinZi() );
}

void set_EntSpeedMinZi(short arg ){
	ptrPrOrdPro->set_EntSpeedMinZi( arg );
}


//short CraftSpeedAvg = 工艺段速度平均值
short CraftSpeedAvg(){
	return( ptrPrOrdPro->CraftSpeedAvg() );
}

void set_CraftSpeedAvg(short arg  ){
	ptrPrOrdPro->set_CraftSpeedAvg( arg );
}

short CraftSpeedAvgZi() {
	return( ptrPrOrdPro->CraftSpeedAvgZi() );
}

void set_CraftSpeedAvgZi(short arg ){
	ptrPrOrdPro->set_CraftSpeedAvgZi( arg );
}


//short CraftSpeedMax = 工艺段速度最大值
short CraftSpeedMax(){
	return( ptrPrOrdPro->CraftSpeedMax() );
}

void set_CraftSpeedMax(short arg  ){
	ptrPrOrdPro->set_CraftSpeedMax( arg );
}

short CraftSpeedMaxZi() {
	return( ptrPrOrdPro->CraftSpeedMaxZi() );
}

void set_CraftSpeedMaxZi(short arg ){
	ptrPrOrdPro->set_CraftSpeedMaxZi( arg );
}


//short CraftSpeedMin = 工艺段速度最小值
short CraftSpeedMin(){
	return( ptrPrOrdPro->CraftSpeedMin() );
}

void set_CraftSpeedMin(short arg  ){
	ptrPrOrdPro->set_CraftSpeedMin( arg );
}

short CraftSpeedMinZi() {
	return( ptrPrOrdPro->CraftSpeedMinZi() );
}

void set_CraftSpeedMinZi(short arg ){
	ptrPrOrdPro->set_CraftSpeedMinZi( arg );
}


//short ExtSpeedAvg = 出口速度平均值
short ExtSpeedAvg(){
	return( ptrPrOrdPro->ExtSpeedAvg() );
}

void set_ExtSpeedAvg(short arg  ){
	ptrPrOrdPro->set_ExtSpeedAvg( arg );
}

short ExtSpeedAvgZi() {
	return( ptrPrOrdPro->ExtSpeedAvgZi() );
}

void set_ExtSpeedAvgZi(short arg ){
	ptrPrOrdPro->set_ExtSpeedAvgZi( arg );
}


//short ExtSpeedMax = 出口速度最大值
short ExtSpeedMax(){
	return( ptrPrOrdPro->ExtSpeedMax() );
}

void set_ExtSpeedMax(short arg  ){
	ptrPrOrdPro->set_ExtSpeedMax( arg );
}

short ExtSpeedMaxZi() {
	return( ptrPrOrdPro->ExtSpeedMaxZi() );
}

void set_ExtSpeedMaxZi(short arg ){
	ptrPrOrdPro->set_ExtSpeedMaxZi( arg );
}


//short ExtSpeedMin = 出口速度最小值
short ExtSpeedMin(){
	return( ptrPrOrdPro->ExtSpeedMin() );
}

void set_ExtSpeedMin(short arg  ){
	ptrPrOrdPro->set_ExtSpeedMin( arg );
}

short ExtSpeedMinZi() {
	return( ptrPrOrdPro->ExtSpeedMinZi() );
}

void set_ExtSpeedMinZi(short arg ){
	ptrPrOrdPro->set_ExtSpeedMinZi( arg );
}


//short EntCoilSpeedAvg = 开卷机速度平均值
short EntCoilSpeedAvg(){
	return( ptrPrOrdPro->EntCoilSpeedAvg() );
}

void set_EntCoilSpeedAvg(short arg  ){
	ptrPrOrdPro->set_EntCoilSpeedAvg( arg );
}

short EntCoilSpeedAvgZi() {
	return( ptrPrOrdPro->EntCoilSpeedAvgZi() );
}

void set_EntCoilSpeedAvgZi(short arg ){
	ptrPrOrdPro->set_EntCoilSpeedAvgZi( arg );
}


//short EntCoilSpeedMax = 开卷机速度最大值
short EntCoilSpeedMax(){
	return( ptrPrOrdPro->EntCoilSpeedMax() );
}

void set_EntCoilSpeedMax(short arg  ){
	ptrPrOrdPro->set_EntCoilSpeedMax( arg );
}

short EntCoilSpeedMaxZi() {
	return( ptrPrOrdPro->EntCoilSpeedMaxZi() );
}

void set_EntCoilSpeedMaxZi(short arg ){
	ptrPrOrdPro->set_EntCoilSpeedMaxZi( arg );
}


//short EntCoilSpeedMin = 开卷机速度最小值
short EntCoilSpeedMin(){
	return( ptrPrOrdPro->EntCoilSpeedMin() );
}

void set_EntCoilSpeedMin(short arg  ){
	ptrPrOrdPro->set_EntCoilSpeedMin( arg );
}

short EntCoilSpeedMinZi() {
	return( ptrPrOrdPro->EntCoilSpeedMinZi() );
}

void set_EntCoilSpeedMinZi(short arg ){
	ptrPrOrdPro->set_EntCoilSpeedMinZi( arg );
}


//short ExtCoilSpeedAvg = 卷取机速度平均值
short ExtCoilSpeedAvg(){
	return( ptrPrOrdPro->ExtCoilSpeedAvg() );
}

void set_ExtCoilSpeedAvg(short arg  ){
	ptrPrOrdPro->set_ExtCoilSpeedAvg( arg );
}

short ExtCoilSpeedAvgZi() {
	return( ptrPrOrdPro->ExtCoilSpeedAvgZi() );
}

void set_ExtCoilSpeedAvgZi(short arg ){
	ptrPrOrdPro->set_ExtCoilSpeedAvgZi( arg );
}


//short ExtCoilSpeedMax = 卷取机速度最大值
short ExtCoilSpeedMax(){
	return( ptrPrOrdPro->ExtCoilSpeedMax() );
}

void set_ExtCoilSpeedMax(short arg  ){
	ptrPrOrdPro->set_ExtCoilSpeedMax( arg );
}

short ExtCoilSpeedMaxZi() {
	return( ptrPrOrdPro->ExtCoilSpeedMaxZi() );
}

void set_ExtCoilSpeedMaxZi(short arg ){
	ptrPrOrdPro->set_ExtCoilSpeedMaxZi( arg );
}


//short ExtCoilSpeedMin = 卷取机速度最小值
short ExtCoilSpeedMin(){
	return( ptrPrOrdPro->ExtCoilSpeedMin() );
}

void set_ExtCoilSpeedMin(short arg  ){
	ptrPrOrdPro->set_ExtCoilSpeedMin( arg );
}

short ExtCoilSpeedMinZi() {
	return( ptrPrOrdPro->ExtCoilSpeedMinZi() );
}

void set_ExtCoilSpeedMinZi(short arg ){
	ptrPrOrdPro->set_ExtCoilSpeedMinZi( arg );
}


//short EntCoilTensionAvg = 开卷机张力平均值
short EntCoilTensionAvg(){
	return( ptrPrOrdPro->EntCoilTensionAvg() );
}

void set_EntCoilTensionAvg(short arg  ){
	ptrPrOrdPro->set_EntCoilTensionAvg( arg );
}

short EntCoilTensionAvgZi() {
	return( ptrPrOrdPro->EntCoilTensionAvgZi() );
}

void set_EntCoilTensionAvgZi(short arg ){
	ptrPrOrdPro->set_EntCoilTensionAvgZi( arg );
}


//short EntCoilTensionMax = 开卷机张力最大值
short EntCoilTensionMax(){
	return( ptrPrOrdPro->EntCoilTensionMax() );
}

void set_EntCoilTensionMax(short arg  ){
	ptrPrOrdPro->set_EntCoilTensionMax( arg );
}

short EntCoilTensionMaxZi() {
	return( ptrPrOrdPro->EntCoilTensionMaxZi() );
}

void set_EntCoilTensionMaxZi(short arg ){
	ptrPrOrdPro->set_EntCoilTensionMaxZi( arg );
}


//short EntCoilTensionMin = 开卷机张力最小值
short EntCoilTensionMin(){
	return( ptrPrOrdPro->EntCoilTensionMin() );
}

void set_EntCoilTensionMin(short arg  ){
	ptrPrOrdPro->set_EntCoilTensionMin( arg );
}

short EntCoilTensionMinZi() {
	return( ptrPrOrdPro->EntCoilTensionMinZi() );
}

void set_EntCoilTensionMinZi(short arg ){
	ptrPrOrdPro->set_EntCoilTensionMinZi( arg );
}


//short GydTensionAvg = 工艺段张力均值
short GydTensionAvg(){
	return( ptrPrOrdPro->GydTensionAvg() );
}

void set_GydTensionAvg(short arg  ){
	ptrPrOrdPro->set_GydTensionAvg( arg );
}

short GydTensionAvgZi() {
	return( ptrPrOrdPro->GydTensionAvgZi() );
}

void set_GydTensionAvgZi(short arg ){
	ptrPrOrdPro->set_GydTensionAvgZi( arg );
}


//short GydTensionMax = 工艺段张力最大值
short GydTensionMax(){
	return( ptrPrOrdPro->GydTensionMax() );
}

void set_GydTensionMax(short arg  ){
	ptrPrOrdPro->set_GydTensionMax( arg );
}

short GydTensionMaxZi() {
	return( ptrPrOrdPro->GydTensionMaxZi() );
}

void set_GydTensionMaxZi(short arg ){
	ptrPrOrdPro->set_GydTensionMaxZi( arg );
}


//short GydTensionMin = 工艺段张力最小值
short GydTensionMin(){
	return( ptrPrOrdPro->GydTensionMin() );
}

void set_GydTensionMin(short arg  ){
	ptrPrOrdPro->set_GydTensionMin( arg );
}

short GydTensionMinZi() {
	return( ptrPrOrdPro->GydTensionMinZi() );
}

void set_GydTensionMinZi(short arg ){
	ptrPrOrdPro->set_GydTensionMinZi( arg );
}


//short DiskCutTensionAvg = 圆盘剪张力平均值
short DiskCutTensionAvg(){
	return( ptrPrOrdPro->DiskCutTensionAvg() );
}

void set_DiskCutTensionAvg(short arg  ){
	ptrPrOrdPro->set_DiskCutTensionAvg( arg );
}

short DiskCutTensionAvgZi() {
	return( ptrPrOrdPro->DiskCutTensionAvgZi() );
}

void set_DiskCutTensionAvgZi(short arg ){
	ptrPrOrdPro->set_DiskCutTensionAvgZi( arg );
}


//short DiskCutTensionMax = 圆盘剪张力最大值
short DiskCutTensionMax(){
	return( ptrPrOrdPro->DiskCutTensionMax() );
}

void set_DiskCutTensionMax(short arg  ){
	ptrPrOrdPro->set_DiskCutTensionMax( arg );
}

short DiskCutTensionMaxZi() {
	return( ptrPrOrdPro->DiskCutTensionMaxZi() );
}

void set_DiskCutTensionMaxZi(short arg ){
	ptrPrOrdPro->set_DiskCutTensionMaxZi( arg );
}


//short DiskCutTensionMin = 圆盘剪张力最小值
short DiskCutTensionMin(){
	return( ptrPrOrdPro->DiskCutTensionMin() );
}

void set_DiskCutTensionMin(short arg  ){
	ptrPrOrdPro->set_DiskCutTensionMin( arg );
}

short DiskCutTensionMinZi() {
	return( ptrPrOrdPro->DiskCutTensionMinZi() );
}

void set_DiskCutTensionMinZi(short arg ){
	ptrPrOrdPro->set_DiskCutTensionMinZi( arg );
}


//short ExtCoilTensionAvg = 卷取机张力平均值
short ExtCoilTensionAvg(){
	return( ptrPrOrdPro->ExtCoilTensionAvg() );
}

void set_ExtCoilTensionAvg(short arg  ){
	ptrPrOrdPro->set_ExtCoilTensionAvg( arg );
}

short ExtCoilTensionAvgZi() {
	return( ptrPrOrdPro->ExtCoilTensionAvgZi() );
}

void set_ExtCoilTensionAvgZi(short arg ){
	ptrPrOrdPro->set_ExtCoilTensionAvgZi( arg );
}


//short ExtCoilTensionMax = 卷取机张力最大值
short ExtCoilTensionMax(){
	return( ptrPrOrdPro->ExtCoilTensionMax() );
}

void set_ExtCoilTensionMax(short arg  ){
	ptrPrOrdPro->set_ExtCoilTensionMax( arg );
}

short ExtCoilTensionMaxZi() {
	return( ptrPrOrdPro->ExtCoilTensionMaxZi() );
}

void set_ExtCoilTensionMaxZi(short arg ){
	ptrPrOrdPro->set_ExtCoilTensionMaxZi( arg );
}


//short ExtCoilTensionMin = 卷取机张力最小值
short ExtCoilTensionMin(){
	return( ptrPrOrdPro->ExtCoilTensionMin() );
}

void set_ExtCoilTensionMin(short arg  ){
	ptrPrOrdPro->set_ExtCoilTensionMin( arg );
}

short ExtCoilTensionMinZi() {
	return( ptrPrOrdPro->ExtCoilTensionMinZi() );
}

void set_ExtCoilTensionMinZi(short arg ){
	ptrPrOrdPro->set_ExtCoilTensionMinZi( arg );
}


//int AcidPotZ1Avg = 1#酸罐液位平均值
int AcidPotZ1Avg(){
	return( ptrPrOrdPro->AcidPotZ1Avg() );
}

void set_AcidPotZ1Avg(int arg  ){
	ptrPrOrdPro->set_AcidPotZ1Avg( arg );
}

short AcidPotZ1AvgZi() {
	return( ptrPrOrdPro->AcidPotZ1AvgZi() );
}

void set_AcidPotZ1AvgZi(short arg ){
	ptrPrOrdPro->set_AcidPotZ1AvgZi( arg );
}


//int AcidPotZ1Max = 1#酸罐液位最大值
int AcidPotZ1Max(){
	return( ptrPrOrdPro->AcidPotZ1Max() );
}

void set_AcidPotZ1Max(int arg  ){
	ptrPrOrdPro->set_AcidPotZ1Max( arg );
}

short AcidPotZ1MaxZi() {
	return( ptrPrOrdPro->AcidPotZ1MaxZi() );
}

void set_AcidPotZ1MaxZi(short arg ){
	ptrPrOrdPro->set_AcidPotZ1MaxZi( arg );
}


//int AcidPotZ1Min = 1#酸罐液位最小值
int AcidPotZ1Min(){
	return( ptrPrOrdPro->AcidPotZ1Min() );
}

void set_AcidPotZ1Min(int arg  ){
	ptrPrOrdPro->set_AcidPotZ1Min( arg );
}

short AcidPotZ1MinZi() {
	return( ptrPrOrdPro->AcidPotZ1MinZi() );
}

void set_AcidPotZ1MinZi(short arg ){
	ptrPrOrdPro->set_AcidPotZ1MinZi( arg );
}


//int AcidPotZ2Avg = 2#酸罐液位平均值
int AcidPotZ2Avg(){
	return( ptrPrOrdPro->AcidPotZ2Avg() );
}

void set_AcidPotZ2Avg(int arg  ){
	ptrPrOrdPro->set_AcidPotZ2Avg( arg );
}

short AcidPotZ2AvgZi() {
	return( ptrPrOrdPro->AcidPotZ2AvgZi() );
}

void set_AcidPotZ2AvgZi(short arg ){
	ptrPrOrdPro->set_AcidPotZ2AvgZi( arg );
}


//int AcidPotZ2Max = 2#酸罐液位最大值
int AcidPotZ2Max(){
	return( ptrPrOrdPro->AcidPotZ2Max() );
}

void set_AcidPotZ2Max(int arg  ){
	ptrPrOrdPro->set_AcidPotZ2Max( arg );
}

short AcidPotZ2MaxZi() {
	return( ptrPrOrdPro->AcidPotZ2MaxZi() );
}

void set_AcidPotZ2MaxZi(short arg ){
	ptrPrOrdPro->set_AcidPotZ2MaxZi( arg );
}


//int AcidPotZ2Min = 2#酸罐液位最小值
int AcidPotZ2Min(){
	return( ptrPrOrdPro->AcidPotZ2Min() );
}

void set_AcidPotZ2Min(int arg  ){
	ptrPrOrdPro->set_AcidPotZ2Min( arg );
}

short AcidPotZ2MinZi() {
	return( ptrPrOrdPro->AcidPotZ2MinZi() );
}

void set_AcidPotZ2MinZi(short arg ){
	ptrPrOrdPro->set_AcidPotZ2MinZi( arg );
}


//int AcidPotZ3Avg = 3#酸罐液位平均值
int AcidPotZ3Avg(){
	return( ptrPrOrdPro->AcidPotZ3Avg() );
}

void set_AcidPotZ3Avg(int arg  ){
	ptrPrOrdPro->set_AcidPotZ3Avg( arg );
}

short AcidPotZ3AvgZi() {
	return( ptrPrOrdPro->AcidPotZ3AvgZi() );
}

void set_AcidPotZ3AvgZi(short arg ){
	ptrPrOrdPro->set_AcidPotZ3AvgZi( arg );
}


//int AcidPotZ3Max = 3#酸罐液位最大值
int AcidPotZ3Max(){
	return( ptrPrOrdPro->AcidPotZ3Max() );
}

void set_AcidPotZ3Max(int arg  ){
	ptrPrOrdPro->set_AcidPotZ3Max( arg );
}

short AcidPotZ3MaxZi() {
	return( ptrPrOrdPro->AcidPotZ3MaxZi() );
}

void set_AcidPotZ3MaxZi(short arg ){
	ptrPrOrdPro->set_AcidPotZ3MaxZi( arg );
}


//int AcidPotZ3Min = 3#酸罐液位最小值
int AcidPotZ3Min(){
	return( ptrPrOrdPro->AcidPotZ3Min() );
}

void set_AcidPotZ3Min(int arg  ){
	ptrPrOrdPro->set_AcidPotZ3Min( arg );
}

short AcidPotZ3MinZi() {
	return( ptrPrOrdPro->AcidPotZ3MinZi() );
}

void set_AcidPotZ3MinZi(short arg ){
	ptrPrOrdPro->set_AcidPotZ3MinZi( arg );
}


//int AcidPotZ4Avg = 4#酸罐液位平均值
int AcidPotZ4Avg(){
	return( ptrPrOrdPro->AcidPotZ4Avg() );
}

void set_AcidPotZ4Avg(int arg  ){
	ptrPrOrdPro->set_AcidPotZ4Avg( arg );
}

short AcidPotZ4AvgZi() {
	return( ptrPrOrdPro->AcidPotZ4AvgZi() );
}

void set_AcidPotZ4AvgZi(short arg ){
	ptrPrOrdPro->set_AcidPotZ4AvgZi( arg );
}


//int AcidPotZ4Max = 4#酸罐液位最大值
int AcidPotZ4Max(){
	return( ptrPrOrdPro->AcidPotZ4Max() );
}

void set_AcidPotZ4Max(int arg  ){
	ptrPrOrdPro->set_AcidPotZ4Max( arg );
}

short AcidPotZ4MaxZi() {
	return( ptrPrOrdPro->AcidPotZ4MaxZi() );
}

void set_AcidPotZ4MaxZi(short arg ){
	ptrPrOrdPro->set_AcidPotZ4MaxZi( arg );
}


//int AcidPotZ4Min = 4#酸罐液位最小值
int AcidPotZ4Min(){
	return( ptrPrOrdPro->AcidPotZ4Min() );
}

void set_AcidPotZ4Min(int arg  ){
	ptrPrOrdPro->set_AcidPotZ4Min( arg );
}

short AcidPotZ4MinZi() {
	return( ptrPrOrdPro->AcidPotZ4MinZi() );
}

void set_AcidPotZ4MinZi(short arg ){
	ptrPrOrdPro->set_AcidPotZ4MinZi( arg );
}


//int AcidPotZ5Avg = 5#酸罐液位平均值
int AcidPotZ5Avg(){
	return( ptrPrOrdPro->AcidPotZ5Avg() );
}

void set_AcidPotZ5Avg(int arg  ){
	ptrPrOrdPro->set_AcidPotZ5Avg( arg );
}

short AcidPotZ5AvgZi() {
	return( ptrPrOrdPro->AcidPotZ5AvgZi() );
}

void set_AcidPotZ5AvgZi(short arg ){
	ptrPrOrdPro->set_AcidPotZ5AvgZi( arg );
}


//int AcidPotZ5Max = 5#酸罐液位最大值
int AcidPotZ5Max(){
	return( ptrPrOrdPro->AcidPotZ5Max() );
}

void set_AcidPotZ5Max(int arg  ){
	ptrPrOrdPro->set_AcidPotZ5Max( arg );
}

short AcidPotZ5MaxZi() {
	return( ptrPrOrdPro->AcidPotZ5MaxZi() );
}

void set_AcidPotZ5MaxZi(short arg ){
	ptrPrOrdPro->set_AcidPotZ5MaxZi( arg );
}


//int AcidPotZ5Min = 5#酸罐液位最小值
int AcidPotZ5Min(){
	return( ptrPrOrdPro->AcidPotZ5Min() );
}

void set_AcidPotZ5Min(int arg  ){
	ptrPrOrdPro->set_AcidPotZ5Min( arg );
}

short AcidPotZ5MinZi() {
	return( ptrPrOrdPro->AcidPotZ5MinZi() );
}

void set_AcidPotZ5MinZi(short arg ){
	ptrPrOrdPro->set_AcidPotZ5MinZi( arg );
}


//short BleaThroughHeatTempAvg = 漂洗槽加热器温度平均值
short BleaThroughHeatTempAvg(){
	return( ptrPrOrdPro->BleaThroughHeatTempAvg() );
}

void set_BleaThroughHeatTempAvg(short arg  ){
	ptrPrOrdPro->set_BleaThroughHeatTempAvg( arg );
}

short BleaThroughHeatTempAvgZi() {
	return( ptrPrOrdPro->BleaThroughHeatTempAvgZi() );
}

void set_BleaThroughHeatTempAvgZi(short arg ){
	ptrPrOrdPro->set_BleaThroughHeatTempAvgZi( arg );
}


//short BleaThroughHeatTempMax = 漂洗槽加热器温度最大值
short BleaThroughHeatTempMax(){
	return( ptrPrOrdPro->BleaThroughHeatTempMax() );
}

void set_BleaThroughHeatTempMax(short arg  ){
	ptrPrOrdPro->set_BleaThroughHeatTempMax( arg );
}

short BleaThroughHeatTempMaxZi() {
	return( ptrPrOrdPro->BleaThroughHeatTempMaxZi() );
}

void set_BleaThroughHeatTempMaxZi(short arg ){
	ptrPrOrdPro->set_BleaThroughHeatTempMaxZi( arg );
}


//short BleaThroughHeatTempMin = 漂洗槽加热器温度最小值
short BleaThroughHeatTempMin(){
	return( ptrPrOrdPro->BleaThroughHeatTempMin() );
}

void set_BleaThroughHeatTempMin(short arg  ){
	ptrPrOrdPro->set_BleaThroughHeatTempMin( arg );
}

short BleaThroughHeatTempMinZi() {
	return( ptrPrOrdPro->BleaThroughHeatTempMinZi() );
}

void set_BleaThroughHeatTempMinZi(short arg ){
	ptrPrOrdPro->set_BleaThroughHeatTempMinZi( arg );
}


//short CondenseHeatTempAvg = 冷凝水加热器温度平均值
short CondenseHeatTempAvg(){
	return( ptrPrOrdPro->CondenseHeatTempAvg() );
}

void set_CondenseHeatTempAvg(short arg  ){
	ptrPrOrdPro->set_CondenseHeatTempAvg( arg );
}

short CondenseHeatTempAvgZi() {
	return( ptrPrOrdPro->CondenseHeatTempAvgZi() );
}

void set_CondenseHeatTempAvgZi(short arg ){
	ptrPrOrdPro->set_CondenseHeatTempAvgZi( arg );
}


//short CondenseHeatTempMax = 冷凝水加热器温度最大值
short CondenseHeatTempMax(){
	return( ptrPrOrdPro->CondenseHeatTempMax() );
}

void set_CondenseHeatTempMax(short arg  ){
	ptrPrOrdPro->set_CondenseHeatTempMax( arg );
}

short CondenseHeatTempMaxZi() {
	return( ptrPrOrdPro->CondenseHeatTempMaxZi() );
}

void set_CondenseHeatTempMaxZi(short arg ){
	ptrPrOrdPro->set_CondenseHeatTempMaxZi( arg );
}


//short CondenseHeatTempMin = 冷凝水加热器温度最小值
short CondenseHeatTempMin(){
	return( ptrPrOrdPro->CondenseHeatTempMin() );
}

void set_CondenseHeatTempMin(short arg  ){
	ptrPrOrdPro->set_CondenseHeatTempMin( arg );
}

short CondenseHeatTempMinZi() {
	return( ptrPrOrdPro->CondenseHeatTempMinZi() );
}

void set_CondenseHeatTempMinZi(short arg ){
	ptrPrOrdPro->set_CondenseHeatTempMinZi( arg );
}


//short AcidThroughHeatTempZ1Avg1 = 1#酸槽1#加热器温度平均值
short AcidThroughHeatTempZ1Avg1(){
	return( ptrPrOrdPro->AcidThroughHeatTempZ1Avg1() );
}

void set_AcidThroughHeatTempZ1Avg1(short arg  ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ1Avg1( arg );
}

short AcidThroughHeatTempZ1Avg1Zi() {
	return( ptrPrOrdPro->AcidThroughHeatTempZ1Avg1Zi() );
}

void set_AcidThroughHeatTempZ1Avg1Zi(short arg ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ1Avg1Zi( arg );
}


//short AcidThroughHeatTempZ1Max1 = 1#酸槽1#加热器温度最大值
short AcidThroughHeatTempZ1Max1(){
	return( ptrPrOrdPro->AcidThroughHeatTempZ1Max1() );
}

void set_AcidThroughHeatTempZ1Max1(short arg  ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ1Max1( arg );
}

short AcidThroughHeatTempZ1Max1Zi() {
	return( ptrPrOrdPro->AcidThroughHeatTempZ1Max1Zi() );
}

void set_AcidThroughHeatTempZ1Max1Zi(short arg ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ1Max1Zi( arg );
}


//short AcidThroughHeatTempZ1Min1 = 1#酸槽1#加热器温度最小值
short AcidThroughHeatTempZ1Min1(){
	return( ptrPrOrdPro->AcidThroughHeatTempZ1Min1() );
}

void set_AcidThroughHeatTempZ1Min1(short arg  ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ1Min1( arg );
}

short AcidThroughHeatTempZ1Min1Zi() {
	return( ptrPrOrdPro->AcidThroughHeatTempZ1Min1Zi() );
}

void set_AcidThroughHeatTempZ1Min1Zi(short arg ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ1Min1Zi( arg );
}


//short AcidThroughHeatTempZ1Avg2 = 1#酸槽2#加热器温度平均值
short AcidThroughHeatTempZ1Avg2(){
	return( ptrPrOrdPro->AcidThroughHeatTempZ1Avg2() );
}

void set_AcidThroughHeatTempZ1Avg2(short arg  ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ1Avg2( arg );
}

short AcidThroughHeatTempZ1Avg2Zi() {
	return( ptrPrOrdPro->AcidThroughHeatTempZ1Avg2Zi() );
}

void set_AcidThroughHeatTempZ1Avg2Zi(short arg ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ1Avg2Zi( arg );
}


//short AcidThroughHeatTempZ1Max2 = 1#酸槽2#加热器温度最大值
short AcidThroughHeatTempZ1Max2(){
	return( ptrPrOrdPro->AcidThroughHeatTempZ1Max2() );
}

void set_AcidThroughHeatTempZ1Max2(short arg  ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ1Max2( arg );
}

short AcidThroughHeatTempZ1Max2Zi() {
	return( ptrPrOrdPro->AcidThroughHeatTempZ1Max2Zi() );
}

void set_AcidThroughHeatTempZ1Max2Zi(short arg ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ1Max2Zi( arg );
}


//short AcidThroughHeatTempZ1Min2 = 1#酸槽2#加热器温度最小值
short AcidThroughHeatTempZ1Min2(){
	return( ptrPrOrdPro->AcidThroughHeatTempZ1Min2() );
}

void set_AcidThroughHeatTempZ1Min2(short arg  ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ1Min2( arg );
}

short AcidThroughHeatTempZ1Min2Zi() {
	return( ptrPrOrdPro->AcidThroughHeatTempZ1Min2Zi() );
}

void set_AcidThroughHeatTempZ1Min2Zi(short arg ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ1Min2Zi( arg );
}


//short AcidThroughHeatTempZ2Avg = 2#酸槽加热器温度平均值
short AcidThroughHeatTempZ2Avg(){
	return( ptrPrOrdPro->AcidThroughHeatTempZ2Avg() );
}

void set_AcidThroughHeatTempZ2Avg(short arg  ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ2Avg( arg );
}

short AcidThroughHeatTempZ2AvgZi() {
	return( ptrPrOrdPro->AcidThroughHeatTempZ2AvgZi() );
}

void set_AcidThroughHeatTempZ2AvgZi(short arg ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ2AvgZi( arg );
}


//short AcidThroughHeatTempZ2Max = 2#酸槽加热器温度最大值
short AcidThroughHeatTempZ2Max(){
	return( ptrPrOrdPro->AcidThroughHeatTempZ2Max() );
}

void set_AcidThroughHeatTempZ2Max(short arg  ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ2Max( arg );
}

short AcidThroughHeatTempZ2MaxZi() {
	return( ptrPrOrdPro->AcidThroughHeatTempZ2MaxZi() );
}

void set_AcidThroughHeatTempZ2MaxZi(short arg ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ2MaxZi( arg );
}


//short AcidThroughHeatTempZ2Min = 2#酸槽加热器温度最小值
short AcidThroughHeatTempZ2Min(){
	return( ptrPrOrdPro->AcidThroughHeatTempZ2Min() );
}

void set_AcidThroughHeatTempZ2Min(short arg  ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ2Min( arg );
}

short AcidThroughHeatTempZ2MinZi() {
	return( ptrPrOrdPro->AcidThroughHeatTempZ2MinZi() );
}

void set_AcidThroughHeatTempZ2MinZi(short arg ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ2MinZi( arg );
}


//short AcidThroughHeatTempZ3Avg = 3#酸槽加热器温度平均值
short AcidThroughHeatTempZ3Avg(){
	return( ptrPrOrdPro->AcidThroughHeatTempZ3Avg() );
}

void set_AcidThroughHeatTempZ3Avg(short arg  ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ3Avg( arg );
}

short AcidThroughHeatTempZ3AvgZi() {
	return( ptrPrOrdPro->AcidThroughHeatTempZ3AvgZi() );
}

void set_AcidThroughHeatTempZ3AvgZi(short arg ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ3AvgZi( arg );
}


//short AcidThroughHeatTempZ3Max = 3#酸槽加热器温度最大值
short AcidThroughHeatTempZ3Max(){
	return( ptrPrOrdPro->AcidThroughHeatTempZ3Max() );
}

void set_AcidThroughHeatTempZ3Max(short arg  ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ3Max( arg );
}

short AcidThroughHeatTempZ3MaxZi() {
	return( ptrPrOrdPro->AcidThroughHeatTempZ3MaxZi() );
}

void set_AcidThroughHeatTempZ3MaxZi(short arg ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ3MaxZi( arg );
}


//short AcidThroughHeatTempZ3Min = 3#酸槽加热器温度最小值
short AcidThroughHeatTempZ3Min(){
	return( ptrPrOrdPro->AcidThroughHeatTempZ3Min() );
}

void set_AcidThroughHeatTempZ3Min(short arg  ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ3Min( arg );
}

short AcidThroughHeatTempZ3MinZi() {
	return( ptrPrOrdPro->AcidThroughHeatTempZ3MinZi() );
}

void set_AcidThroughHeatTempZ3MinZi(short arg ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ3MinZi( arg );
}


//short AcidThroughHeatTempZ4Avg = 4#酸槽加热器温度平均值
short AcidThroughHeatTempZ4Avg(){
	return( ptrPrOrdPro->AcidThroughHeatTempZ4Avg() );
}

void set_AcidThroughHeatTempZ4Avg(short arg  ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ4Avg( arg );
}

short AcidThroughHeatTempZ4AvgZi() {
	return( ptrPrOrdPro->AcidThroughHeatTempZ4AvgZi() );
}

void set_AcidThroughHeatTempZ4AvgZi(short arg ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ4AvgZi( arg );
}


//short AcidThroughHeatTempZ4Max = 4#酸槽加热器温度最大值
short AcidThroughHeatTempZ4Max(){
	return( ptrPrOrdPro->AcidThroughHeatTempZ4Max() );
}

void set_AcidThroughHeatTempZ4Max(short arg  ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ4Max( arg );
}

short AcidThroughHeatTempZ4MaxZi() {
	return( ptrPrOrdPro->AcidThroughHeatTempZ4MaxZi() );
}

void set_AcidThroughHeatTempZ4MaxZi(short arg ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ4MaxZi( arg );
}


//short AcidThroughHeatTempZ4Min = 4#酸槽加热器温度最小值
short AcidThroughHeatTempZ4Min(){
	return( ptrPrOrdPro->AcidThroughHeatTempZ4Min() );
}

void set_AcidThroughHeatTempZ4Min(short arg  ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ4Min( arg );
}

short AcidThroughHeatTempZ4MinZi() {
	return( ptrPrOrdPro->AcidThroughHeatTempZ4MinZi() );
}

void set_AcidThroughHeatTempZ4MinZi(short arg ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ4MinZi( arg );
}


//short AcidThroughHeatTempZ5Avg = 5#酸槽加热器温度平均值
short AcidThroughHeatTempZ5Avg(){
	return( ptrPrOrdPro->AcidThroughHeatTempZ5Avg() );
}

void set_AcidThroughHeatTempZ5Avg(short arg  ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ5Avg( arg );
}

short AcidThroughHeatTempZ5AvgZi() {
	return( ptrPrOrdPro->AcidThroughHeatTempZ5AvgZi() );
}

void set_AcidThroughHeatTempZ5AvgZi(short arg ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ5AvgZi( arg );
}


//short AcidThroughHeatTempZ5Max = 5#酸槽加热器温度最大值
short AcidThroughHeatTempZ5Max(){
	return( ptrPrOrdPro->AcidThroughHeatTempZ5Max() );
}

void set_AcidThroughHeatTempZ5Max(short arg  ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ5Max( arg );
}

short AcidThroughHeatTempZ5MaxZi() {
	return( ptrPrOrdPro->AcidThroughHeatTempZ5MaxZi() );
}

void set_AcidThroughHeatTempZ5MaxZi(short arg ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ5MaxZi( arg );
}


//short AcidThroughHeatTempZ5Min = 5#酸槽加热器温度最小值
short AcidThroughHeatTempZ5Min(){
	return( ptrPrOrdPro->AcidThroughHeatTempZ5Min() );
}

void set_AcidThroughHeatTempZ5Min(short arg  ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ5Min( arg );
}

short AcidThroughHeatTempZ5MinZi() {
	return( ptrPrOrdPro->AcidThroughHeatTempZ5MinZi() );
}

void set_AcidThroughHeatTempZ5MinZi(short arg ){
	ptrPrOrdPro->set_AcidThroughHeatTempZ5MinZi( arg );
}


//short BleaConductAvg = 漂洗槽电导率平均值
short BleaConductAvg(){
	return( ptrPrOrdPro->BleaConductAvg() );
}

void set_BleaConductAvg(short arg  ){
	ptrPrOrdPro->set_BleaConductAvg( arg );
}

short BleaConductAvgZi() {
	return( ptrPrOrdPro->BleaConductAvgZi() );
}

void set_BleaConductAvgZi(short arg ){
	ptrPrOrdPro->set_BleaConductAvgZi( arg );
}


//short BleaConductMax = 漂洗槽电导率最大值
short BleaConductMax(){
	return( ptrPrOrdPro->BleaConductMax() );
}

void set_BleaConductMax(short arg  ){
	ptrPrOrdPro->set_BleaConductMax( arg );
}

short BleaConductMaxZi() {
	return( ptrPrOrdPro->BleaConductMaxZi() );
}

void set_BleaConductMaxZi(short arg ){
	ptrPrOrdPro->set_BleaConductMaxZi( arg );
}


//short BleaConductMin = 漂洗槽电导率最小值
short BleaConductMin(){
	return( ptrPrOrdPro->BleaConductMin() );
}

void set_BleaConductMin(short arg  ){
	ptrPrOrdPro->set_BleaConductMin( arg );
}

short BleaConductMinZi() {
	return( ptrPrOrdPro->BleaConductMinZi() );
}

void set_BleaConductMinZi(short arg ){
	ptrPrOrdPro->set_BleaConductMinZi( arg );
}


//int WastAcheFlowAvg = 废酸流量平均值
int WastAcheFlowAvg(){
	return( ptrPrOrdPro->WastAcheFlowAvg() );
}

void set_WastAcheFlowAvg(int arg  ){
	ptrPrOrdPro->set_WastAcheFlowAvg( arg );
}

short WastAcheFlowAvgZi() {
	return( ptrPrOrdPro->WastAcheFlowAvgZi() );
}

void set_WastAcheFlowAvgZi(short arg ){
	ptrPrOrdPro->set_WastAcheFlowAvgZi( arg );
}


//int WastAcheFlowMax = 废酸流量最大值
int WastAcheFlowMax(){
	return( ptrPrOrdPro->WastAcheFlowMax() );
}

void set_WastAcheFlowMax(int arg  ){
	ptrPrOrdPro->set_WastAcheFlowMax( arg );
}

short WastAcheFlowMaxZi() {
	return( ptrPrOrdPro->WastAcheFlowMaxZi() );
}

void set_WastAcheFlowMaxZi(short arg ){
	ptrPrOrdPro->set_WastAcheFlowMaxZi( arg );
}


//int WastAcheFlowMin = 废酸流量最小值
int WastAcheFlowMin(){
	return( ptrPrOrdPro->WastAcheFlowMin() );
}

void set_WastAcheFlowMin(int arg  ){
	ptrPrOrdPro->set_WastAcheFlowMin( arg );
}

short WastAcheFlowMinZi() {
	return( ptrPrOrdPro->WastAcheFlowMinZi() );
}

void set_WastAcheFlowMinZi(short arg ){
	ptrPrOrdPro->set_WastAcheFlowMinZi( arg );
}


//int WasteLiquidPitPosAvg = 废水坑液位平均值
int WasteLiquidPitPosAvg(){
	return( ptrPrOrdPro->WasteLiquidPitPosAvg() );
}

void set_WasteLiquidPitPosAvg(int arg  ){
	ptrPrOrdPro->set_WasteLiquidPitPosAvg( arg );
}

short WasteLiquidPitPosAvgZi() {
	return( ptrPrOrdPro->WasteLiquidPitPosAvgZi() );
}

void set_WasteLiquidPitPosAvgZi(short arg ){
	ptrPrOrdPro->set_WasteLiquidPitPosAvgZi( arg );
}


//int WasteLiquidPitPosMax = 废水坑液位最大值
int WasteLiquidPitPosMax(){
	return( ptrPrOrdPro->WasteLiquidPitPosMax() );
}

void set_WasteLiquidPitPosMax(int arg  ){
	ptrPrOrdPro->set_WasteLiquidPitPosMax( arg );
}

short WasteLiquidPitPosMaxZi() {
	return( ptrPrOrdPro->WasteLiquidPitPosMaxZi() );
}

void set_WasteLiquidPitPosMaxZi(short arg ){
	ptrPrOrdPro->set_WasteLiquidPitPosMaxZi( arg );
}


//int WasteLiquidPitPosMin = 废水坑液位最小值
int WasteLiquidPitPosMin(){
	return( ptrPrOrdPro->WasteLiquidPitPosMin() );
}

void set_WasteLiquidPitPosMin(int arg  ){
	ptrPrOrdPro->set_WasteLiquidPitPosMin( arg );
}

short WasteLiquidPitPosMinZi() {
	return( ptrPrOrdPro->WasteLiquidPitPosMinZi() );
}

void set_WasteLiquidPitPosMinZi(short arg ){
	ptrPrOrdPro->set_WasteLiquidPitPosMinZi( arg );
}


//int BleaLiquidPitPosAvg = 漂洗水罐液位平均值
int BleaLiquidPitPosAvg(){
	return( ptrPrOrdPro->BleaLiquidPitPosAvg() );
}

void set_BleaLiquidPitPosAvg(int arg  ){
	ptrPrOrdPro->set_BleaLiquidPitPosAvg( arg );
}

short BleaLiquidPitPosAvgZi() {
	return( ptrPrOrdPro->BleaLiquidPitPosAvgZi() );
}

void set_BleaLiquidPitPosAvgZi(short arg ){
	ptrPrOrdPro->set_BleaLiquidPitPosAvgZi( arg );
}


//int BleaLiquidPitPosMax = 漂洗水罐液位最大值
int BleaLiquidPitPosMax(){
	return( ptrPrOrdPro->BleaLiquidPitPosMax() );
}

void set_BleaLiquidPitPosMax(int arg  ){
	ptrPrOrdPro->set_BleaLiquidPitPosMax( arg );
}

short BleaLiquidPitPosMaxZi() {
	return( ptrPrOrdPro->BleaLiquidPitPosMaxZi() );
}

void set_BleaLiquidPitPosMaxZi(short arg ){
	ptrPrOrdPro->set_BleaLiquidPitPosMaxZi( arg );
}


//int BleaLiquidPitPosMin = 漂洗水罐液位最小值
int BleaLiquidPitPosMin(){
	return( ptrPrOrdPro->BleaLiquidPitPosMin() );
}

void set_BleaLiquidPitPosMin(int arg  ){
	ptrPrOrdPro->set_BleaLiquidPitPosMin( arg );
}

short BleaLiquidPitPosMinZi() {
	return( ptrPrOrdPro->BleaLiquidPitPosMinZi() );
}

void set_BleaLiquidPitPosMinZi(short arg ){
	ptrPrOrdPro->set_BleaLiquidPitPosMinZi( arg );
}


//int ReacheFlowAvg = 补充酸流量平均值
int ReacheFlowAvg(){
	return( ptrPrOrdPro->ReacheFlowAvg() );
}

void set_ReacheFlowAvg(int arg  ){
	ptrPrOrdPro->set_ReacheFlowAvg( arg );
}

short ReacheFlowAvgZi() {
	return( ptrPrOrdPro->ReacheFlowAvgZi() );
}

void set_ReacheFlowAvgZi(short arg ){
	ptrPrOrdPro->set_ReacheFlowAvgZi( arg );
}


//int ReacheFlowMax = 补充酸流量大值
int ReacheFlowMax(){
	return( ptrPrOrdPro->ReacheFlowMax() );
}

void set_ReacheFlowMax(int arg  ){
	ptrPrOrdPro->set_ReacheFlowMax( arg );
}

short ReacheFlowMaxZi() {
	return( ptrPrOrdPro->ReacheFlowMaxZi() );
}

void set_ReacheFlowMaxZi(short arg ){
	ptrPrOrdPro->set_ReacheFlowMaxZi( arg );
}


//int ReacheFlowMin = 补充酸流量小值
int ReacheFlowMin(){
	return( ptrPrOrdPro->ReacheFlowMin() );
}

void set_ReacheFlowMin(int arg  ){
	ptrPrOrdPro->set_ReacheFlowMin( arg );
}

short ReacheFlowMinZi() {
	return( ptrPrOrdPro->ReacheFlowMinZi() );
}

void set_ReacheFlowMinZi(short arg ){
	ptrPrOrdPro->set_ReacheFlowMinZi( arg );
}




};
#endif