public FormOpenSchedule(ConditionSchedule sch)
        {
            InitializeComponent();

            defSch = sch;
            Initialize();
        }
Beispiel #2
0
        private void RefreshContext()
        {
            if (InvalidContext == false)
            {
                return;
            }

            try
            {
                ConditionSchedule sch    = context.Condition.Schedules[context.Index];
                ConditionMethod   method = context.Condition.Method;

                context.RefreshCondition();
                context.Report.RefreshCondition();
                context.Value.Integral.Initialize(method.ScanTime, method.IntegralTime, sch);

                sheetArgs.Index = EWorkSheet.Title;
                OnSetSpreadSheet();

                descArgs.Name           = sch.Name;
                descArgs.RepeatMax      = sch.Repeat;
                descArgs.PrepareMaxTime = sch.PreRun * csOneMiniteMsec;
                descArgs.JudgeMaxTime   = sch.Judge * csOneMiniteMsec;
                descArgs.JudgeMax       = sch.NoOfSteady;

                OnDispState();
            }
            finally
            {
                InvalidContext = false;
            }
        }
Beispiel #3
0
        public void Initialize(int scanTime, int integTime, ConditionSchedule sch)
        {
            lock (this)
            {
                Sheets["Judge"]["Total.IDU.Voltage"].Set(sch.OutdoorVolt1, sch.OutdoorVolt1Avg, sch.OutdoorVolt1Dev, scanTime);
                Sheets["Judge"]["Total.ODU.Voltage"].Set(sch.OutdoorVolt2, sch.OutdoorVolt2Avg, sch.OutdoorVolt2Dev, scanTime);

                Sheets["Judge"]["ID11.Entering.DB"].Set(sch.Indoor1DB, sch.Indoor1DBAvg, sch.Indoor1DBDev, scanTime);
                Sheets["Judge"]["ID11.Entering.WB"].Set(sch.Indoor1WB, sch.Indoor1WBAvg, sch.Indoor1WBDev, scanTime);
                Sheets["Judge"]["ID11.Leaving.DB"].Set(0, float.NaN, sch.Indoor1LDB1Dev, scanTime);
                Sheets["Judge"]["ID11.Leaving.WB"].Set(0, float.NaN, sch.Indoor1LWB1Dev, scanTime);
                Sheets["Judge"]["ID11.Air.Flow.Lev"].Set(0, float.NaN, sch.Indoor1AirFlow1Dev, scanTime);
                Sheets["Judge"]["ID11.Static.Pressure"].Set(sch.Indoor1CP1, sch.Indoor1CP1Avg, sch.Indoor1CP1Dev, scanTime);

                Sheets["Judge"]["ID12.Entering.DB"].Set(sch.Indoor1DB, sch.Indoor1DBAvg, sch.Indoor1DBDev, scanTime);
                Sheets["Judge"]["ID12.Entering.WB"].Set(sch.Indoor1WB, sch.Indoor1WBAvg, sch.Indoor1WBDev, scanTime);
                Sheets["Judge"]["ID12.Leaving.DB"].Set(0, float.NaN, sch.Indoor1LDB2Dev, scanTime);
                Sheets["Judge"]["ID12.Leaving.WB"].Set(0, float.NaN, sch.Indoor1LWB2Dev, scanTime);
                Sheets["Judge"]["ID12.Air.Flow.Lev"].Set(0, float.NaN, sch.Indoor1AirFlow2Dev, scanTime);
                Sheets["Judge"]["ID12.Static.Pressure"].Set(sch.Indoor1CP2, sch.Indoor1CP2Avg, sch.Indoor1CP2Dev, scanTime);

                Sheets["Judge"]["ID21.Entering.DB"].Set(sch.Indoor2DB, sch.Indoor2DBAvg, sch.Indoor2DBDev, scanTime);
                Sheets["Judge"]["ID21.Entering.WB"].Set(sch.Indoor2WB, sch.Indoor2WBAvg, sch.Indoor2WBDev, scanTime);
                Sheets["Judge"]["ID21.Leaving.DB"].Set(0, float.NaN, sch.Indoor2LDB1Dev, scanTime);
                Sheets["Judge"]["ID21.Leaving.WB"].Set(0, float.NaN, sch.Indoor2LWB1Dev, scanTime);
                Sheets["Judge"]["ID21.Air.Flow.Lev"].Set(0, float.NaN, sch.Indoor2AirFlow1Dev, scanTime);
                Sheets["Judge"]["ID21.Static.Pressure"].Set(sch.Indoor2CP1, sch.Indoor2CP1Avg, sch.Indoor2CP1Dev, scanTime);

                Sheets["Judge"]["ID22.Entering.DB"].Set(sch.Indoor2DB, sch.Indoor2DBAvg, sch.Indoor2DBDev, scanTime);
                Sheets["Judge"]["ID22.Entering.WB"].Set(sch.Indoor2WB, sch.Indoor2WBAvg, sch.Indoor2WBDev, scanTime);
                Sheets["Judge"]["ID22.Leaving.DB"].Set(0, float.NaN, sch.Indoor2LDB2Dev, scanTime);
                Sheets["Judge"]["ID22.Leaving.WB"].Set(0, float.NaN, sch.Indoor2LWB2Dev, scanTime);
                Sheets["Judge"]["ID22.Air.Flow.Lev"].Set(0, float.NaN, sch.Indoor2AirFlow2Dev, scanTime);
                Sheets["Judge"]["ID22.Static.Pressure"].Set(sch.Indoor2CP2, sch.Indoor2CP2Avg, sch.Indoor2CP2Dev, scanTime);

                Sheets["Judge"]["OD.Entering.DB"].Set(sch.OutdoorDB, sch.OutdoorDBAvg, sch.OutdoorDBDev, scanTime);
                Sheets["Judge"]["OD.Entering.WB"].Set(sch.OutdoorWB, sch.OutdoorWBAvg, sch.OutdoorWBDev, scanTime);
                Sheets["Judge"]["OD.Entering.DP"].Set(sch.OutdoorDP, sch.OutdoorDPAvg, sch.OutdoorDPDev, scanTime);

                IgnoreJudgement = IsAllZero("Judge");

                foreach (KeyValuePair <string, IntegralValues> sheet in Sheets)
                {
                    if (sheet.Key == "Judge")
                    {
                        continue;
                    }

                    foreach (KeyValuePair <string, IntegralValue> row in sheet.Value.Values)
                    {
                        row.Value.Set(0, 0, 0, scanTime, integTime * 60);
                    }
                }
            }
        }
Beispiel #4
0
        public void RefreshCondition()
        {
            ConditionSchedule sch = context.Condition.Schedules[context.Index];

            ConditionNote note = context.Condition.Note;

            Note.Company     = note.Company;
            Note.Name        = note.Name;
            Note.No          = note.No;
            Note.Observer    = note.Observer;
            Note.Maker       = note.Maker;
            Note.Model1      = note.Model1;
            Note.Serial1     = note.Serial1;
            Note.Model2      = note.Model2;
            Note.Serial2     = note.Serial2;
            Note.Model3      = note.Model3;
            Note.Serial3     = note.Serial3;
            Note.ExpDevice   = note.ExpDevice;
            Note.Refrigerant = note.Refrigerant;
            Note.RefCharge   = note.RefCharge;
            Note.Memo        = note.Memo;

            EIndoorMode mode = sch.IndoorMode;

            if (mode == EIndoorMode.NotUsed)
            {
                mode = EIndoorMode.Cooling;
            }

            ConditionRated rated = context.Condition.Rateds[EConditionRated.Total][(int)mode];

            Rated.Capacity   = rated.Capacity;
            Rated.PowerInput = rated.PowerInput;
            Rated.EER_COP    = rated.EER_COP;
            Rated.Voltage    = rated.Voltage;
            Rated.Current    = rated.Current;
            Rated.Frequency  = rated.Frequency;
            Rated.PM_IDU     = rated.PM_IDU;
            Rated.PM_ODU     = rated.PM_ODU;
            Rated.Wiring     = rated.Wiring;

            (ValueSheets["ID A #1"] as ReportCalorieSheet).Set(sch.Indoor1DB, sch.Indoor1WB, sch.OutdoorDB, sch.OutdoorWB);
            (ValueSheets["ID A #2"] as ReportCalorieSheet).Set(sch.Indoor1DB, sch.Indoor1WB, sch.OutdoorDB, sch.OutdoorWB);
            (ValueSheets["ID B #1"] as ReportCalorieSheet).Set(sch.Indoor2DB, sch.Indoor2WB, sch.OutdoorDB, sch.OutdoorWB);
            (ValueSheets["ID B #2"] as ReportCalorieSheet).Set(sch.Indoor2DB, sch.Indoor2WB, sch.OutdoorDB, sch.OutdoorWB);
            (ValueSheets["ID A TC"] as ReportThermoSheet).Set(sch.Indoor1DB, sch.Indoor1WB, sch.OutdoorDB, sch.OutdoorWB);
            (ValueSheets["ID A TC"] as ReportThermoSheet).Reinitialize();
            (ValueSheets["ID B TC"] as ReportThermoSheet).Set(sch.Indoor2DB, sch.Indoor2WB, sch.OutdoorDB, sch.OutdoorWB);
            (ValueSheets["ID B TC"] as ReportThermoSheet).Reinitialize();
            (ValueSheets["OD TC"] as ReportThermoSheet).Set(sch.Indoor1DB, sch.Indoor1WB, sch.OutdoorDB, sch.OutdoorWB);
            (ValueSheets["OD TC"] as ReportThermoSheet).Reinitialize();
        }
Beispiel #5
0
        private void LoadSchedule(int paramNo)
        {
            ScheduleParamDataSet schSet = Context.DB.ScheduleParamSet;

            schSet.SelectOrderByRecNo(paramNo);
            Context.Condition.Schedules.Clear();

            for (int i = 0; i < schSet.GetRowCount(); i++)
            {
                ConditionSchedule sch = new ConditionSchedule(Context.Condition.Schedules.Count + 1);
                schSet.Fetch(i);
                SetSchedule(sch, schSet);
                Context.Condition.Schedules.Add(sch);
            }
        }
Beispiel #6
0
        private void DoJudgement(ConditionSchedule sch)
        {
            bool repeat = true;

            try
            {
                while (repeat == true)
                {
                    try
                    {
                        descArgs.Step         = ETestStep.Judgement;
                        descArgs.JudgeMax     = sch.NoOfSteady;
                        descArgs.JudgeCount   = 0;
                        descArgs.JudgeMaxTime = sch.Judge * csOneMiniteMsec;
                        descArgs.JudgeCurTime = 0;
                        OnDispState();

                        Judgement();
                        repeat = false;
                    }
                    catch (UlThreadTerminatedException e)
                    {
                        ClearCurrentValues();

                        switch ((ETestMessage)e.Code)
                        {
                        case ETestMessage.None:
                            throw e;

                        case ETestMessage.Next:
                            repeat = false;
                            break;

                        case ETestMessage.Reset:
                            repeat = true;
                            break;
                        }
                    }
                }
            }
            finally
            {
                context.Value.Integral.Clear("Judge");
            }
        }
Beispiel #7
0
        private void OpenScheduleDialog(ConditionSchedule sch)
        {
            FormOpenSchedule form = new FormOpenSchedule(sch);

            if (form.ShowDialog() == DialogResult.OK)
            {
                if (form.ScheduleGridView.FocusedRowHandle >= 0)
                {
                    AdvBandedGridView view = Context.Condition.Control.ScheduleGridView;
                    ConditionSchedule row  = Context.Condition.Schedules[view.FocusedRowHandle];

                    form.standardEdit.Focus();
                    SetScheduleByForm(row, form);

                    view.RefreshData();
                    Context.Condition.Control.noteCompanyEdit.Focus();
                    view.Focus();
                }
            }
        }
Beispiel #8
0
        private void DoPreparation(ConditionSchedule sch)
        {
            bool repeat = true;

            descArgs.Step = ETestStep.Preparation;

            while (repeat == true)
            {
                try
                {
                    descArgs.Step           = ETestStep.Preparation;
                    descArgs.PrepareMaxTime = sch.PreRun * csOneMiniteMsec;
                    descArgs.PrepareCurTime = 0;
                    OnDispState();

                    Preparation();
                    repeat = false;
                }
                catch (UlThreadTerminatedException e)
                {
                    ClearCurrentValues();

                    switch ((ETestMessage)e.Code)
                    {
                    case ETestMessage.None:
                        throw e;

                    case ETestMessage.Next:
                        repeat = false;
                        break;

                    case ETestMessage.Reset:
                        repeat = true;
                        break;
                    }
                }
            }
        }
Beispiel #9
0
        private void SetScheduleByForm(ConditionSchedule sch, FormOpenSchedule form)
        {
            sch.Standard   = form.standardEdit.Text;
            sch.Name       = form.nameEdit.Text;
            sch.NoOfSteady = int.Parse(form.noSteadyEdit.Text);
            sch.PreRun     = int.Parse(form.preparationEdit.Text);
            sch.Judge      = int.Parse(form.judgementEdit.Text);
            sch.Repeat     = int.Parse(form.repeatEdit.Text);

            sch.Indoor1Use         = form.Chambers[0].Indoor1Use;
            sch.Indoor1Mode1       = form.Chambers[0].Indoor1Mode1;
            sch.Indoor1Duct1       = form.Chambers[0].Indoor1Duct1;
            sch.Indoor1Mode2       = form.Chambers[0].Indoor1Mode2;
            sch.Indoor1Duct2       = form.Chambers[0].Indoor1Duct2;
            sch.Indoor1DB          = float.Parse(form.id1EdbSetupEdit.Text);
            sch.Indoor1DBAvg       = float.Parse(form.id1EdbAvgEdit.Text);
            sch.Indoor1DBDev       = float.Parse(form.id1EdbDevEdit.Text);
            sch.Indoor1WB          = float.Parse(form.id1EwbSetupEdit.Text);
            sch.Indoor1WBAvg       = float.Parse(form.id1EwbAvgEdit.Text);
            sch.Indoor1WBDev       = float.Parse(form.id1EwbDevEdit.Text);
            sch.Indoor1LDB1Dev     = float.Parse(form.id1Ldb1DevEdit.Text);
            sch.Indoor1LWB1Dev     = float.Parse(form.id1Lwb1DevEdit.Text);
            sch.Indoor1AirFlow1Dev = float.Parse(form.id1Airflow1DevEdit.Text);
            sch.Indoor1LDB2Dev     = float.Parse(form.id1Ldb2DevEdit.Text);
            sch.Indoor1LWB2Dev     = float.Parse(form.id1Lwb2DevEdit.Text);
            sch.Indoor1AirFlow2Dev = float.Parse(form.id1Airflow2DevEdit.Text);
            sch.Indoor1CP1         = float.Parse(form.id1Cdp1SetupEdit.Text);
            sch.Indoor1CP1Avg      = float.Parse(form.id1Cdp1AvgEdit.Text);
            sch.Indoor1CP1Dev      = float.Parse(form.id1Cdp1DevEdit.Text);
            sch.Indoor1CP2         = float.Parse(form.id1Cdp2SetupEdit.Text);
            sch.Indoor1CP2Avg      = float.Parse(form.id1Cdp2AvgEdit.Text);
            sch.Indoor1CP2Dev      = float.Parse(form.id1Cdp2DevEdit.Text);

            sch.Indoor2Use         = form.Chambers[0].Indoor2Use;
            sch.Indoor2Mode1       = form.Chambers[0].Indoor2Mode1;
            sch.Indoor2Duct1       = form.Chambers[0].Indoor2Duct1;
            sch.Indoor2Mode2       = form.Chambers[0].Indoor2Mode2;
            sch.Indoor2Duct2       = form.Chambers[0].Indoor2Duct2;
            sch.Indoor2DB          = float.Parse(form.id2EdbSetupEdit.Text);
            sch.Indoor2DBAvg       = float.Parse(form.id2EdbAvgEdit.Text);
            sch.Indoor2DBDev       = float.Parse(form.id2EdbDevEdit.Text);
            sch.Indoor2WB          = float.Parse(form.id2EwbSetupEdit.Text);
            sch.Indoor2WBAvg       = float.Parse(form.id2EwbAvgEdit.Text);
            sch.Indoor2WBDev       = float.Parse(form.id2EwbDevEdit.Text);
            sch.Indoor2LDB1Dev     = float.Parse(form.id2Ldb1DevEdit.Text);
            sch.Indoor2LWB1Dev     = float.Parse(form.id2Lwb1DevEdit.Text);
            sch.Indoor2AirFlow1Dev = float.Parse(form.id2Airflow1DevEdit.Text);
            sch.Indoor2LDB2Dev     = float.Parse(form.id2Ldb2DevEdit.Text);
            sch.Indoor2LWB2Dev     = float.Parse(form.id2Lwb2DevEdit.Text);
            sch.Indoor2AirFlow2Dev = float.Parse(form.id2Airflow2DevEdit.Text);
            sch.Indoor2CP1         = float.Parse(form.id2Cdp1SetupEdit.Text);
            sch.Indoor2CP1Avg      = float.Parse(form.id2Cdp1AvgEdit.Text);
            sch.Indoor2CP1Dev      = float.Parse(form.id2Cdp1DevEdit.Text);
            sch.Indoor2CP2         = float.Parse(form.id2Cdp2SetupEdit.Text);
            sch.Indoor2CP2Avg      = float.Parse(form.id2Cdp2AvgEdit.Text);
            sch.Indoor2CP2Dev      = float.Parse(form.id2Cdp2DevEdit.Text);

            sch.OutdoorUse      = form.Chambers[0].OutdoorUse;
            sch.OutdoorDpSensor = form.Chambers[0].OutdoorDpSensor;
            sch.OutdoorAutoVolt = form.Chambers[0].OutdoorAutoVolt;
            sch.OutdoorDB       = float.Parse(form.odEdbSetupEdit.Text);
            sch.OutdoorDBAvg    = float.Parse(form.odEdbAvgEdit.Text);
            sch.OutdoorDBDev    = float.Parse(form.odEdbDevEdit.Text);
            sch.OutdoorWB       = float.Parse(form.odEwbSetupEdit.Text);
            sch.OutdoorWBAvg    = float.Parse(form.odEwbAvgEdit.Text);
            sch.OutdoorWBDev    = float.Parse(form.odEdpDevEdit.Text);
            sch.OutdoorDP       = float.Parse(form.odEdpSetupEdit.Text);
            sch.OutdoorDPAvg    = float.Parse(form.odEdpAvgEdit.Text);
            sch.OutdoorDPDev    = float.Parse(form.odEdpDevEdit.Text);
            sch.OutdoorVolt1    = float.Parse(form.odVolt1SetupEdit.Text);
            sch.OutdoorVolt1Avg = float.Parse(form.odVolt1AvgEdit.Text);
            sch.OutdoorVolt1Dev = float.Parse(form.odVolt1DevEdit.Text);
            sch.OutdoorVolt2    = float.Parse(form.odVolt2SetupEdit.Text);
            sch.OutdoorVolt2Avg = float.Parse(form.odVolt2AvgEdit.Text);
            sch.OutdoorVolt2Dev = float.Parse(form.odVolt2DevEdit.Text);
        }
Beispiel #10
0
        private void SetSchedule(ConditionSchedule sch, ScheduleParamDataSet schSet)
        {
            sch.Standard   = schSet.Standard;
            sch.Name       = schSet.Name;
            sch.NoOfSteady = schSet.NoOfSteady;
            sch.PreRun     = schSet.Preparation;
            sch.Judge      = schSet.Judgement;
            sch.Repeat     = schSet.Repeat;

            sch.Indoor1Use         = schSet.ID1Use;
            sch.Indoor1Mode1       = schSet.ID1Mode1;
            sch.Indoor1Duct1       = schSet.ID1Duct1;
            sch.Indoor1Mode2       = schSet.ID1Mode2;
            sch.Indoor1Duct2       = schSet.ID1Duct2;
            sch.Indoor1DB          = schSet.ID1EdbSetup;
            sch.Indoor1DBAvg       = schSet.ID1EdbAvg;
            sch.Indoor1DBDev       = schSet.ID1EdbDev;
            sch.Indoor1WB          = schSet.ID1EwbSetup;
            sch.Indoor1WBAvg       = schSet.ID1EwbAvg;
            sch.Indoor1WBDev       = schSet.ID1EwbDev;
            sch.Indoor1LDB1Dev     = schSet.ID1Ldb1Dev;
            sch.Indoor1LWB1Dev     = schSet.ID1Lwb1Dev;;
            sch.Indoor1AirFlow1Dev = schSet.ID1Af1Dev;
            sch.Indoor1LDB2Dev     = schSet.ID1Ldb2Dev;
            sch.Indoor1LWB2Dev     = schSet.ID1Lwb2Dev;;
            sch.Indoor1AirFlow2Dev = schSet.ID1Af2Dev;
            sch.Indoor1CP1         = schSet.ID1Cdp1Setup;
            sch.Indoor1CP1Avg      = schSet.ID1Cdp1Avg;
            sch.Indoor1CP1Dev      = schSet.ID1Cdp1Dev;
            sch.Indoor1CP2         = schSet.ID1Cdp2Setup;
            sch.Indoor1CP2Avg      = schSet.ID1Cdp2Avg;
            sch.Indoor1CP2Dev      = schSet.ID1Cdp2Dev;

            sch.Indoor2Use         = schSet.ID2Use;
            sch.Indoor2Mode1       = schSet.ID2Mode1;
            sch.Indoor2Duct1       = schSet.ID2Duct1;
            sch.Indoor2Mode2       = schSet.ID2Mode2;
            sch.Indoor2Duct2       = schSet.ID2Duct2;
            sch.Indoor2DB          = schSet.ID2EdbSetup;
            sch.Indoor2DBAvg       = schSet.ID2EdbAvg;
            sch.Indoor2DBDev       = schSet.ID2EdbDev;
            sch.Indoor2WB          = schSet.ID2EwbSetup;
            sch.Indoor2WBAvg       = schSet.ID2EwbAvg;
            sch.Indoor2WBDev       = schSet.ID2EwbDev;
            sch.Indoor2LDB1Dev     = schSet.ID2Ldb1Dev;
            sch.Indoor2LWB1Dev     = schSet.ID2Lwb1Dev;;
            sch.Indoor2AirFlow1Dev = schSet.ID2Af1Dev;
            sch.Indoor2LDB2Dev     = schSet.ID2Ldb2Dev;
            sch.Indoor2LWB2Dev     = schSet.ID2Lwb2Dev;;
            sch.Indoor2AirFlow2Dev = schSet.ID2Af2Dev;
            sch.Indoor2CP1         = schSet.ID2Cdp1Setup;
            sch.Indoor2CP1Avg      = schSet.ID2Cdp1Avg;
            sch.Indoor2CP1Dev      = schSet.ID2Cdp1Dev;
            sch.Indoor2CP2         = schSet.ID2Cdp2Setup;
            sch.Indoor2CP2Avg      = schSet.ID2Cdp2Avg;
            sch.Indoor2CP2Dev      = schSet.ID2Cdp2Dev;

            sch.OutdoorUse      = schSet.ODUse;
            sch.OutdoorDpSensor = schSet.ODDp;
            sch.OutdoorAutoVolt = schSet.ODAutoVolt;
            sch.OutdoorDB       = schSet.ODEdbSetup;
            sch.OutdoorDBAvg    = schSet.ODEdbAvg;
            sch.OutdoorDBDev    = schSet.ODEdbDev;
            sch.OutdoorWB       = schSet.ODEwbSetup;
            sch.OutdoorWBAvg    = schSet.ODEwbAvg;
            sch.OutdoorWBDev    = schSet.ODEwbDev;
            sch.OutdoorDP       = schSet.ODEdpSetup;
            sch.OutdoorDPAvg    = schSet.ODEdpAvg;
            sch.OutdoorDPDev    = schSet.ODEdpDev;
            sch.OutdoorVolt1    = schSet.ODVolt1Setup;
            sch.OutdoorVolt1Avg = schSet.ODVolt1Avg;
            sch.OutdoorVolt1Dev = schSet.ODVolt1Dev;
            sch.OutdoorVolt2    = schSet.ODVolt2Setup;
            sch.OutdoorVolt2Avg = schSet.ODVolt2Avg;
            sch.OutdoorVolt2Dev = schSet.ODVolt2Dev;
        }
Beispiel #11
0
        public void Initialize()
        {
            RecNo   = -1;
            RegTime = DateTime.Now;

            ConditionSchedule sch = context.Condition.Schedules[context.Index];
            ReportSheet       sheet;

            ConditionMethod method = context.Condition.Method;

            Method.IntegralCount         = method.IntegralCount;
            Method.IntegralTime          = method.IntegralTime;
            Method.ScanTime              = method.ScanTime;
            Method.CoolingCapacity       = method.CoolingCapacity;
            Method.HeatingCapacity       = method.HeatingCapacity;
            Method.AirFlow               = method.AirFlow;
            Method.Enthalpy              = method.Enthalpy;
            Method.Pressure              = method.Pressure;
            Method.DiffPressure          = method.DiffPressure;
            Method.AtmPressure           = method.AtmPressure;
            Method.AutoControllerSetting = method.AutoControllerSetting;
            Method.UsePowerMeterIntegral = method.UsePowerMeterIntegral;

            ConditionNote note = context.Condition.Note;

            Note.Company     = note.Company;
            Note.Name        = note.Name;
            Note.No          = note.No;
            Note.Observer    = note.Observer;
            Note.Maker       = note.Maker;
            Note.Model1      = note.Model1;
            Note.Serial1     = note.Serial1;
            Note.Model2      = note.Model2;
            Note.Serial2     = note.Serial2;
            Note.Model3      = note.Model3;
            Note.Serial3     = note.Serial3;
            Note.ExpDevice   = note.ExpDevice;
            Note.Refrigerant = note.Refrigerant;
            Note.RefCharge   = note.RefCharge;
            Note.Memo        = note.Memo;

            EIndoorMode mode = sch.IndoorMode;

            if (mode == EIndoorMode.NotUsed)
            {
                mode = EIndoorMode.Cooling;
            }

            EUnitCapacity unitCapa = (mode == EIndoorMode.Cooling) ? method.CoolingCapacity : method.HeatingCapacity;

            context.Value.SetUnitTo(EUnitType.Capacity, (int)unitCapa);
            context.Value.SetUnitTo(EUnitType.EER_COP, (int)unitCapa);

            ConditionRated rated = context.Condition.Rateds[EConditionRated.Total][(int)mode];

            Rated.Capacity   = rated.Capacity;
            Rated.PowerInput = rated.PowerInput;
            Rated.EER_COP    = rated.EER_COP;
            Rated.Voltage    = rated.Voltage;
            Rated.Current    = rated.Current;
            Rated.Frequency  = rated.Frequency;
            Rated.PM_IDU     = rated.PM_IDU;
            Rated.PM_ODU     = rated.PM_ODU;
            Rated.Wiring     = rated.Wiring;

            lock (ValueSheets)
            {
                string nozzleName;
                string nozzleState = "O,O,O,O";
                List <CoefficientDataRow> coeff = Resource.Settings.Coefficients;

                ValueSheets.Clear();

                nozzleName = $"Nozzle ({coeff[0].Nozzle1:f0}/{coeff[0].Nozzle2:f0}/{coeff[0].Nozzle3:f0}/{coeff[0].Nozzle4:f0})";
                sheet      = new ReportCalorieSheet(context, "ID1", "ID11",
                                                    sch.Indoor1DB, sch.Indoor1WB, sch.Indoor1Use, sch.Indoor1Mode1,
                                                    sch.OutdoorDB, sch.OutdoorWB, sch.OutdoorUse, sch.OutdoorDpSensor,
                                                    nozzleName, nozzleState);
                sheet.Use = (sch.Indoor1Use == EIndoorUse.Indoor) ? true : false;
                ValueSheets.Add("ID A #1", sheet);

                nozzleName = $"Nozzle ({coeff[1].Nozzle1:f0}/{coeff[1].Nozzle2:f0}/{coeff[1].Nozzle3:f0}/{coeff[1].Nozzle4:f0})";
                sheet      = new ReportCalorieSheet(context, "ID1", "ID12",
                                                    sch.Indoor1DB, sch.Indoor1WB, sch.Indoor1Use, sch.Indoor1Mode2,
                                                    sch.OutdoorDB, sch.OutdoorWB, sch.OutdoorUse, sch.OutdoorDpSensor,
                                                    nozzleName, nozzleState);
                sheet.Use = (sch.Indoor1Use == EIndoorUse.Indoor) ? true : false;
                ValueSheets.Add("ID A #2", sheet);

                nozzleName = $"Nozzle ({coeff[2].Nozzle1:f0}/{coeff[2].Nozzle2:f0}/{coeff[2].Nozzle3:f0}/{coeff[2].Nozzle4:f0})";
                sheet      = new ReportCalorieSheet(context, "ID2", "ID21",
                                                    sch.Indoor2DB, sch.Indoor2WB, sch.Indoor2Use, sch.Indoor2Mode1,
                                                    sch.OutdoorDB, sch.OutdoorWB, sch.OutdoorUse, sch.OutdoorDpSensor,
                                                    nozzleName, nozzleState);
                sheet.Use = (sch.Indoor2Use == EIndoorUse.Indoor) ? true : false;
                ValueSheets.Add("ID B #1", sheet);

                nozzleName = $"Nozzle ({coeff[3].Nozzle1:f0}/{coeff[3].Nozzle2:f0}/{coeff[3].Nozzle3:f0}/{coeff[3].Nozzle4:f0})";
                sheet      = new ReportCalorieSheet(context, "ID2", "ID22",
                                                    sch.Indoor2DB, sch.Indoor2WB, sch.Indoor2Use, sch.Indoor2Mode2,
                                                    sch.OutdoorDB, sch.OutdoorWB, sch.OutdoorUse, sch.OutdoorDpSensor,
                                                    nozzleName, nozzleState);
                sheet.Use = (sch.Indoor2Use == EIndoorUse.Indoor) ? true : false;
                ValueSheets.Add("ID B #2", sheet);

                sheet = new ReportThermoSheet(context, "ID1", "",
                                              sch.Indoor1DB, sch.Indoor1WB, sch.Indoor1Use, sch.Indoor1Mode1,
                                              sch.OutdoorDB, sch.OutdoorWB, sch.OutdoorUse, sch.OutdoorDpSensor, "", "");
                if (sheet.Use == true)
                {
                    sheet.Use = (sch.Indoor1Use == EIndoorUse.Indoor) ? true : false;
                }
                ValueSheets.Add("ID A TC", sheet);

                sheet = new ReportThermoSheet(context, "ID2", "",
                                              sch.Indoor2DB, sch.Indoor2WB, sch.Indoor2Use, sch.Indoor2Mode1,
                                              sch.OutdoorDB, sch.OutdoorWB, sch.OutdoorUse, sch.OutdoorDpSensor, "", "");
                if (sheet.Use == true)
                {
                    sheet.Use = (sch.Indoor2Use == EIndoorUse.Indoor) ? true : false;
                }
                ValueSheets.Add("ID B TC", sheet);

                sheet = new ReportThermoSheet(context, "OD", "",
                                              sch.Indoor1DB, sch.Indoor1WB, sch.Indoor1Use, sch.Indoor1Mode1,
                                              sch.OutdoorDB, sch.OutdoorWB, sch.OutdoorUse, sch.OutdoorDpSensor, "", "");
                if (sheet.Use == true)
                {
                    sheet.Use = (sch.OutdoorUse == EOutdoorUse.Outdoor) ? true : false;
                }
                ValueSheets.Add("OD TC", sheet);
            }

            DataRaw.Clear();

            foreach (KeyValuePair <string, ValueRow> row in context.Value.Calcurated)
            {
                if (row.Value.Save == true)
                {
                    DataRaw.Rows.Add(row.Key, new DataRaw(-1, row.Value));
                }
            }

            foreach (KeyValuePair <string, ValueRow> row in context.Value.Measured)
            {
                if (row.Value.Save == true)
                {
                    DataRaw.Rows.Add(row.Key, new DataRaw(-1, row.Value));
                }
            }

            DataRaw.Count = DataRaw.Rows.Count / 600;
            if ((DataRaw.Rows.Count % 600) != 0)
            {
                DataRaw.Count++;
            }
        }