cloudpss 3.2.0a2__py3-none-any.whl → 4.0.0a5__py3-none-any.whl

cloudpss/ieslab/EvaluationModel.py

@@ -0,0 +1,189 @@
+import time
+from cloudpss.runner.runner import HttpRunner, Runner
+from cloudpss.runner.IESLabEvaluationResult import IESLabEvaluationResult
+from ..utils import request
+import json
+from enum import IntEnum, unique
+
+class IESLabEvaluationModel(object):
+    _baseUri = 'api/ieslab-plan/rest/'
+    _taskUri = 'api/ieslab-plan/taskmanager/getSimuLastTasks'
+    _kindNameMap = {
+        "投资组成": "investmentbanchandproportion",
+        "资金来源": "capitalsource",
+        "资产形式": "assetformation",
+        "生产成本": "productioncost",
+        "流动资金及财务费用": "workingcapitalandfinancialexpenses",
+        "税率及附加": "projectcalculation",
+    }
+
+    # 财务评价基础参数接口默认值
+    _financialParasDefaultValues = {
+        "资产形式": {
+            "fixedAssetsRatio": "95",
+            "residualRrate": "5",
+            "depreciationPeriod": "15",
+            "reimbursementPeriod": "5"
+        },
+        "生产成本": {
+            'annualSalary': "8",
+            'capacity': "4",
+            'insuranceRate': "0.25",
+            'materialsExpenses': "5.0",
+            'otherExpenses': "1.0",
+            'welfareFactor': "0"
+        },
+        "流动资金及财务费用": {
+            "annualAPCirculationTimes": "12",
+            "annualARCirculationTimes": "12",
+            "annualCashCirculationTimes": "12",
+            "annualStockCirculationTimes": "12",
+            "interestRateAndWorkingCapital": "4",
+            "workingCapitalLoanRatio": "70"
+        },
+        "税率及附加": {
+            "aleatoricAccumulationFundRate": "0",
+            "basicDiscountRate": "8",
+            "cityMaintenanceConstructionTaxTate": "5",
+            "corporateIncomeTaxRate": "25",
+            "educationFeePlus": "5",
+            "electricityVATRate": "18",
+            "fuelBoughtVATRate": "10",
+            "hotColdVATRate": "12",
+            "legalAccumulationFundRate": "10",
+            "localEducationPlus": "2",
+            "materialBoughtVATRate": "17",
+            "steamSaleVATRate": "12"
+        }
+    }
+
+    # 评价基础参数接口默认值
+    _evaluationType = {
+        "环保评价": "environmentalEvaluation",
+        "能效评价": "energyEvaluation"
+    }
+
+    def __init__(self, simulationId):
+        '''
+            初始化
+        '''
+        self.simulationId = simulationId
+
+    def _saveItemData(self, url, data):
+        '''
+            保存url链接对应的优化方案下财务评估模块的基础信息
+            :param url string类型，表示优化方案的接口链接
+
+            :return: dict 类型，代表方案对应的财务评价基础参数信息
+        '''
+        r = request('POST', url, data=json.dumps(data))
+        dataList = json.loads(r.text)
+        return dataList
+
+    def _fetchItemData(self, url, planID):
+        '''
+            获取planID对应的优化方案下财务评估模块的基础信息
+            :param planID int类型，表示优化方案的ID，数值位于0~优化方案数量之间
+
+            :return: dict 类型，为源数据的引用，代表方案对应的财务评价基础参数信息
+        '''
+        r = request('GET',
+                    url,
+                    params={
+                        "simu_id": self.simulationId,
+                        "planId": planID,
+                    })
+        data = json.loads(r.text)
+        return data
+
+    def GetFinancialParams(self, planID):
+        '''
+            获取planID对应的优化方案下财务评估模块的基础信息
+            :param planID int类型，表示优化方案的ID，数值位于0~优化方案数量之间
+
+            :return: dict 类型，为源数据的引用，代表方案对应的财务评价基础参数信息
+        '''
+        dict_result = dict()
+        for k, v in self._kindNameMap.items():
+            kind = self._kindNameMap.get(k, k)
+            url = self._baseUri + kind + '/'
+            list = self._fetchItemData(url, planID)
+            if (len(list['results']) == 0):
+                data = {
+                    "simu": self.simulationId,
+                    "planId": planID,
+                }
+                if (k in self._financialParasDefaultValues):
+                    data.update(self._financialParasDefaultValues[k])
+                    res = self._saveItemData(url, data)
+                    dict_result[v] = res
+                else:
+                    pass
+            else:
+                dict_result[v] = list['results']
+        return dict_result
+
+    def run(self, planID, type=None) -> Runner[IESLabEvaluationResult]:
+        '''
+            运行方案评估
+
+            :param planID int类型，表示优化方案的ID，数值位于0~优化方案数量之间
+            :params type:  string类型，任务类型：环保评价/能效评价
+
+            :return: Runner[IESLabEvaluationResult]
+        '''
+        url = 'api/ieslab-plan/taskmanager/saveDataToclickhouse'
+        CMD_TYPE = type if type is None else self._evaluationType[type]
+        try:
+            timeId = int(time.time() * 1000)
+            r = request('GET',
+                        url,
+                        params={
+                            "simuid": self.simulationId,
+                            "planId": planID,
+                            "CMD_TYPE": CMD_TYPE
+                        })
+            data = json.loads(r.text)
+            return HttpRunner({'rid': 'function/ieslab/evaluation'},
+                self.simulationId,
+                timeId=timeId,
+                planId=planID,
+                cmdType=CMD_TYPE)
+        except:
+            raise Exception('方案评估开始计算失败')
+
+    def EnvironmentalEvaluationRun(self, planID):
+        '''
+            运行环保评价方案评估
+
+            :param planID int类型，表示优化方案的ID，数值位于0~优化方案数量之间
+
+            :return: 方案评估运行实例
+        '''
+        return self.run(planID, 'environmentalEvaluation')
+
+    def EnergyEvaluationRun(self, planID):
+        '''
+            运行能效评价方案评估
+
+            :param planID int类型，表示优化方案的ID，数值位于0~优化方案数量之间
+
+            :return: 方案评估运行实例
+        '''
+        return self.run(planID, 'energyEvaluation')
+
+    def GetRunner(self, planID) -> Runner[IESLabEvaluationResult]:
+        '''
+            获得运行实例
+
+            :return: Runner[IESLabEvaluationResult]
+        '''
+        return HttpRunner({'rid': 'function/ieslab/evaluation'},
+            self.simulationId,
+            planId=planID)
+
+
+@unique
+class OptimizationMode(IntEnum):
+    经济性 = 0
+    环保性 = 1

cloudpss/ieslab/IESLabPlan.py

@@ -0,0 +1,132 @@
+import json
+
+from cloudpss.ieslab.DataManageModel import IESPlanDataManageModel
+from cloudpss.ieslab.EvaluationModel import IESLabEvaluationModel
+from cloudpss.ieslab.PlanModel import IESLabPlanModel
+from cloudpss.runner.IESLabTypicalDayResult import IESLabTypicalDayResult
+from ..utils import request
+from ..model.model import Model
+from cloudpss.runner.runner import  Runner
+from cloudpss.runner.IESLabPlanResult import IESLabPlanResult
+from cloudpss.runner.IESLabEvaluationResult import IESLabEvaluationResult
+
+class IESLabPlan(object):
+    def __init__(self, project={}):
+        '''
+            初始化
+        '''
+        self.id = project.get('id', None)
+        self.name = project.get('name', None)
+        self.__modelRid = project.get('model', None)
+        self.project_group = project.get('project_group', None)
+        if self.__modelRid is not None:
+            self.model = Model.fetch(self.__modelRid)
+        self.dataManageModel = IESPlanDataManageModel(self.id)
+        self.planModel = IESLabPlanModel(self.id)
+        self.evaluationModel = IESLabEvaluationModel(self.id)
+        self.currentPlanResult = IESLabPlanResult(self.id)
+        self.currentEvaluationResult = IESLabEvaluationResult(self.id)
+
+    @staticmethod
+    def fetch(simulationId):
+        '''
+            获取算例信息
+
+            :params: simulationId string类型，代表数据项的算例id
+
+            :return: IESLabPlan
+        '''
+        try:
+            r = request('GET',
+                        'api/ieslab-plan/rest/simu/{0}/'.format(simulationId))
+            project = json.loads(r.text)
+            return IESLabPlan(project)
+        except:
+            raise Exception('未查询到当前算例')
+
+    def __run(self, job=None, name=None):
+        '''
+            调用仿真 
+
+            :params job:  调用仿真时使用的计算方案，不指定将使用算例保存时选中的计算方案
+            :params name:  任务名称，为空时使用项目的参数方案名称和计算方案名称
+
+            :return: 返回一个运行实例
+        '''
+        if job is None:
+            currentJob = self.model.context['currentJob']
+            job = self.model.jobs[currentJob]
+        job['args']['simulationId'] = self.id
+        return self.model.run(job, name=name)
+
+    def iesLabTypicalDayRun(self, job=None, name=None, **kwargs)->Runner[IESLabTypicalDayResult]:
+        '''
+            运行典型日计算 
+
+            :params job:  调用仿真时使用的计算方案，不指定将使用算例保存时选中的计算方案
+            :params name:  任务名称，为空时使用项目的参数方案名称和计算方案名称
+
+            :return: Runner[IESLabTypicalDayResult]
+        '''
+        if job is None:
+            currentJob = self.model.context['currentJob']
+            job = self.model.jobs[currentJob]
+            if job['rid'] != 'function/CloudPSS/ieslab-gmm':
+                for j in self.model.jobs:
+                    if j['rid'] == 'job-definition/ies/ies-gmm' or j['rid'] == 'job-definition/cloudpss/ieslab-gmm':
+                        j['rid'] = 'function/CloudPSS/ieslab-gmm'
+                        job = j
+        if job is None:
+            raise Exception("找不到默认的综合能源系统规划典型日生成算法的计算方案")
+        if job['rid'] != 'function/CloudPSS/ieslab-gmm':
+            raise Exception("不是综合能源系统规划典型日生成算法的计算方案")
+        return self.__run(job=job, name=name)
+
+    def iesLabEvaluationRun(self, planId, type=None):
+        '''
+            运行方案评估
+
+            :param planID int类型，表示优化方案的ID，数值位于0~优化方案数量之间
+            :param type string类型，表示评估类型，可选值为：能效评价、环保评价
+
+            :return: 方案评估运行实例
+
+        '''
+        return self.evaluationModel.run(planId, type)
+
+    def iesLabEnergyEvaluationRun(self, planId):
+        '''
+            运行能效评价
+
+            :param planID int类型，表示优化方案的ID，数值位于0~优化方案数量之间
+
+            :return: 能效评价运行实例
+
+        '''
+        return self.evaluationModel.EnergyEvaluationRun(planId)
+
+    def iesLabEnvironmentalEvaluationRun(self, planId):
+        '''
+            运行环保评价
+
+            :param planID int类型，表示优化方案的ID，数值位于0~优化方案数量之间
+
+            :return: 环保评价运行实例
+        '''
+        return self.evaluationModel.EnvironmentalEvaluationRun(planId)
+
+    def iesLabPlanRun(self):
+        '''
+            生成方案优选算例
+
+            :return: 方案优选运行实例
+        '''
+        return self.planModel.run()
+    
+    def iesLabPlanKill(self):
+        '''
+            停止并删除方案优选算例
+
+            :return: Boolean
+        '''
+        return self.planModel.kill()

cloudpss/ieslab/IESLabSimulation.py

@@ -0,0 +1,54 @@
+import json
+from ..utils import request
+from ..model.model import Model
+from .DataManageModel import IESSimulationDataManageModel
+
+
+class IESLabSimulation(object):
+    def __init__(self, project={}):
+        '''
+            初始化
+        '''
+        self.id = project.get('id', None)
+        self.name = project.get('name', None)
+        self.__modelRid = project.get('model', None)
+        self.project_group = project.get('project_group', None)
+        if self.__modelRid is not None:
+            self.model = Model.fetch(self.__modelRid)
+        self.dataManageModel = IESSimulationDataManageModel(self.id)
+
+    @staticmethod
+    def fetch(simulationId):
+        '''
+            获取算例信息
+
+            :params: simulationId string类型，代表数据项的算例id
+
+            :return: IESLabSimulation
+        '''
+        try:
+            r = request(
+                'GET', 'api/ieslab-simulation/rest/simu/{0}/'.format(simulationId))
+            project = json.loads(r.text)
+            print(project)
+            return IESLabSimulation(project)
+        except:
+            raise Exception('未查询到当前算例')
+
+    def run(self, job=None, name=None):
+        '''
+            调用仿真 
+
+            :params job:  调用仿真时使用的计算方案，不指定将使用算例保存时选中的计算方案
+            :params name:  任务名称，为空时使用项目的参数方案名称和计算方案名称
+
+            :return: 返回一个运行实例
+        '''
+        if job is None:
+            currentJob = self.model.context['currentJob']
+            job = self.model.jobs[currentJob]
+
+        job['args']['simulationId'] = self.id
+        print(job)
+        return self.model.run(job, name=name)
+

cloudpss/ieslab/PlanModel.py

@@ -0,0 +1,143 @@
+from cloudpss.runner.IESLabPlanResult import IESLabPlanResult
+from cloudpss.runner.runner import HttpRunner, Runner
+from ..utils import request, fileLoad
+import json
+from enum import IntEnum, unique
+
+
+class IESLabPlanModel(object):
+    _baseUri = 'api/ieslab-plan/taskmanager/getSimuLastTasks'
+
+    def __init__(self, simulationId):
+        '''
+            初始化
+        '''
+        self.simulationId = simulationId
+        self.optimizationInfo = self.GetOptimizationInfo()
+        self.OptimizationMode = OptimizationMode
+
+    def _fetchItemData(self, url):
+        '''
+            获取当前算例的优化目标设置信息
+
+            :return: enum 类型，代表经济性优化和环保性优化的类型
+        '''
+        r = request('GET', url, params={"simuid": self.simulationId})
+        data = json.loads(r.text)
+        return data
+
+    def GetOptimizationInfo(self):
+        '''
+            获取当前算例的优化目标设置信息
+
+            :return: enum 类型，代表经济性优化和环保性优化的类型
+        '''
+        try:
+            data = self._fetchItemData(self._baseUri)
+            for e in OptimizationMode:
+                if (e.value == data['data']['optimizationpara']
+                    ['OptimizationMode']):
+                    return e
+        except:
+            return OptimizationMode['经济性']
+
+    def SetOptimizationInfo(self, optType):
+        '''
+            无对应接口
+            设置当前算例的优化目标
+
+            :param optType: enum 类型，代表经济性优化和环保性优化的类型
+        '''
+        self.optimizationInfo = optType
+        return True
+
+    def run(self) -> Runner[IESLabPlanResult]:
+        '''
+            生成方案优选算例
+
+            :return: Runner[IESLabPlanResult]
+        '''
+        isRunning = self.GetLastTaskResult()
+        if isRunning:
+            raise Exception('该算例正在运行！请从浏览器算例页面点击结束运行或者调用IESPlan对象的kill接口终止计算后重试！')
+        else:
+            url = 'api/ieslab-plan/taskmanager/runOptimization'
+            if self.optimizationInfo is None:
+                self.optimizationInfo = OptimizationMode['经济性']
+            optType = self.optimizationInfo.value or 0
+            try:
+                r = request('GET',
+                            url,
+                            params={
+                                "simuid":
+                                self.simulationId,
+                                "optPara":
+                                json.dumps({
+                                    "OptimizationMode": optType,
+                                    "ProjectPeriod": "20"
+                                })
+                            })
+                data = json.loads(r.text)
+                return HttpRunner({}, self.simulationId)
+            except:
+                raise Exception('生成方案优选算例失败')
+
+    def GetRunner(self) -> Runner[IESLabPlanResult]:
+        '''
+            获得运行实例
+
+            :return: Runner[IESLabPlanResult]
+        '''
+        return HttpRunner({}, self.simulationId)
+    
+    def kill(self) -> bool:
+        '''
+            停止并删除当前运行的优化算例
+        '''
+        res = IESLabPlanResult(self.simulationId).getLastTaskResult()
+        error = res.get('error', 0)
+        if error == 0:
+            data = res.get('data', {})
+            if data is not None:
+                taskID = data.get('task_id', '')
+        url = f'api/ieslab-plan/taskmanager/removeOptimizationTask'
+        try:
+            r = request('GET',
+                        url,
+                        params={
+                            "taskid": taskID,
+                            "stopFlag": '2'
+                        })
+            json.loads(r.text)
+            return True
+        except:
+            return False
+
+    def GetLastTaskResult(self)-> bool:
+        '''
+            获取最后一次运行的taskID的运行结果与日志
+
+            :return: boolean 类型
+        '''
+        isRunning = True
+        res = IESLabPlanResult(self.simulationId).getLastTaskResult()
+        error = res.get('error', 0)
+        if error == 0:
+            data = res.get('data', {})
+            if data is not None:
+                status = data.get('status', '')
+                if status == 'stop':
+                    isRunning = False
+        logs = IESLabPlanResult(self.simulationId).GetLogs()
+        if logs is not None:
+            for log in logs:
+                if(log.get('data', '') == 'run ends'):
+                    isRunning = False
+                    break
+        return isRunning
+
+
+# @unique
+class OptimizationMode(IntEnum):
+    经济性 = 0
+    环保性 = 1

cloudpss/ieslab/__init__.py

@@ -0,0 +1,4 @@
+from .IESLabSimulation import IESLabSimulation
+from .IESLabPlan import IESLabPlan
+from .PlanModel import OptimizationMode
+__all__ = ['IESLabSimulation','IESLabPlan', 'OptimizationMode']

cloudpss/model/jobDefinitions.py

@@ -112,5 +112,39 @@ JOB_DEFINITIONS = {
             "SkipPF": "0",
             "MaxIteration": "30"
         }
+    },
+    "iesLoadPrediction": {
+        "name": "负荷预测方案 1",
+        "rid": "job-definition/ies/ies-load-prediction",
+        "arcs": {
+            "startTime": "2022 -01-01 00:00:00",
+            "endTime": "2022 -12-31 23:00:00",
+            "layer_forcast": "0",
+            "forcast_algorithm": "0",
+            "ratio_sub": [],
+            "ratio_feeder": [],
+            "ratio_trans": []
+        }
+    },
+    "iesPowerFlow": {
+        "name": "时序潮流方案 1",
+        "rid": "job-definition/ies/ies-power-flow",
+        "arcs": {
+            "startTime": "2022 -01-01 00:00:00",
+            "endTime": "2022 -12-31 23:00:00",
+            "solveMethod": "0",
+            "maxIteration": "30"
+        }
+    },
+    "iesEnergyStoragePlan": {
+        "name": "储能规划方案 1",
+        "rid": "job-definition/ies/ies-energy-storage-plan",
+        "arcs": {
+            "Planyear": "15",
+            "NetConfig": [],
+            "SourceConfig": [],
+            "LoadConfig": []
+        }
     }
+
 }