上传代码

This commit is contained in:
chentianrui
2025-09-08 17:58:02 +08:00
parent be848c3e78
commit f5f26c5cf8
76 changed files with 839039 additions and 2695 deletions
+47 -15
View File
@@ -11,12 +11,11 @@ import re
from xml.dom import minidom
# 配置logging
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
handlers=[logging.FileHandler("bcl_calculator.log"), logging.StreamHandler()],
)
# 配置logging(不在导入时绑定固定文件,具体文件由调用方配置)
_root_logger = logging.getLogger()
if not _root_logger.handlers:
# 避免 "No handler could be found" 警告
_root_logger.addHandler(logging.NullHandler())
class BCLVariantType(Enum):
@@ -1609,30 +1608,63 @@ class BCLCalculator:
continue
var_name = var_node.get("text")
variables[var_name] = self._get_variable_value(var_name, context)
var_value_obj = self._get_variable_value(var_name, context)
variables[var_name] = var_value_obj
# 构建表达式字符串
expr_str = expr_node.get("text")
expr_str = expr_node.get("text", "<unknown>")
if not expr_str:
expr_str = "<empty>"
# 构造符号表,转换为 float
symbols = {}
for var_name, var_value in variables.items():
symbols[var_name] = float("0" if not var_value.get_value() else var_value.get_value())
var_values_log = {}
for var_name, var_value_obj in variables.items():
raw_value = var_value_obj.get_value()
try:
# 安全转换为 float
float_value = float("0" if not raw_value else raw_value)
symbols[var_name] = float_value
var_values_log[var_name] = float_value
except (ValueError, TypeError) as e:
var_values_log[var_name] = f"无法转换为float: {raw_value} (类型: {type(raw_value).__name__})"
logging.debug(f"开始计算表达式: '{expr_str}'")
logging.debug(f"变量绑定值: {var_values_log}")
calculator = ExpressionCalculator()
parse_success = calculator.parse_expression(expr_str)
if not parse_success:
logging.error(f"表达式解析失败: {calculator.get_last_error()}")
raise ValueError(f"表达式解析失败: {calculator.get_last_error()}")
error_msg = calculator.get_last_error()
logging.error(
f"[表达式解析失败] " f"表达式='{expr_str}', " f"变量值={var_values_log}, " f"错误详情='{error_msg}'"
)
raise ValueError(f"表达式解析失败: {error_msg}")
# 执行四则运算并返回结果
result, value = calculator.evaluate(symbols)
if not result:
logging.error(f"表达式计算失败: {calculator.get_last_error()}")
raise ValueError(f"表达式计算失败: {calculator.get_last_error()}")
error_msg = calculator.get_last_error()
logging.error(
f"[表达式计算失败] "
f"表达式='{expr_str}', "
f"变量值={var_values_log}, "
f"错误类型='{error_msg}', "
)
raise ValueError(f"表达式计算失败: {expr_str} (变量: {var_values_log}) => 错误: {error_msg}")
logging.debug(f"表达式计算成功: '{expr_str}' => {value}")
return BCLVariant(value)
except Exception as e:
raise e
# 捕获所有异常,打印完整堆栈和上下文
logging.error(
f"[_evaluate_expression] 未预期异常: {str(e)}\n"
f"表达式节点文本: {expr_node.get('text', 'N/A')}\n"
f"变量上下文: {[child.get('text') for child in expr_node if child.get('type') == '变量']}\n"
f"完整堆栈:\n{traceback.format_exc()}"
)
raise
def _call_function(self, func_name: str, node: ET.Element, context: BCLContext) -> BCLVariant:
+51 -30
View File
@@ -395,50 +395,77 @@ def create_equipment_from_node(node: dict[str, any]) -> Equipment:
return equipment
def init_bcl_calculator(software_category, engineering_type, calculation_type, project_type: Optional[str] = None):
def init_bcl_calculator(*args, **kwargs):
"""
初始化BCL计算器
Args:
software_category: 软件类别(主网/配网/技改)
engineering_type: 工程类型(预算/清单)
calculation_type: 计算类型(工程量/人材机)
project_type: 项目类型(如 变电/线路 等);仅用于工程量时筛选要加载的XML文件
新接口(推荐):
init_bcl_calculator(bcl_dir_path: str) -> bool
兼容旧接口:
init_bcl_calculator(software_category, engineering_type, calculation_type, project_type: Optional[str] = None)
兼容极旧/无参调用:
init_bcl_calculator() # 不执行加载,直接返回 True,避免旧代码报错
Returns:
bool: 是否成功初始化
"""
try:
# 构建计算配置路径
# 格式:计算配置/软件类型(主网,配网,技改)/计算类型(工程量,人材机)/工程类型(预算,清单)
config_path = f"equipment_calculation/计算配置/{software_category}/{calculation_type}/{engineering_type}"
print(f"加载计算配置: {config_path}")
# 检查目录是否存在
import os
# 解析参数:优先使用新接口的单一路径
bcl_dir_path: Optional[str] = None
software_category = None
engineering_type = None
calculation_type = None
project_type = None
# 新接口:单一位置参数为路径
if len(args) == 1 and isinstance(args[0], str):
bcl_dir_path = args[0]
# 旧接口:按原有签名位置参数
elif len(args) >= 3:
software_category, engineering_type, calculation_type = args[:3]
project_type = args[3] if len(args) >= 4 else None
else:
# 也尝试从kwargs读取
bcl_dir_path = kwargs.get("bcl_dir_path")
software_category = kwargs.get("software_category")
engineering_type = kwargs.get("engineering_type")
calculation_type = kwargs.get("calculation_type")
project_type = kwargs.get("project_type")
# 无参极旧调用:直接返回 True(不加载任何脚本,避免中断旧流程)
if bcl_dir_path is None and software_category is None and engineering_type is None and calculation_type is None:
print("init_bcl_calculator: 无参数调用,跳过加载(兼容模式)")
return True
# 确定配置目录
if bcl_dir_path:
config_path = bcl_dir_path
print(f"加载计算配置(新接口): {config_path}")
else:
# 保持旧接口逻辑
config_path = f"equipment_calculation/计算配置/{software_category}/{calculation_type}/{engineering_type}"
print(f"加载计算配置(旧接口): {config_path}")
# 目录存在性处理
if not os.path.exists(config_path):
print(f"计算配置目录不存在: {config_path}")
# 尝试创建目录
try:
os.makedirs(config_path, exist_ok=True)
print(f"已创建计算配置目录: {config_path}")
except Exception as e:
print(f"创建计算配置目录失败: {e}")
# 如果目录不存在,使用默认配置
# 旧逻辑下的默认回退
default_path = "equipment_calculation/计算配置/主网/工程量/预算"
print(f"使用默认计算配置: {default_path}")
# 检查默认配置目录是否存在
if not os.path.exists(default_path):
print(f"默认计算配置目录不存在: {default_path}")
# 尝试使用原始默认配置
original_default_path = "equipment_calculation/计算配置/主网/主网预算"
print(f"尝试使用原始默认计算配置: {original_default_path}")
if os.path.exists(original_default_path):
config_path = original_default_path
else:
@@ -448,13 +475,12 @@ def init_bcl_calculator(software_category, engineering_type, calculation_type, p
config_path = default_path
# 加载脚本
# 对于工程量,若提供了project_type且存在映射,则仅加载映射中指定的XML
result = True
use_filtered_files = False
try:
import os
if calculation_type == "工程量" and project_type:
# 仅当旧接口+工程量+提供project_type时,启用按映射筛选
try:
if (not bcl_dir_path) and calculation_type == "工程量" and project_type:
target_list = PROJECT_TYPE_XML_MAP.get(software_category, {}).get(project_type) or []
if target_list:
use_filtered_files = True
@@ -482,7 +508,6 @@ def init_bcl_calculator(software_category, engineering_type, calculation_type, p
else:
print(f"未找到映射项,按目录全部加载: 软件={software_category}, 项目类型={project_type}")
except Exception as _e:
# 映射/筛选流程异常时,退回目录加载
print(f"按项目类型筛选加载发生异常,退回目录加载: {_e}")
use_filtered_files = False
@@ -490,17 +515,13 @@ def init_bcl_calculator(software_category, engineering_type, calculation_type, p
result = calculator.load_scripts_dir(config_path)
if False == result:
print(f"加载脚本错误: {calculator.get_last_error()}")
# 尝试使用默认配置
# 默认回退
default_path = "equipment_calculation/计算配置/主网/工程量/预算"
print(f"尝试使用默认计算配置: {default_path}")
# 检查默认配置目录是否存在
if not os.path.exists(default_path):
print(f"默认计算配置目录不存在: {default_path}")
# 尝试使用原始默认配置
original_default_path = "equipment_calculation/计算配置/主网/主网预算"
print(f"尝试使用原始默认计算配置: {original_default_path}")
if os.path.exists(original_default_path):
result = calculator.load_scripts_dir(original_default_path)
if False == result:
+30 -11
View File
@@ -28,6 +28,8 @@ class CalculatorBase(ABC):
self.calculation_strategy = self.create_calculation_strategy()
# 默认输出目录
self.output_dir = os.path.join("计算结果", self.software_type.name)
# 新增:BCL 脚本目录(优先使用新接口)
self.bcl_dir: str | None = None
def create_calculation_strategy(self) -> CalculationStrategy:
"""
@@ -60,6 +62,15 @@ class CalculatorBase(ABC):
if hasattr(self.calculation_strategy, "set_output_dir"):
self.calculation_strategy.set_output_dir(output_dir)
def set_bcl_dir(self, bcl_dir: str) -> None:
"""
设置 BCL 脚本目录路径(新接口)。
Args:
bcl_dir: BCL 目录路径
"""
self.bcl_dir = bcl_dir
def _append_log(self, text: str, filename: str = "performance_memory_log.txt") -> str:
"""将文本即时追加写入输出目录下的日志文件,并返回日志路径。"""
try:
@@ -121,12 +132,16 @@ class CalculatorBase(ABC):
# 外层只初始化一次 BCL 计算器
from equipment_calculation.bcl_utils import init_bcl_calculator
init_bcl_calculator(
software_category=self.software_type.category.value,
engineering_type=self.software_type.engineering_type.value,
calculation_type="工程量",
project_type=project_type,
)
if getattr(self, "bcl_dir", None):
init_bcl_calculator(self.bcl_dir)
# else:
# # 兼容老接口
# init_bcl_calculator(
# software_category=self.software_type.category.value,
# engineering_type=self.software_type.engineering_type.value,
# calculation_type="工程量",
# project_type=project_type,
# )
if project_name:
# 处理单个项目划分
@@ -177,11 +192,15 @@ class CalculatorBase(ABC):
# 外层只初始化一次 BCL 计算器(人材机)
from equipment_calculation.bcl_utils import init_bcl_calculator
init_bcl_calculator(
software_category=self.software_type.category.value,
engineering_type=self.software_type.engineering_type.value,
calculation_type="人材机",
)
if getattr(self, "bcl_dir", None):
init_bcl_calculator(self.bcl_dir)
# else:
# # 兼容老接口
# init_bcl_calculator(
# software_category=self.software_type.category.value,
# engineering_type=self.software_type.engineering_type.value,
# calculation_type="人材机",
# )
if project_name:
# 处理单个项目划分
@@ -14,7 +14,7 @@ class ExpressionCalculator:
"""将表达式字符串分解为标记列表"""
token_spec = [
("NUMBER", r"\d+(\.\d*)?"), # 整数或小数
("VARIABLE", r"@?[a-zA-Z_\u4e00-\u9fa5][\w.@\u4e00-\u9fa5]+"), # 支持带点的复合变量
("VARIABLE", r"@?[a-zA-Z_\u4e00-\u9fa5][\w.@\u4e00-\u9fa5]*"), # 支持带点的复合变量,允许单字符变量
("OPERATOR", r"[+\-*/()]"), # 运算符
("SKIP", r"\s+"), # 跳过空格
("MISMATCH", r"."), # 其他字符
+76 -8
View File
@@ -1,5 +1,6 @@
import os
import json
import logging
from memory_profiler import profile
from typing import Dict, List, Any, Optional, Tuple
from equipment_calculation.software_types import (
@@ -32,8 +33,15 @@ CATEGORY_MAPPING = {
# 项目类型名称映射字典,将各种变体映射到标准类型(预算/清单)
PROJECT_TYPE_MAPPING = {
# 预算类变体
"概预算工程": "预算",
"初步设计概算": "预算",
"可行性研究投资估算": "预算",
"施工图预算": "预算",
"配网定额计价": "预算",
"招标控制价": "清单",
"投标报价": "清单",
"招投标工程": "清单",
"配网清单招投标计价": "清单",
}
@@ -55,8 +63,8 @@ def parse_json_content(json_file_path: str) -> Tuple[Optional[str], Optional[str
# 提取 basicData
basic_data = data.get("basicData", {}) if isinstance(data, dict) else {}
# 软件类别(优先 软件类别,其次 软件名称)
category = basic_data.get("软件名称") or basic_data.get("软件名称")
engineering_type = basic_data.get("项目类型")
category = basic_data.get("软件类别") or basic_data.get("软件名称")
engineering_type = basic_data.get("项目类型") or basic_data.get("工程类型") or basic_data.get("工程类别")
# 规范化项目类型为 预算/清单
if engineering_type:
mapped_pt = PROJECT_TYPE_MAPPING.get(engineering_type)
@@ -88,7 +96,13 @@ def parse_json_content(json_file_path: str) -> Tuple[Optional[str], Optional[str
return None, None, None
def process_json_file(json_file_path: str, output_dir: str, calculate_type: str, project_name: str = None) -> bool:
def process_json_file(
json_file_path: str,
output_dir: str,
calculate_type: str,
project_name: str = None,
bcl_dir_path: str | None = None,
) -> bool:
"""
处理单个JSON文件
@@ -127,6 +141,9 @@ def process_json_file(json_file_path: str, output_dir: str, calculate_type: str,
# 获取计算器
calculator = get_calculator(software_type)
# 若提供了 bcl 目录,优先使用新接口
if hasattr(calculator, "set_bcl_dir") and bcl_dir_path:
calculator.set_bcl_dir(bcl_dir_path)
if not calculator:
print(f"错误: 未找到软件类型 {software_type.name} 的计算器")
return False
@@ -184,6 +201,9 @@ def process_json_file(json_file_path: str, output_dir: str, calculate_type: str,
# 创建自定义输出目录的计算器
custom_calculator = CustomOutputCalculator(calculator, custom_output_dir)
# 自定义计算器同样继承 bcl_dir 设置
if hasattr(custom_calculator, "set_bcl_dir") and bcl_dir_path:
custom_calculator.set_bcl_dir(bcl_dir_path)
# 根据计算类型执行计算
if calculate_type in ["all", "quantity"]:
@@ -212,7 +232,9 @@ def process_json_file(json_file_path: str, output_dir: str, calculate_type: str,
return False
def process_directory(input_dir: str, output_dir: str, calculate_type: str = "quantity") -> None:
def process_directory(
input_dir: str, output_dir: str, calculate_type: str = "quantity", bcl_dir_path: str | None = None
) -> None:
"""
批量处理目录中的JSON文件
@@ -239,13 +261,15 @@ def process_directory(input_dir: str, output_dir: str, calculate_type: str = "qu
json_file_path = os.path.join(input_dir, json_file)
print(f"处理文件 {i}/{len(json_files)}: {json_file}")
if process_json_file(json_file_path, output_dir, calculate_type):
if process_json_file(json_file_path, output_dir, calculate_type, bcl_dir_path=bcl_dir_path):
success_count += 1
print(f"处理完成,成功: {success_count}/{len(json_files)}")
def bcl_calculate(input_dir: str, output_dir: str, calculate_type: str = "quantity") -> None:
def bcl_calculate(
input_dir: str, output_dir: str, calculate_type: str = "quantity", bcl_dir_path: str | None = None
) -> None:
"""
主函数,处理指定目录中的所有JSON文件
@@ -254,10 +278,54 @@ def bcl_calculate(input_dir: str, output_dir: str, calculate_type: str = "quanti
output_dir: 输出目录路径
calculate_type: 计算类型(all: 全部, quantity: 工程量取费, resource: 人材机合价)
"""
# 将日志写入本次工程的 bclresults 目录
_configure_bcl_logging(output_dir)
print(f"开始处理目录: {input_dir}")
print(f"输出目录: {output_dir}")
print(f"计算类型: {calculate_type}")
process_directory(input_dir, output_dir, calculate_type)
process_directory(input_dir, output_dir, calculate_type, bcl_dir_path=bcl_dir_path)
print("所有文件处理完成")
def _configure_bcl_logging(log_dir: str):
"""将 bcl 计算日志写入指定目录下的 bcl_calculator.log。
- 清理先前的 FileHandler,避免多次叠加/重复输出。
- 保留/添加一个 StreamHandler 以在控制台输出。
"""
try:
os.makedirs(log_dir, exist_ok=True)
log_path = os.path.join(log_dir, "bcl_calculator.log")
logger = logging.getLogger()
logger.setLevel(logging.INFO)
# 移除已有的 FileHandler,避免写到旧位置或重复写
for h in list(logger.handlers):
if isinstance(h, logging.FileHandler):
logger.removeHandler(h)
try:
h.close()
except Exception:
pass
formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
file_handler = logging.FileHandler(log_path, mode="w", encoding="utf-8")
file_handler.setLevel(logging.INFO)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
# 确保有一个控制台输出
if not any(isinstance(h, logging.StreamHandler) for h in logger.handlers):
stream_handler = logging.StreamHandler()
stream_handler.setLevel(logging.INFO)
stream_handler.setFormatter(formatter)
logger.addHandler(stream_handler)
print(f"日志输出重定向到: {log_path}")
except Exception as e:
print(f"配置日志输出失败,将继续使用默认日志配置: {e}")
File diff suppressed because it is too large Load Diff
@@ -1,4 +0,0 @@
BEGIN:单价_定额重算
${
sum(source, "定额", ?round(定额.人工费*定额.人工系数*定额.定额系数+定额.材料费*定额.材料系数*定额.定额系数+定额.机械费*定额.机械系数*定额.定额系数, 2))
}
@@ -1,4 +0,0 @@
BEGIN:单价_定额重算
${
sum(source, "定额", ?round(定额.人工费*定额.人工系数*定额.定额系数+定额.材料费*定额.材料系数*定额.材料综合系数*定额.定额系数+定额.机械费*定额.机械系数*定额.机械综合系数*定额.定额系数, 2))
}
@@ -1,134 +0,0 @@
/////////////////定额人工工日计算过滤函数////////////////////////////////
BEGIN:_过滤人工工日
${
filter(source ,"人材机",?人材机.type == "人工" && 人材机.单位 == "工日")
}
/////////////////////////////定额人材机重算调用函数 ////////////////////////////////
/////////////////////////////目前采用资源库中定义的通用算法 仅提供人工工日的计算配置 ////////////////////////////////
BEGIN:_定额_人工工日
${
sum(_过滤人工工日(), "人材机", ? 人材机.数量 )
}
///////////////////////////////////////////////////////////////
//
// 定额重算(与技改平台兼容的代码)
//
///////////////////////////////////////////////////////////////
BEGIN:_普通人工费_定额重算
${ _普通人工费_非%_计价_() + _普通人工费__()}
BEGIN:人工费_定额重算
${ _定额_人工费@算法2_() }
BEGIN:_普通材料费_定额重算
${ _普通材料费__算法2_()}
BEGIN:_其他材料费_定额重算
${ _其他费_材料__算法2_() }
BEGIN:材料费_定额重算
${
_定额_材料费@算法2_()
}
BEGIN:甲供材料费_定额重算
${
_定额_甲供材料费@算法2_()
}
BEGIN:甲供材料费_定额重算_含税
${
_变量_甲供材料费@算法2_()
}
BEGIN:_甲供普通材料费_定额重算
${
_甲供普通材料费__算法2_()
}
BEGIN:_甲供其他材料费_定额重算
${
_甲供其他费_材料_%_算法2_()
}
BEGIN:_普通机械费_定额重算
${ _普通机械费__算法2_()}
BEGIN:_其他机械费_定额重算
${_其他费_机械__算法2_() }
BEGIN:机械费_定额重算
${ _定额_机械费@算法2_() }
BEGIN:基价_定额重算
${
sum(source, "定额", ?round(定额.人工费+定额.材料费+定额.机械费, 2))
}
BEGIN:拆分材料父级预算价_定额重算
${ 0.0 }
BEGIN:_拆分子级人工预算合价_消材
${ 0.0 }
BEGIN:_拆分子级机械预算合价_消材
${ 0.0 }
BEGIN:_拆分子级材料预算合价_消材
${ 0.0 }
BEGIN:拆分材料父级市场价_定额重算
${ 0.0 }
BEGIN:_拆分子级人工市场价合价_消材
${ 0.0 }
BEGIN:_拆分子级机械市场价合价_消材
${ 0.0 }
BEGIN:_拆分子级材料市场价合价_消材
${ 0.0 }
BEGIN:拆分父级预算价_定额重算
${ 0.0 }
BEGIN:_拆分子级人工预算合价
${ 0.0 }
BEGIN:_拆分子级机械预算合价
${ 0.0 }
BEGIN:_拆分子级材料预算合价
${ 0.0 }
BEGIN:拆分父级市场价_定额重算
${ 0.0 }
BEGIN:_拆分子级人工市场价合价
${ 0.0 }
BEGIN:_拆分子级机械市场价合价
${ 0.0 }
BEGIN:_拆分子级材料市场价合价
${ 0.0 }
BEGIN:拆分父级原价_定额重算
${ 0.0 }
BEGIN:_拆分子级人工原价合价
${ 0.0 }
BEGIN:_拆分子级机械原价合价
${ 0.0 }
BEGIN:_拆分子级材料原价合价
${ 0.0 }
@@ -1,218 +0,0 @@
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// 材机分析汇总变量计算
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
BEGIN:_统计水超运数量_人力运输
${
?@统计项.数量 * 0.36 * ( 1 + @统计项.损耗 * 0.01)* (1 + @统计项.包装系数 * 0.01) * @统计参数.人力运输
}
BEGIN:_统计水超运数量_汽车运输
${
?#{
->@统计项.装卸 == "0"
:
@统计项.数量 * 0.36 * ( 1 + @统计项.损耗 * 0.01)* (1 + @统计项.包装系数 * 0.01) * @统计参数.汽车运输;
->@统计项.装卸 == "1"
:
@统计项.数量 * 0.36 * ( 1 + @统计项.损耗 * 0.01) * (1 + @统计项.包装系数 * 0.01);
}
}
BEGIN:_统计水超运数量_船舶运输
${
?#{
->@统计项.装卸 == "0"
:
@统计项.数量 * 0.36 * ( 1 + @统计项.损耗 * 0.01)* (1 + @统计项.包装系数 * 0.01) * @统计参数.船舶运输;
->@统计项.装卸 == "1"
:
@统计项.数量 * 0.36 * ( 1 + @统计项.损耗 * 0.01) * (1 + @统计项.包装系数 * 0.01);
}
}
BEGIN:_统计水超运数量_拖拉机运输
${
?#{
->@统计项.装卸 == "0"
:
@统计项.数量 * 0.36 * ( 1 + @统计项.损耗 * 0.01)* (1 + @统计项.包装系数 * 0.01) * @统计参数.拖拉机运输;
->@统计项.装卸 == "1"
:
@统计项.数量 * 0.36 * ( 1 + @统计项.损耗 * 0.01) * (1 + @统计项.包装系数 * 0.01);
}
}
BEGIN:_统计工地运输数量_人力运输
${
?@统计项.数量 * @统计项.单重 / 1000 * ( 1 + @统计项.损耗 * 0.01)* (1 + @统计项.包装系数 * 0.01) * @统计参数.人力运输
}
BEGIN:_统计工地运输数量_汽车运输
${
?#{
->@统计项.装卸 == "0"
:
@统计项.数量 * @统计项.单重 / 1000 * ( 1 + @统计项.损耗 * 0.01)* (1 + @统计项.包装系数 * 0.01) * @统计参数.汽车运输;
->@统计项.装卸 == "1"
:
@统计项.数量 * @统计项.单重 / 1000 * ( 1 + @统计项.损耗 * 0.01) * (1 + @统计项.包装系数 * 0.01);
}
}
BEGIN:_统计工地运输数量_船舶运输
${
?#{
->@统计项.装卸 == "0"
:
@统计项.数量 * @统计项.单重 / 1000 * ( 1 + @统计项.损耗 * 0.01)* (1 + @统计项.包装系数 * 0.01) * @统计参数.船舶运输;
->@统计项.装卸 == "1"
:
@统计项.数量 * @统计项.单重 / 1000 * ( 1 + @统计项.损耗 * 0.01) * (1 + @统计项.包装系数 * 0.01);
}
}
BEGIN:_统计工地运输数量_拖拉机运输
${
?#{
->@统计项.装卸 == "0"
:
@统计项.数量 * @统计项.单重 / 1000 * ( 1 + @统计项.损耗 * 0.01)* (1 + @统计项.包装系数 * 0.01) * @统计参数.拖拉机运输;
->@统计项.装卸 == "1"
:
@统计项.数量 * @统计项.单重 / 1000 * ( 1 + @统计项.损耗 * 0.01) * (1 + @统计项.包装系数 * 0.01);
}
}
BEGIN:_统计拆除工地运输数量_人力运输
${
?@统计项.数量 * @统计项.单重 / 1000 * @统计参数.人力运输
}
BEGIN:_统计拆除工地运输数量_汽车运输
${
?#{
->@统计项.装卸 == "0"
:
@统计项.数量 * @统计项.单重 / 1000 * @统计参数.汽车运输;
->@统计项.装卸 == "1"
:
@统计项.数量 * @统计项.单重 / 1000 ;
}
}
BEGIN:_统计拆除工地运输数量_船舶运输
${
?#{
->@统计项.装卸 == "0"
:
@统计项.数量 * @统计项.单重 / 1000 * @统计参数.船舶运输;
->@统计项.装卸 == "1"
:
@统计项.数量 * @统计项.单重 / 1000;
}
}
BEGIN:_统计拆除工地运输数量_拖拉机运输
${
?#{
->@统计项.装卸 == "0"
:
@统计项.数量 * @统计项.单重 / 1000 * @统计参数.拖拉机运输;
->@统计项.装卸 == "1"
:
@统计项.数量 * @统计项.单重 / 1000 ;
}
}
BEGIN:_统计工地运输数量_往复式索道运输
${
?#{
->@统计项.装卸 == "0"
:
@统计项.数量 * @统计项.单重 / 1000 * ( 1 + @统计项.损耗 * 0.01)* (1 + @统计项.包装系数 * 0.01) * @统计参数.往复式索道运输;
->@统计项.装卸 == "1"
:
@统计项.数量 * @统计项.单重 / 1000 * ( 1 + @统计项.损耗 * 0.01) * (1 + @统计项.包装系数 * 0.01);
}
}
BEGIN:_统计工地运输数量_循环式索道运输
${
?#{
->@统计项.装卸 == "0"
:
@统计项.数量 * @统计项.单重 / 1000 * ( 1 + @统计项.损耗 * 0.01)* (1 + @统计项.包装系数 * 0.01) * @统计参数.循环式索道运输;
->@统计项.装卸 == "1"
:
@统计项.数量 * @统计项.单重 / 1000 * ( 1 + @统计项.损耗 * 0.01) * (1 + @统计项.包装系数 * 0.01);
}
}
//------------------余土外运-------------------------------------------
BEGIN:_统计余土外运数量_人力运输
${
?@统计项.数量 * ( 1 + @统计项.损耗 * 0.01)* (1 + @统计项.包装系数 * 0.01) * @统计参数.人力运输
}
BEGIN:_统计余土外运数量_汽车运输
${
?#{
->@统计项.装卸 == "0"
:
@统计项.数量 * ( 1 + @统计项.损耗 * 0.01) * (1 + @统计项.包装系数 * 0.01) * @统计参数.汽车运输;
->@统计项.装卸 == "1"
:
@统计项.数量 * ( 1 + @统计项.损耗 * 0.01) * (1 + @统计项.包装系数 * 0.01);
}
}
BEGIN:_统计余土外运数量_船舶运输
${
?#{
->@统计项.装卸 == "0"
:
@统计项.数量 * ( 1 + @统计项.损耗 * 0.01)* (1 + @统计项.包装系数 * 0.01) * @统计参数.船舶运输;
->@统计项.装卸 == "1"
:
@统计项.数量 * ( 1 + @统计项.损耗 * 0.01) * (1 + @统计项.包装系数 * 0.01);
}
}
BEGIN:_统计余土外运数量_拖拉机运输
${
?#{
->@统计项.装卸 == "0"
:
@统计项.数量 * ( 1 + @统计项.损耗 * 0.01) * (1 + @统计项.包装系数 * 0.01) * @统计参数.拖拉机运输;
->@统计项.装卸 == "1"
:
@统计项.数量 * ( 1 + @统计项.损耗 * 0.01) * (1 + @统计项.包装系数 * 0.01);
}
}
BEGIN:_统计余土外运数量_往复式索道运输
${
?#{
->@统计项.装卸 == "0"
:
@统计项.数量 * ( 1 + @统计项.损耗 * 0.01) * (1 + @统计项.包装系数 * 0.01) * @统计参数.往复式索道运输;
->@统计项.装卸 == "1"
:
@统计项.数量 * ( 1 + @统计项.损耗 * 0.01) * (1 + @统计项.包装系数 * 0.01);
}
}
BEGIN:_统计余土外运数量_循环式索道运输
${
?#{
->@统计项.装卸 == "0"
:
@统计项.数量 * ( 1 + @统计项.损耗 * 0.01) * (1 + @统计项.包装系数 * 0.01) * @统计参数.循环式索道运输;
->@统计项.装卸 == "1"
:
@统计项.数量 * ( 1 + @统计项.损耗 * 0.01) * (1 + @统计项.包装系数 * 0.01);
}
}
@@ -1,27 +0,0 @@
BEGIN:建筑拆除脚手架搭拆费代码
${ "" }
BEGIN:拆分人工代码
${ "" }
BEGIN:脚手架记取定额范围
${
"PT13-1~200,PT14-1~152,PT15-1~195,PT16-1~203,PT17-1~55,PT18-1~49,XYT15-1~189,XYT16-1~106,XYT17-1~133,XYT18-1~104,XYT19-1~35"
}
BEGIN:建筑调试费代码(计取接地调试费)
${
"PT14-114~130,PT14-135~151"
}
BEGIN:建筑调试费代码(计取消防调试费)
${
"PT15-1~195"
}
BEGIN:建筑调试费代码(计取通风调试费)
${
"PT16-1~31,PT16-54~66,PT16-108~203"
}
BEGIN:建筑调试费代码(计取采暖调试费)
${
"PT17-1~50,PT17-53~55"
}
@@ -1,30 +0,0 @@
///////////////////////////////////广东差异变量//////////////////////////////////////////////////////
BEGIN:_设计费_基础费用_宏变量
${
?#{
->@通用设计费.工程划分 == "充配电工程"
: 设计费_充配电基本设计费_宏变量();
->@通用设计费.工程划分 == "线路工程"
: 设计费_线路基本设计费_宏变量();
->@通用设计费.工程划分 == "混合"
: 设计费_充配电基本设计费_宏变量() + 设计费_线路基本设计费_宏变量();
}
}
///////////////////////////////////贵州差异变量//////////////////////////////////////////////////////
BEGIN:一笔性费用
${
?一笔性费用含税()
}
BEGIN:一笔性费用含税
${
sum(_过滤一笔性费用(), "一笔性费用", ? 一笔性费用.数量 * 一笔性费用.市场价含税 * _项目划分费率() )
}
BEGIN:一笔性费用不含税
${
sum(_过滤一笔性费用(), "一笔性费用", ? 一笔性费用.数量 * 一笔性费用.市场价不含税 * _项目划分费率() )
}
@@ -1,529 +0,0 @@
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// 材机分析汇总变量计算
//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
BEGIN:_工程费用小数位数
${
?#{
-> @工程信息.工程费用小数位数 == "整数"
:
0.0;
-> @工程信息.工程费用小数位数 == "1位小数"
:
1.0;
-> @工程信息.工程费用小数位数 == "2位小数"
:
2.0;
}
}
BEGIN:_材机人工价差
${
sum(source,"人材机",?人材机.市场价不含税 - 人材机.预算价不含税)
}
BEGIN:_材机人工价差合价
${
round(?sum(source,"人材机",?(人材机.市场价不含税 - 人材机.预算价不含税) * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机人工市场价合价
${
round(?sum(source,"人材机",?人材机.市场价不含税 * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机人工预算价合价
${
round(?sum(source,"人材机",?人材机.预算价不含税 * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机机械价差
${
sum(source,"人材机",?人材机.市场价不含税 - 人材机.预算价不含税)
}
BEGIN:_材机机械价差合价
${
round(?sum(source,"人材机",?(人材机.市场价不含税 - 人材机.预算价不含税) * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机机械差值不含税
${
round(?sum(source,"人材机",?(人材机.结算价不含税 - 人材机.市场价不含税) * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机机械市场价合价
${
round(?sum(source,"人材机",?人材机.市场价不含税 * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机机械结算价合价
${
round(?sum(source,"人材机",?人材机.结算价不含税 * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机机械预算价合价
${
round(?sum(source,"人材机",?人材机.预算价不含税 * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机材料价差含税
${
sum(source,"人材机",?人材机.市场价含税 - 人材机.预算价含税)
}
BEGIN:_材机材料价差不含税
${
sum(source,"人材机",?人材机.市场价不含税 - 人材机.预算价不含税)
}
BEGIN:_材机材料价差合价含税
${
round(?sum(source,"人材机",?(人材机.市场价含税 - 人材机.预算价含税) * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机材料价差合价不含税
${
round(?sum(source,"人材机",?(人材机.市场价不含税 - 人材机.预算价不含税) * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机材料差值含税
${
round(?sum(source,"人材机",?(人材机.结算价含税 - 人材机.市场价含税) * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机材料差值不含税
${
round(?sum(source,"人材机",?(人材机.结算价不含税 - 人材机.市场价不含税) * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机材料市场价合价含税
${
round(?sum(source,"人材机",?人材机.市场价含税 * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机材料市场价合价不含税
${
round(?sum(source,"人材机",?人材机.市场价不含税 * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机材料结算价合价含税
${
round(?sum(source,"人材机",?人材机.结算价含税 * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机材料结算价合价不含税
${
round(?sum(source,"人材机",?人材机.结算价不含税 * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机材料预算价合价含税
${
round(?sum(source,"人材机",?人材机.预算价含税 * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机材料预算价合价不含税
${
round(?sum(source,"人材机",?人材机.预算价不含税 * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机主材价差
${
sum(source,"人材机",?人材机.市场价不含税 - 人材机.预算价不含税)
}
BEGIN:_材机主材价差合价
${
round(?sum(source,"人材机",?(人材机.市场价不含税 - 人材机.预算价不含税) * 人材机.数量), _工程费用小数位数)
}
BEGIN:_材机主材市场价合价
${
round(?sum(source,"人材机",?人材机.市场价不含税 * 人材机.数量), _工程费用小数位数)
}
BEGIN:_材机主材预算价合价
${
round(?sum(source,"人材机",?人材机.预算价不含税 * 人材机.数量), _工程费用小数位数)
}
BEGIN:_材机设备运杂费
${
sum(source,"人材机",?人材机.市场价不含税 )
}
BEGIN:_材机设备市场价合价
${
round(?sum(source,"人材机",?人材机.市场价不含税 * 人材机.数量), _工程费用小数位数)
}
BEGIN:_材机设备运杂费合价
${
round(?sum(source,"人材机",?人材机.市场价不含税 * 人材机.数量), _工程费用小数位数)
}
BEGIN:_材机配件运杂费
${
sum(source,"人材机",?人材机.市场价不含税 )
}
BEGIN:_材机配件原价合价
${
round(?sum(source,"人材机",?人材机.原价 * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机配件市场价合价
${
round(?sum(source,"人材机",?人材机.市场价不含税 * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机配件价差
${
sum(source,"人材机",?人材机.市场价不含税 - 人材机.原价)
}
BEGIN:_材机配件价差合价
${
round(?sum(source,"人材机",?(人材机.市场价不含税 - 人材机.原价) * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机配件运杂费合价
${
round(?sum(source,"人材机",?人材机.市场价不含税 * 人材机.数量 ), _工程费用小数位数)
}
BEGIN:_材机主材合价含税
${
round(?sum(source,"人材机",?人材机.市场价含税 * 人材机.数量), _工程费用小数位数)
}
BEGIN:_材机主材合价不含税
${
round(?sum(source,"人材机",?人材机.市场价不含税 * 人材机.数量), _工程费用小数位数)
}
BEGIN:_材机设备合价含税
${
round(?sum(source,"人材机",?人材机.市场价含税 * 人材机.数量), _工程费用小数位数)
}
BEGIN:_材机设备合价不含税
${
round(?sum(source,"人材机",?人材机.市场价不含税 * 人材机.数量), _工程费用小数位数)
}
//***********数量计算***********************************************
BEGIN:_材机主材总重
${
sum(source,"主材",?主材.单重 * 主材.数量)
}
//-------------------------------------合并材机数量---------------20230128修改通信定额范围以及拆分人工的机械增加------------------------------//
//****2023年11月9日 运输定额的地形区分人运、汽车拖拉机计算*****//
BEGIN:_材机_定额地形系数_人工增加
${
?#{
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "架空线路" && in(parent.编码,"JYX1-1~16")
:
(@拆除架空线路地形系数.工地运输混凝土杆);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "架空线路" && in(parent.编码,"JYX1-17~22")
:
(@拆除架空线路地形系数.工地运输金具);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "架空线路" && (in(parent.编码,"JYX1-23~108") && strFind(parent.名称,"装卸") == -1)
:
(@拆除架空线路地形系数.工汽拖运输);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "架空线路" && in(parent.编码,"CYX1-1~4")
:
(@拆除架空线路地形系数.基础工程);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "架空线路" && in(parent.编码,"CYX2-1~40")
:
(@拆除架空线路地形系数.杆塔工程);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "架空线路" && in(parent.编码,"CYX3-1~27")
:
(@拆除架空线路地形系数.架线一般);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "架空线路" && in(parent.编码,"CYX3-28~42")
:
(@拆除架空线路地形系数.架线张力);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "架空线路" && in(parent.编码,"CYX4-1~131")
:
(@拆除架空线路地形系数.附件工程);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "通信线路" && in(parent.编码,"JYX1-1~16")
:
(@拆除通信线路地形系数.工地运输混凝土杆);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "通信线路" && in(parent.编码,"JYX1-17~22")
:
(@拆除通信线路地形系数.工地运输金具);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "通信线路" && (in(parent.编码,"JYX1-23~108") && strFind(parent.名称,"装卸") == -1)
:
(@拆除通信线路地形系数.工汽拖运输);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "通信线路" && in(parent.编码,"CYX1-1~4")
:
(@拆除通信线路地形系数.基础工程);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "通信线路" && in(parent.编码,"CYX2-1~40")
:
(@拆除通信线路地形系数.杆塔工程);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "通信线路" && in(parent.编码,"CYX3-1~27")
:
(@拆除通信线路地形系数.架线一般);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "通信线路" && in(parent.编码,"CYX3-28~42")
:
(@拆除通信线路地形系数.架线张力);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "通信线路" && in(parent.编码,"CYX4-1~131")
:
(@拆除通信线路地形系数.附件工程);
->parent.parent.专业类型 != "拆除" && parent.parent.专业类型 != "余物清理" && (in(parent.编码,"PZ1-87~129")|| in(parent.编码,"PGZ1-61~88"))
:
(_工程地形综合系数材机() );
->parent.parent.专业类型 != "拆除" && parent.parent.专业类型 != "余物清理" && strFind(parent.编码,"BG-PX7") == 0
:
(_工程地形综合系数材机() );
->parent.parent.专业类型 != "拆除" && parent.parent.专业类型 != "余物清理" && (strFind(parent.编码,"PX") == 0 || strFind(parent.编码,"PXG") == 0) &&(strFind(parent.编码,"PX1") != 0) && in(parent.编码,"PX5-77~86")==0
:
(_工程地形综合系数材机());
->parent.专业类型 != "拆除" && parent.专业类型 != "余物清理" && in(parent.编码,"PX1-1~6")
:
(_运输地形综合系数材机_不含城区());
->parent.专业类型 != "拆除" && parent.专业类型 != "余物清理" && (in(parent.编码,"PX1-7~30") && strFind(parent.名称,"装卸") == -1)
:
(_运输地形综合系数材机汽车拖拉机());
->parent.专业类型 != "拆除" && parent.专业类型 != "余物清理" && strFind(parent.编码,"PX1") == 0 && in(parent.编码,"PX1-1~30") == 0 && strFind(parent.名称,"装卸") == -1
:
(_运输地形综合系数材机());
}
}
BEGIN:_材机_定额地形系数_机械增加
${
?#{
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "架空线路" && in(parent.编码,"JYX1-1~16")
:
0;
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "架空线路" && in(parent.编码,"JYX1-17~22")
:
0;
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "架空线路" && (in(parent.编码,"JYX1-23~108") && strFind(parent.名称,"装卸") == -1)
:
(@拆除架空线路地形系数.工汽拖运输);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "架空线路" && in(parent.编码,"CYX1-1~4")
:
(@拆除架空线路地形系数.基础工程);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "架空线路" && in(parent.编码,"CYX2-1~40")
:
(@拆除架空线路地形系数.杆塔工程);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "架空线路" && in(parent.编码,"CYX3-1~27")
:
(@拆除架空线路地形系数.架线一般);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "架空线路" && in(parent.编码,"CYX3-28~42")
:
(@拆除架空线路地形系数.架线张力);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "架空线路" && in(parent.编码,"CYX4-1~131")
:
(@拆除架空线路地形系数.附件工程);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "通信线路" && in(parent.编码,"JYX1-1~16")
:
0;
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "通信线路" && in(parent.编码,"JYX1-17~22")
:
0;
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "通信线路" && (in(parent.编码,"JYX1-23~108") && strFind(parent.名称,"装卸") == -1)
:
(@拆除通信线路地形系数.工汽拖运输);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "通信线路" && in(parent.编码,"CYX1-1~4")
:
(@拆除通信线路地形系数.基础工程);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "通信线路" && in(parent.编码,"CYX2-1~40")
:
(@拆除通信线路地形系数.杆塔工程);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "通信线路" && in(parent.编码,"CYX3-1~27")
:
(@拆除通信线路地形系数.架线一般);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "通信线路" && in(parent.编码,"CYX3-28~42")
:
(@拆除通信线路地形系数.架线张力);
->parent.parent.专业类型 == "拆除" && parent.专业属性 == "通信线路" && in(parent.编码,"CYX4-1~131")
:
(@拆除通信线路地形系数.附件工程);
->parent.parent.专业类型 != "拆除" && parent.parent.专业类型 != "余物清理" && (in(parent.编码,"PZ1-87~129")|| in(parent.编码,"PGZ1-61~88"))
:
(_工程地形综合系数材机() );
->parent.parent.专业类型 != "拆除" && parent.parent.专业类型 != "余物清理" && strFind(parent.编码,"BG-PX7") == 0
:
(_工程地形综合系数材机() );
->parent.parent.专业类型 != "拆除" && parent.parent.专业类型 != "余物清理" && (strFind(parent.编码,"PX") == 0 || strFind(parent.编码,"PXG") == 0) &&(strFind(parent.编码,"PX1") != 0) && in(parent.编码,"PX5-77~86")==0
:
iif(in(parent.编码,"PX2-8~18,PX2-23~27,PX2-38~45,PX2-51~59,PX2-65~72"), 0, (_工程地形综合系数材机()));
->parent.专业类型 != "拆除" && parent.专业类型 != "余物清理" && in(parent.编码,"PX1-1~6")
:
0;
->parent.专业类型 != "拆除" && parent.专业类型 != "余物清理" && (in(parent.编码,"PX1-7~30") && strFind(parent.名称,"装卸") == -1)
:
(_运输地形综合系数材机汽车拖拉机());
->parent.专业类型 != "拆除" && parent.专业类型 != "余物清理" && strFind(parent.编码,"PX1") == 0 && in(parent.编码,"PX1-1~30") == 0 && strFind(parent.名称,"装卸") == -1
:
(_运输地形综合系数材机());
}
}
//****20230119,电缆线路改为通信线路**//
BEGIN:_工程地形综合系数材机
${
?#{
->parent.专业属性 == "架空线路"
:@工程地形系数.架空线路;
->parent.专业属性 == "通信线路"
:@工程地形系数.通信线路;
->parent.专业属性 == "10kV架空线路"
:@工程地形系数.10kV架空线路;
->parent.专业属性 == "400V及以下架空线路"
:@工程地形系数.400V及以下架空线路;
}
}
//****20231109,新增人力运输、汽车拖拉机运输地形**//
BEGIN:_运输地形综合系数材机
${
?#{
->parent.专业属性 == "架空线路"
:@运输地形系数.架空线路;
->parent.专业属性 == "通信线路"
:@运输地形系数.通信线路;
->parent.专业属性 == "10kV架空线路"
:@运输地形系数.10kV架空线路;
->parent.专业属性 == "400V及以下架空线路"
:@运输地形系数.400V及以下架空线路;
}
}
//****20230120,新增不含城区地形系数**//
BEGIN:_运输地形综合系数材机_不含城区
${
?#{
->parent.专业属性 == "架空线路"
:@运输地形系数.架空线路_其中:人力运输.不含城区;
->parent.专业属性 == "通信线路"
:@运输地形系数.通信线路_其中:人力运输.不含城区;
->parent.专业属性 == "10kV架空线路"
:@运输地形系数.10kV架空线路_其中:人力运输.不含城区;
->parent.专业属性 == "400V及以下架空线路"
:@运输地形系数.400V及以下架空线路_其中:人力运输.不含城区;
}
}
//****20231109,新增以下变量,为了区分出汽车拖拉机运输地形的取值**//
BEGIN:_运输地形综合系数材机汽车拖拉机
${
?#{
->parent.专业属性 == "架空线路"
:@运输地形系数.架空线路_其中:汽车拖拉机运输;
->parent.专业属性 == "通信线路"
:@运输地形系数.通信线路_其中:汽车拖拉机运输;
->parent.专业属性 == "10kV架空线路"
:@运输地形系数.10kV架空线路_其中:汽车拖拉机运输;
->parent.专业属性 == "400V及以下架空线路"
:@运输地形系数.400V及以下架空线路_其中:汽车拖拉机运输;
}
}
BEGIN:_材机合并机械数量
${
sum(source, "机械",?#{
->机械.type == "主材"
:
机械.数量 * _项目划分费率();
-> parent.type == "项目划分"
:
机械.数量;
-> parent.type != "项目划分"
:
parent.数量 * _项目划分费率() * 机械.数量 * parent.机械系数 * parent.定额系数 * ( 1 + _材机_定额地形系数_机械增加() / 100);
})
}
BEGIN:_材机合并人工数量
${
sum(source, "人工",?#{
->人工.type == "主材"
:
人工.数量 * _项目划分费率();
-> parent.type == "项目划分"
:
人工.数量;
-> parent.type != "项目划分"
:
parent.数量 * _项目划分费率() * 人工.数量 * parent.人工系数 * parent.定额系数 * ( 1 + _材机_定额地形系数_人工增加() / 100);
})
}
BEGIN:_材机合并主材数量
${
sum(source, "主材",?主材.数量)
}
BEGIN:_材机合并设备数量
${
sum(source, "设备",?设备.数量)
}
BEGIN:_材机合并材料数量
${
sum(source, "材料",?#{
-> parent.type == "项目划分"
:
材料.数量;
//普通材料
->parent.type == "定额"
:
parent.数量 * _项目划分费率() * 材料.数量 * parent.材料系数 * parent.定额系数;
//配合比材料
-> parent.type == "材料"
:
parent.数量 * parent.parent.数量 * _项目划分费率() * 材料.数量 * parent.parent.材料系数 * parent.parent.定额系数;
})
}
BEGIN:_材机合并定额数量
${
sum(source, "定额",?定额.数量)
}
@@ -1,180 +0,0 @@
//-------------------------------------人工审前变量---------------------------------------------
BEGIN:_材机人工审前价差不含税
${
sum(source,"人材机",?人材机.审前市场价不含税 - 人材机.审前预算价不含税)
}
BEGIN:_材机人工审前市场价合价_不含税
${
round(?sum(source,"人材机",?人材机.审前市场价不含税 * 人材机.审前数量), _工程费用小数位数)
}
BEGIN:_材机人工审前预算价合价_不含税
${
round(?sum(source,"人材机",?人材机.审前预算价不含税 * 人材机.审前数量), _工程费用小数位数)
}
BEGIN:_材机人工审前价差合价_不含税
${
round(?sum(source,"人材机",?(人材机.审前市场价不含税 - 人材机.审前预算价不含税) * 人材机.审前数量), _工程费用小数位数)
}
BEGIN:_材机人工核增核减市场价合价_不含税
${
?_材机人工市场价合价()-_材机人工审前市场价合价_不含税()
}
BEGIN:_材机人工核增核减预算价合价_不含税
${
?_材机人工预算价合价()-_材机人工审前预算价合价_不含税()
}
//-------------------------------------机械审前变量---------------------------------------------
BEGIN:_材机机械审前价差不含税
${
sum(source,"人材机",?人材机.审前市场价不含税 - 人材机.审前预算价不含税)
}
BEGIN:_材机机械审前市场价合价_不含税
${
round(?sum(source,"人材机",?人材机.审前市场价不含税 * 人材机.审前数量), _工程费用小数位数)
}
BEGIN:_材机机械审前预算价合价_不含税
${
round(?sum(source,"人材机",?人材机.审前预算价不含税 * 人材机.审前数量), _工程费用小数位数)
}
BEGIN:_材机机械审前价差合价_不含税
${
round(?sum(source,"人材机",?(人材机.审前市场价不含税 - 人材机.审前预算价不含税) * 人材机.审前数量), _工程费用小数位数)
}
BEGIN:_材机机械核增核减市场价合价_不含税
${
?_材机机械市场价合价()-_材机机械审前市场价合价_不含税()
}
BEGIN:_材机机械核增核减预算价合价_不含税
${
?_材机机械预算价合价()-_材机机械审前预算价合价_不含税()
}
//-------------------------------------材料审前变量---------------------------------------------
BEGIN:_材机材料审前价差含税
${
sum(source,"人材机",?人材机.审前市场价含税 - 人材机.审前预算价含税)
}
BEGIN:_材机材料审前价差不含税
${
sum(source,"人材机",?人材机.审前市场价不含税 - 人材机.审前预算价不含税)
}
BEGIN:_材机材料审前市场价合价_含税
${
round(?sum(source,"人材机",?人材机.审前市场价含税 * 人材机.审前数量), _工程费用小数位数)
}
BEGIN:_材机材料审前市场价合价_不含税
${
round(?sum(source,"人材机",?人材机.审前市场价不含税 * 人材机.审前数量), _工程费用小数位数)
}
BEGIN:_材机材料审前预算价合价_含税
${
round(?sum(source,"人材机",?人材机.审前预算价含税 * 人材机.审前数量), _工程费用小数位数)
}
BEGIN:_材机材料审前预算价合价_不含税
${
round(?sum(source,"人材机",?人材机.审前预算价不含税 * 人材机.审前数量), _工程费用小数位数)
}
BEGIN:_材机材料审前价差合价_含税
${
round(?sum(source,"人材机",?(人材机.审前市场价含税 - 人材机.审前预算价含税) * 人材机.审前数量), _工程费用小数位数)
}
BEGIN:_材机材料审前价差合价_不含税
${
round(?sum(source,"人材机",?(人材机.审前市场价不含税 - 人材机.审前预算价不含税) * 人材机.审前数量), _工程费用小数位数)
}
BEGIN:_材机材料核增核减市场价合价_不含税
${
?_材机材料市场价合价不含税()-_材机材料审前市场价合价_不含税()
}
BEGIN:_材机材料核增核减市场价合价_含税
${
?_材机材料市场价合价含税()-_材机材料审前市场价合价_含税()
}
BEGIN:_材机材料核增核减预算价合价_不含税
${
?_材机材料预算价合价不含税()-_材机材料审前预算价合价_不含税()
}
BEGIN:_材机材料核增核减预算价合价_含税
${
?_材机材料预算价合价含税()-_材机材料审前预算价合价_含税()
}
//-------------------------------------主材审前变量---------------------------------------------
BEGIN:_材机主材审前市场价合价_含税
${
round(?sum(source,"人材机",?人材机.审前市场价含税 * 人材机.审前数量 ), _工程费用小数位数)
}
BEGIN:_材机主材审前市场价合价_不含税
${
round(?sum(source,"人材机",?人材机.审前市场价不含税 * 人材机.审前数量), _工程费用小数位数)
}
BEGIN:_材机主材核增核减市场价合价_含税
${
?_材机主材合价含税()-_材机主材审前市场价合价_含税()
}
BEGIN:_材机主材核增核减市场价合价_不含税
${
?_材机主材合价不含税()-_材机主材审前市场价合价_不含税()
}
//-------------------------------------设备审前变量---------------------------------------------
BEGIN:_材机设备审前市场价合价_含税
${
round(?sum(source,"人材机",?人材机.审前市场价含税 * 人材机.审前数量), _工程费用小数位数)
}
BEGIN:_材机设备审前市场价合价_不含税
${
round(?sum(source,"人材机",?人材机.审前市场价不含税 * 人材机.审前数量), _工程费用小数位数)
}
BEGIN:_材机设备核增核减市场价合价_含税
${
?_材机设备合价含税()-_材机设备审前市场价合价_含税()
}
BEGIN:_材机设备核增核减市场价合价_不含税
${
?_材机设备合价不含税()-_材机设备审前市场价合价_不含税()
}
//---------------
BEGIN:_材机合并主材审前数量
${
sum(source, "主材",?主材.审前数量)
}
BEGIN:_材机合并设备审前数量
${
sum(source, "设备",?设备.审前数量)
}