增加 基础价值B11 计算模块

app/api/v1/calculation/calcuation.py

@@ -0,0 +1,120 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from typing import Optional, List, Dict, Any
+import json
+
+from app.controllers.user_valuation import user_valuation_controller
+from app.schemas.valuation import (
+    UserValuationCreate,
+    UserValuationQuery,
+    UserValuationList,
+    UserValuationOut,
+    UserValuationDetail
+)
+from app.schemas.base import Success, SuccessExtra
+from app.utils.app_user_jwt import get_current_app_user_id
+from app.utils.calculation_engine.economic_value_b1.economic_value_b1 import EconomicValueB1Calculator
+
+app_valuations_router = APIRouter(tags=["用户端估值评估"])
+
+@app_valuations_router.post("/calculation", summary="计算估值")
+async def calculate_valuation(
+    data: UserValuationCreate,
+    user_id: int = Depends(get_current_app_user_id)
+):
+    """
+    计算估值评估
+    
+    根据用户提交的估值评估数据，调用计算引擎进行经济价值B1计算
+    """
+    try:
+        # 创建计算器实例
+        calculator = EconomicValueB1Calculator()
+        
+        # 从用户数据中提取计算所需的参数
+        input_data = _extract_calculation_params(data)
+        
+        # 调用计算引擎进行估值计算
+        calculation_result = calculator.calculate_complete_economic_value_b1(input_data)
+        
+        # 创建估值评估记录
+        result = await user_valuation_controller.create_valuation(
+            user_id=user_id,
+            data=data
+        )
+        
+        # 将计算结果添加到返回数据中
+        result_dict = json.loads(result.model_dump_json())
+        result_dict['calculation_result'] = calculation_result
+        
+        return Success(data=result_dict, msg="估值计算完成")
+        
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"计算失败: {str(e)}")
+
+
+def _extract_calculation_params(data: UserValuationCreate) -> Dict[str, Any]:
+    """
+    从用户提交的数据中提取计算所需的参数
+    
+    Args:
+        data: 用户提交的估值评估数据
+        
+    Returns:
+        Dict: 计算所需的参数字典
+    """
+    # 基础价值B11相关参数
+    # 财务价值所需数据 从近三年收益计算
+    three_year_income = data.three_year_income or [0, 0, 0]
+
+    
+    # 法律强度L相关参数 - 需要用户额外提供评分
+    # 这里使用默认值，实际应用中需要用户填写
+    patent_score = 5.0  # 专利分 (0-10分)
+    popularity_score = 5.0  # 普及地域分 (0-10分) 
+    infringement_score = 5.0  # 侵权分 (0-10分)
+    
+    # 发展潜力D相关参数
+    esg_score = 5.0  # ESG分 (0-10分)
+    # 创新投入比 = (研发费用/营收) * 100
+    try:
+        rd_investment = float(data.rd_investment or 0)
+        annual_revenue = float(data.annual_revenue or 1)  # 避免除零
+        innovation_ratio = (rd_investment / annual_revenue) * 100 if annual_revenue > 0 else 0
+    except (ValueError, TypeError):
+        innovation_ratio = 0.0
+    
+    # 行业系数I - 系统配置值
+    target_industry_roe = 0.15  # 目标行业平均ROE
+    benchmark_industry_roe = 0.12  # 基准行业ROE
+    
+    # 流量因子B12相关参数
+    # 近30天搜索指数S1 - 从社交媒体数据计算
+    search_index_s1 = 4500.0  # 默认值，实际应从API获取
+    industry_average_s2 = 5000.0  # 行业均值，系统配置
+    
+    # 社交媒体传播度S3 - 从线上账号信息计算
+    social_media_spread_s3 = 1.07  # 默认值，实际应从API获取
+    
+    # 政策乘数B13相关参数
+    # 政策契合度评分P - 根据行业和资助情况计算
+    policy_compatibility_score = 9.1  # 默认值，实际应系统计算
+    
+    return {
+        # 基础价值B11相关参数
+        'financial_value': financial_value,
+        'patent_score': patent_score,
+        'popularity_score': popularity_score,
+        'infringement_score': infringement_score,
+        'esg_score': esg_score,
+        'innovation_ratio': innovation_ratio,
+        'target_industry_roe': target_industry_roe,
+        'benchmark_industry_roe': benchmark_industry_roe,
+        
+        # 流量因子B12相关参数
+        'search_index_s1': search_index_s1,
+        'industry_average_s2': industry_average_s2,
+        'social_media_spread_s3': social_media_spread_s3,
+        
+        # 政策乘数B13相关参数
+        'policy_compatibility_score': policy_compatibility_score
+    }

app/utils/calculation_engine/__init__.py

@@ -0,0 +1,3 @@
+'''
+这是非物质文化遗产IP知识产权评估系统的核心计算引擎包。
+'''

app/utils/calculation_engine/economic_value_b1/__init__.py

@@ -0,0 +1,18 @@
+"""
+经济价值B1计算包
+经济价值B1 = 基础价值B11 × (1 + 流量因子B12) × 政策乘数B13
+"""
+
+from .economic_value_b1 import EconomicValueB1Calculator
+from .sub_formulas import (
+    BasicValueB11Calculator,
+    TrafficFactorB12Calculator,
+    PolicyMultiplierB13Calculator
+)
+
+__all__ = [
+    "EconomicValueB1Calculator",
+    "BasicValueB11Calculator",
+    "TrafficFactorB12Calculator",
+    "PolicyMultiplierB13Calculator"
+]

app/utils/calculation_engine/economic_value_b1/economic_value_b1.py

@@ -0,0 +1,142 @@
+"""
+经济价值B1计算模块
+
+经济价值B1 = 基础价值B11 × (1 + 流量因子B12) × 政策乘数B13
+
+"""
+
+from typing import Dict
+try:
+    # 相对导入（当作为包使用时）
+    from .sub_formulas.basic_value_b11 import BasicValueB11Calculator
+    from .sub_formulas.traffic_factor_b12 import TrafficFactorB12Calculator
+    from .sub_formulas.policy_multiplier_b13 import PolicyMultiplierB13Calculator
+except ImportError:
+    # 绝对导入（当直接运行时）
+    from sub_formulas.basic_value_b11 import BasicValueB11Calculator
+    from sub_formulas.traffic_factor_b12 import TrafficFactorB12Calculator
+    from sub_formulas.policy_multiplier_b13 import PolicyMultiplierB13Calculator
+
+
+class EconomicValueB1Calculator:
+    """经济价值B1计算器"""
+    
+    def __init__(self):
+        """初始化计算器"""
+        self.basic_value_calculator = BasicValueB11Calculator()
+        self.traffic_factor_calculator = TrafficFactorB12Calculator()
+        self.policy_multiplier_calculator = PolicyMultiplierB13Calculator()
+    
+    def calculate_economic_value_b1(self,
+                                   basic_value_b11: float,
+                                   traffic_factor_b12: float,
+                                   policy_multiplier_b13: float) -> float:
+        """
+        计算经济价值B1
+        
+        
+        经济价值B1 = 基础价值B11 × (1 + 流量因子B12) × 政策乘数B13
+        
+        Args:
+            basic_value_b11: 基础价值B11 (系统计算)
+            traffic_factor_b12: 流量因子B12 (系统计算)
+            policy_multiplier_b13: 政策乘数B13 (系统计算)
+            
+        Returns:
+            float: 经济价值B1
+        """
+        economic_value = basic_value_b11 * (1 + traffic_factor_b12) * policy_multiplier_b13
+        
+        return economic_value
+    
+    def calculate_complete_economic_value_b1(self, input_data: Dict) -> Dict:
+        """
+        计算完整的经济价值B1，包含所有子公式
+        
+        Args:
+            input_data: 输入数据字典，包含所有必要的参数
+            
+        Returns:
+            Dict: 包含所有中间计算结果和最终结果的字典
+        """
+        # 财务价值F 近三年年均收益列表 [1,2,3]
+
+        financial_value = self.basic_value_calculator.calculate_financial_value_f()
+        # 计算法律强度L   patent_score: 专利分 (0-10分) (用户填写)
+        #              popularity_score: 普及地域分 (0-10分) (用户填写)
+        #              infringement_score: 侵权分 (0-10分) (用户填写)
+
+        legal_strength = self.basic_value_calculator.calculate_legal_strength_l()
+        # 发展潜力      patent_score: 专利分 (0-10分) (用户填写)
+        #             esg_score: ESG分 (0-10分) (用户填写)
+        #             innovation_ratio: 创新投入比 (研发费用/营收) * 100 (用户填写)
+
+        development_potential = self.basic_value_calculator.calculate_development_potential_d()
+        # 计算行业系数I  target_industry_roe: 目标行业平均ROE (系统配置)
+        #             benchmark_industry_roe: 基准行业ROE (系统配置)
+        industry_coefficient = self.basic_value_calculator.calculate_industry_coefficient_i()
+        # 计算基础价值B11
+        basic_value_b11 = self.basic_value_calculator.calculate_basic_value_b11(
+            financial_value,
+            legal_strength,
+            development_potential,
+            industry_coefficient
+        )
+        
+        # 计算流量因子B12
+        traffic_factor_b12 = self.traffic_factor_calculator.calculate_traffic_factor_b12(
+            input_data['search_index_s1'],
+            input_data['industry_average_s2'],
+            input_data['social_media_spread_s3']
+        )
+        
+        # 计算政策乘数B13
+        policy_multiplier_b13 = self.policy_multiplier_calculator.calculate_policy_multiplier_b13(
+            input_data['policy_compatibility_score']
+        )
+        
+        # 计算经济价值B1
+        economic_value_b1 = self.calculate_economic_value_b1(
+            basic_value_b11,
+            traffic_factor_b12,
+            policy_multiplier_b13
+        )
+        
+        return {
+            'basic_value_b11': basic_value_b11,
+            'traffic_factor_b12': traffic_factor_b12,
+            'policy_multiplier_b13': policy_multiplier_b13,
+            'economic_value_b1': economic_value_b1
+        }
+
+
+# 示例使用
+if __name__ == "__main__":
+
+    calculator = EconomicValueB1Calculator()
+    
+    # 示例数据
+    input_data = {
+        # 基础价值B11相关参数
+        'financial_value': 68.04,  # 财务价值F
+        'legal_strength': 7.90,    # 法律强度L
+        'development_potential': 6.00,  # 发展潜力D
+        'industry_coefficient': 0.25,   # 行业系数I
+        
+        # 流量因子B12相关参数
+        'search_index_s1': 4500.0,  # 近30天搜索指数S1
+        'industry_average_s2': 5000.0,  # 行业均值S2
+        'social_media_spread_s3': 1.07,  # 社交媒体传播度S3
+        
+        # 政策乘数B13相关参数
+        'policy_compatibility_score': 9.1  # 政策契合度评分P
+    }
+    
+    # 计算经济价值B1
+    result = calculator.calculate_complete_economic_value_b1(input_data)
+    
+    print("经济价值B1计算结果:")
+    print(f"基础价值B11: {result['basic_value_b11']:.2f}")
+    print(f"流量因子B12: {result['traffic_factor_b12']:.4f}")
+    print(f"政策乘数B13: {result['policy_multiplier_b13']:.4f}")
+    print(f"经济价值B1: {result['economic_value_b1']:.2f}")

app/utils/calculation_engine/economic_value_b1/sub_formulas/__init__.py

@@ -0,0 +1,34 @@
+"""
+经济价值B1子公式包
+
+包含经济价值B1的所有子公式计算模块：
+
+1. basic_value_b11: 基础价值B11计算
+   - 财务价值F = [3年内年均收益 × (1 + 增长率)^5] / 5
+   - 法律强度L = 专利分 × 0.4 + 普及分 × 0.3 + 侵权分 × 0.3
+   - 发展潜力D = 专利分 × 0.5 + ESG分 × 0.2 + 创新投入比 × 0.3
+   - 行业系数I = (目标行业平均ROE - 基准行业ROE) / 基准行业ROE
+
+   - 基础价值B11 = 财务价值F × (0.45 + 0.05 × 行业系数I) + 法律强度L × (0.35 + 0.05 × 行业系数I) + 发展潜力D × 0.2
+
+2. traffic_factor_b12: 流量因子B12计算
+   - 近30天搜索指数S1 = 百度搜索指数 × 0.4 + 微信搜索指数 × 0.3 + 微博搜索指数 × 0.3
+   - 社交媒体传播度S3 = 互动量指数 × 0.4 + 覆盖人群指数 × 0.3 + 转化效率 × 0.3
+   - 行业均值S2 =  系统内根据行业自动匹配行业均值S2
+
+   - 流量因子B12 = ln(近30天搜索指数S1/行业均值S2) × 0.3 + 社交媒体传播度S3 × 0.7
+
+3. policy_multiplier_b13: 政策乘数B13计算
+   - 政策契合度P = 政策匹配度 × 0.4 + 实施阶段评分 × 0.3 + 资金支持度 × 0.3
+   - 政策乘数B13 = 1 + (政策契合度评分P × 0.15)
+"""
+
+from .basic_value_b11 import BasicValueB11Calculator
+from .traffic_factor_b12 import TrafficFactorB12Calculator
+from .policy_multiplier_b13 import PolicyMultiplierB13Calculator
+
+__all__ = [
+    "BasicValueB11Calculator",
+    "TrafficFactorB12Calculator",
+    "PolicyMultiplierB13Calculator"
+]

app/utils/calculation_engine/economic_value_b1/sub_formulas/basic_value_b11.py

@@ -0,0 +1,296 @@
+import math
+from typing import List, Optional
+
+
+class BasicValueB11Calculator:
+    """基础价值B11计算器"""
+
+    def __init__(self):
+        """初始化计算器"""
+        pass
+
+    def calculate_basic_value_b11(self,
+                                  financial_value: float,
+                                  legal_strength: float,
+                                  development_potential: float,
+                                  industry_coefficient: float) -> float:
+        """
+        计算基础价值B11
+
+        基础价值B11 = 财务价值F × (0.45 + 0.05 × 行业系数I) + 法律强度L × (0.35 + 0.05 × 行业系数I) + 发展潜力D × 0.2
+
+        Args:
+            financial_value: 财务价值F (用户填写)
+            legal_strength: 法律强度L (用户填写)
+            development_potential: 发展潜力D (用户填写)
+            industry_coefficient: 行业系数I (系统配置)
+
+        Returns:
+            float: 基础价值B11
+        """
+        basic_value = (financial_value * (0.45 + 0.05 * industry_coefficient) +
+                       legal_strength * (0.35 + 0.05 * industry_coefficient) +
+                       development_potential * 0.2)
+
+        return basic_value
+
+    def growth_rate(self, annual_revenue_3_years: List[float]):
+        """
+
+        """
+        g1, g2 = (annual_revenue_3_years[1] - annual_revenue_3_years[0]) / annual_revenue_3_years[0] * 100, (
+                    annual_revenue_3_years[2] - annual_revenue_3_years[1]) / annual_revenue_3_years[1] * 100
+        predicted_growth = g2 + (g2 - g1)
+        return predicted_growth
+
+    def calculate_financial_value_f(self,
+                                    annual_revenue_3_years: List[float],
+                                    growth_rate: Optional[float] = None) -> float:
+        """
+        计算财务价值F
+
+        财务价值F = [3年内年均收益 × (1 + 增长率)^5] / 5
+
+        Args:
+            annual_revenue_3_years: 近三年年均收益列表，单位：万元 (用户填写)
+            growth_rate: 增长率，如果为None则自动计算 (用户填写)
+
+        Returns:
+            float: 财务价值F
+        """
+        if len(annual_revenue_3_years) != 3:
+            raise ValueError("必须提供近三年的收益数据")
+
+        # 计算年均收益
+        avg_annual_revenue = sum(annual_revenue_3_years) / 3
+
+        # 如果没有提供增长率，则根据三年数据计算
+        if growth_rate is None:
+            growth_rate = self._calculate_growth_rate(annual_revenue_3_years)
+
+        financial_value = (avg_annual_revenue * math.pow(1 + growth_rate, 5)) / 5
+
+        return financial_value
+
+    def _calculate_growth_rate(self, revenue_data: List[float]) -> float:
+        """
+        根据三年收益数据计算增长率
+
+        Args:
+            revenue_data: 三年收益数据 (用户填写)
+
+        Returns:
+            float: 增长率
+        """
+        if len(revenue_data) != 3:
+            raise ValueError("必须提供三年的收益数据")
+
+        # 计算两个增长率差值作为预测的增长率差值
+        growth_rate_1 = (revenue_data[1] - revenue_data[0]) / revenue_data[0] if revenue_data[0] != 0 else 0
+        growth_rate_2 = (revenue_data[2] - revenue_data[1]) / revenue_data[1] if revenue_data[1] != 0 else 0
+
+        # 使用两个增长率的平均值
+        avg_growth_rate = (growth_rate_1 + growth_rate_2) / 2
+
+        return avg_growth_rate
+
+    def calculate_legal_strength_l(self,
+                                   patent_score: float,
+                                   popularity_score: float,
+                                   infringement_score: float) -> float:
+        """
+        计算法律强度L
+
+
+        法律强度L = 专利分 × 0.4 + 普及分 × 0.3 + 侵权分 × 0.3
+
+        Args:
+            patent_score: 专利分 (0-10分) (用户填写)
+            popularity_score: 普及地域分 (0-10分) (用户填写)
+            infringement_score: 侵权分 (0-10分) (用户填写)
+
+        Returns:
+            float: 法律强度L
+        """
+
+        legal_strength = (patent_score * 0.4 +
+                          popularity_score * 0.3 +
+                          infringement_score * 0.3)
+
+        return legal_strength
+
+    def calculate_development_potential_d(self,
+                                          patent_score: float,
+                                          esg_score: float,
+                                          innovation_ratio: float) -> float:
+        """
+        计算发展潜力D
+
+
+        发展潜力D = 专利分 × 0.5 + ESG分 × 0.2 + 创新投入比 × 0.3
+
+        Args:
+            patent_score: 专利分 (0-10分) (用户填写)
+            esg_score: ESG分 (0-10分) (用户填写)
+            innovation_ratio: 创新投入比 (研发费用/营收) * 100 (用户填写)
+
+        Returns:
+            float: 发展潜力D
+        """
+
+        development_potential = (patent_score * 0.5 +
+                                 esg_score * 0.2 +
+                                 innovation_ratio * 0.3)
+
+        return development_potential
+
+    def calculate_industry_coefficient_i(self,
+                                         target_industry_roe: float,
+                                         benchmark_industry_roe: float) -> float:
+        """
+        计算行业系数I
+
+        行业系数I = (目标行业平均ROE - 基准行业ROE) / 基准行业ROE
+
+        Args:
+            target_industry_roe: 目标行业平均ROE (系统配置)
+            benchmark_industry_roe: 基准行业ROE (系统配置)
+
+        Returns:
+            float: 行业系数I
+        """
+        if benchmark_industry_roe == 0:
+            raise ValueError("基准行业ROE不能为0")
+
+        industry_coefficient = (target_industry_roe - benchmark_industry_roe) / benchmark_industry_roe
+
+        return industry_coefficient
+
+
+# 专利相关计算函数
+def calculate_patent_score(patent_remaining_years: int) -> float:
+    """
+    计算专利分
+
+    专利剩余保护期评分标准：
+    - >10年: 10分
+    - 5-10年: 7分
+    - <5年: 3分
+
+    Args:
+        patent_remaining_years: 专利剩余保护期（年） (用户填写)
+
+    Returns:
+        float: 专利分
+    """
+    if patent_remaining_years > 10:
+        return 10.0
+    elif patent_remaining_years >= 5:
+        return 7.0
+    else:
+        return 3.0
+
+
+# 识别用户所上传的图像中的专利号，通过API验证专利是否存在，按所用专利数量赋分，未引用0分，每引用一项+2.5分，10分封顶（0-10分）
+def calculate_patent_usage_score(patent_count: int) -> float:
+    """
+    计算专利使用量分
+
+    专利使用量评分标准：
+    - 未引用: 0分
+    - 每引用一项: +2.5分
+    - 10分封顶
+
+    Args:
+        patent_count: 专利数量 (用户填写)
+
+    Returns:
+        float: 专利使用量分
+    """
+    score = min(patent_count * 2.5, 10.0)
+    return score
+
+
+# 普及地域评分
+def calculate_popularity_score(region_coverage: str) -> float:
+    """
+    计算普及地域分
+
+    全球覆盖(10分)，全国覆盖(7分)，区域覆盖(4分)
+
+    Args:
+        region_coverage: 普及地域类型 (用户填写)
+
+    Returns:
+        float: 普及地域分
+    """
+    coverage_scores = {
+        "全球覆盖": 10.0,
+        "全国覆盖": 7.0,
+        "区域覆盖": 4.0
+    }
+
+    return coverage_scores.get(region_coverage, 0.0)
+
+
+# 侵权记录评分
+def calculate_infringement_score(infringement_status: str) -> float:
+    """
+    计算侵权记录分
+
+    无侵权记录(10分)，历史侵权已解决(6分)，现存纠纷(2分)
+
+    Args:
+        infringement_status: 侵权记录状态 (用户填写)
+
+    Returns:
+        float: 侵权记录分
+    """
+    infringement_scores = {
+        "无侵权记录": 10.0,
+        "历史侵权已解决": 6.0,
+        "现存纠纷": 2.0
+    }
+
+    return infringement_scores.get(infringement_status, 0.0)
+
+
+# 示例使用
+if __name__ == "__main__":
+    # 创建计算器实例
+    calculator = BasicValueB11Calculator()
+
+    # 示例数据
+    annual_revenue = [100, 120, 150]  # 近三年收益，单位：万元 (用户填写)
+    patent_remaining_years = 8  # 专利剩余年限 (用户填写)
+    region_coverage = "全国覆盖"  # 普及地域 (用户填写)
+    infringement_status = "无侵权记录"  # 侵权记录 (用户填写)
+    patent_count = 2  # 专利数量 (用户填写)
+    esg_score = 10.0  # ESG分 (用户填写)
+    innovation_ratio = 5.0  # 创新投入比 (用户填写) 创新投入比（研发费用/营收）*100
+    target_industry_roe = 0.15  # 目标行业ROE (系统配置)
+    benchmark_industry_roe = 0.12  # 基准行业ROE (系统配置)
+
+    # 计算各项指标
+    financial_value = calculator.calculate_financial_value_f(annual_revenue)
+    patent_score = calculate_patent_score(patent_remaining_years)
+    popularity_score = calculate_popularity_score(region_coverage)
+    infringement_score = calculate_infringement_score(infringement_status)
+    legal_strength = calculator.calculate_legal_strength_l(patent_score, popularity_score, infringement_score)
+
+    patent_usage_score = calculate_patent_usage_score(patent_count)
+    development_potential = calculator.calculate_development_potential_d(patent_usage_score, esg_score,
+                                                                         innovation_ratio)
+
+    industry_coefficient = calculator.calculate_industry_coefficient_i(target_industry_roe, benchmark_industry_roe)
+
+    # 计算基础价值B11
+    basic_value = calculator.calculate_basic_value_b11(
+        financial_value, legal_strength, development_potential, industry_coefficient
+    )
+
+    print(f"财务价值F: {financial_value:.2f}")
+    print(f"法律强度L: {legal_strength:.2f}")
+    print(f"发展潜力D: {development_potential:.2f}")
+    print(f"行业系数I: {industry_coefficient:.4f}")
+    print(f"基础价值B11: {basic_value:.2f}")

app/utils/calculation_engine/economic_value_b1/sub_formulas/policy_multiplier_b13.py

@@ -0,0 +1,134 @@
+class PolicyMultiplierB13Calculator:
+    """政策乘数B13计算器"""
+
+    def __init__(self):
+        """初始化计算器"""
+        pass
+
+    def calculate_policy_multiplier_b13(self, policy_compatibility_score: float) -> float:
+        """
+        计算政策乘数B13
+        
+        
+        政策乘数B13 = 1 + (政策契合度评分P × 0.15)
+        
+        Args:
+            policy_compatibility_score: 政策契合度评分P (系统计算)
+            
+        Returns:
+            float: 政策乘数B13
+        """
+        # 
+        policy_multiplier = 1 + (policy_compatibility_score * 0.15)
+
+        return policy_multiplier
+
+    def calculate_policy_compatibility_score(self,
+                                             policy_match_score: float,
+                                             implementation_stage_score: float,
+                                             funding_support_score: float) -> float:
+        """
+        计算政策契合度评分P
+        
+        
+        政策契合度P = 政策匹配度 × 0.4 + 实施阶段评分 × 0.3 + 资金支持度 × 0.3
+        
+        Args:
+            policy_match_score: 政策匹配度 (系统配置)
+            implementation_stage_score: 实施阶段评分 (用户填写)
+            funding_support_score: 资金支持度 (用户填写)
+            
+        Returns:
+            float: 政策契合度评分P
+        """
+        # 
+        policy_compatibility = (policy_match_score * 0.4 +
+                                implementation_stage_score * 0.3 +
+                                funding_support_score * 0.3)
+
+        return policy_compatibility
+
+    def calculate_policy_match_score(self, industry: str) -> float:
+        """
+        计算政策匹配度
+        
+        系统内根据行业自动匹配政策匹配度
+        
+        Args:
+            industry: 所属行业 (用户填写)
+            
+        Returns:
+            float: 政策匹配度
+        """
+
+        return 5
+
+    def calculate_implementation_stage_score(self, implementation_stage: str) -> float:
+        """
+        计算实施阶段评分
+        
+        用户选择目前资产的实施阶段，成熟应用(10分)、推广阶段(7分)、试点阶段(4分)
+        
+        Args:
+            implementation_stage: 实施阶段 (用户填写)
+            
+        Returns:
+            float: 实施阶段评分
+        """
+        stage_scores = {
+            "成熟应用": 10.0,
+            "推广阶段": 7.0,
+            "试点阶段": 4.0
+        }
+
+        return stage_scores.get(implementation_stage, 0.0)
+
+    def calculate_funding_support_score(self, funding_support: str) -> float:
+        """
+        计算资金支持度
+        
+        用户选择目前资产的资金支持情况，国家级资助(10分)、省级资助(7分)、无资助(0分)
+        
+        Args:
+            funding_support: 资金支持情况 (用户填写)
+            
+        Returns:
+            float: 资金支持度
+        """
+        funding_scores = {
+            "国家级资助": 10.0,
+            "省级资助": 7.0,
+            "无资助": 0.0
+        }
+
+        return funding_scores.get(funding_support, 0.0)
+
+
+# 示例使用
+if __name__ == "__main__":
+    # 创建计算器实例
+    calculator = PolicyMultiplierB13Calculator()
+
+    # 示例数据
+    industry = "文化艺术"  # 所属行业 (用户填写)
+    implementation_stage = "成熟应用"  # 实施阶段 (用户填写)
+    funding_support = "国家级资助"  # 资金支持 (用户填写)
+
+    # 计算各项指标
+    policy_match_score = calculator.calculate_policy_match_score(industry)
+    implementation_stage_score = calculator.calculate_implementation_stage_score(implementation_stage)
+    funding_support_score = calculator.calculate_funding_support_score(funding_support)
+
+    # 计算政策契合度评分P
+    policy_compatibility_score = calculator.calculate_policy_compatibility_score(
+        policy_match_score, implementation_stage_score, funding_support_score
+    )
+
+    # 计算政策乘数B13
+    policy_multiplier = calculator.calculate_policy_multiplier_b13(policy_compatibility_score)
+
+    print(f"政策匹配度: {policy_match_score:.2f}")
+    print(f"实施阶段评分: {implementation_stage_score:.2f}")
+    print(f"资金支持度: {funding_support_score:.2f}")
+    print(f"政策契合度评分P: {policy_compatibility_score:.2f}")
+    print(f"政策乘数B13: {policy_multiplier:.4f}")

app/utils/calculation_engine/economic_value_b1/sub_formulas/traffic_factor_b12.py

@@ -0,0 +1,305 @@
+import math
+from typing import Dict, Tuple
+
+
+
+class TrafficFactorB12Calculator:
+    """流量因子B12计算器"""
+    
+    def __init__(self):
+        """初始化计算器"""
+        pass
+    
+    def calculate_traffic_factor_b12(self,
+                                   search_index_s1: float,
+                                   industry_average_s2: float,
+                                   social_media_spread_s3: float) -> float:
+        """
+        计算流量因子B12
+
+        流量因子B12 = ln(近30天搜索指数S1/行业均值S2) × 0.3 + 社交媒体传播度S3 × 0.7
+        
+        Args:
+            search_index_s1: 近30天搜索指数S1 (API获取)
+            industry_average_s2: 行业均值S2 (系统配置)
+            social_media_spread_s3: 社交媒体传播度S3 (API获取)
+            
+        Returns:
+            float: 流量因子B12
+        """
+        # 避免除零和对数计算错误
+        if industry_average_s2 <= 0:
+            raise ValueError("行业均值S2必须大于0")
+        
+        if search_index_s1 <= 0:
+            # 如果搜索指数为0或负数，使用最小值避免对数计算错误
+            search_index_s1 = 1.0
+        
+        # ，不进行任何拆分
+        traffic_factor = (math.log(search_index_s1 / industry_average_s2) * 0.3 + 
+                         social_media_spread_s3 * 0.7)
+        
+        return traffic_factor
+    
+    def calculate_search_index_s1(self,
+                                 baidu_index: float,
+                                 wechat_index: float,
+                                 weibo_index: float) -> float:
+        """
+        计算近30天搜索指数S1
+
+        近30天搜索指数S1 = 百度搜索指数 × 0.4 + 微信搜索指数 × 0.3 + 微博搜索指数 × 0.3
+        
+        Args:
+            baidu_index: 百度搜索指数 (API获取)
+            wechat_index: 微信搜索指数 (API获取)
+            weibo_index: 微博搜索指数 (API获取)
+            
+        Returns:
+            float: 近30天搜索指数S1
+        """
+        # 
+        search_index = (baidu_index * 0.4 + 
+                       wechat_index * 0.3 + 
+                       weibo_index * 0.3)
+        
+        return search_index
+    
+    def calculate_social_media_spread_s3(self,
+                                       interaction_index: float,
+                                       coverage_index: float,
+                                       conversion_efficiency: float) -> float:
+        """
+        计算社交媒体传播度S3
+
+        社交媒体传播度S3 = 互动量指数 × 0.4 + 覆盖人群指数 × 0.3 + 转化效率 × 0.3
+        
+        Args:
+            interaction_index: 互动量指数 (API获取)
+            coverage_index: 覆盖人群指数 (API获取)
+            conversion_efficiency: 转化效率 (用户填写)
+            
+        Returns:
+            float: 社交媒体传播度S3
+        """
+        # 
+        social_media_spread = (interaction_index * 0.4 + 
+                              coverage_index * 0.3 + 
+                              conversion_efficiency * 0.3)
+        
+        return social_media_spread
+    
+    def calculate_interaction_index(self,
+                                 likes: int,
+                                 comments: int,
+                                 shares: int) -> float:
+        """
+        计算互动量指数
+
+        互动量指数 = (点赞 + 评论 + 转发) / 1000
+        
+        Args:
+            likes: 点赞数 (API获取)
+            comments: 评论数 (API获取)
+            shares: 转发数 (API获取)
+            
+        Returns:
+            float: 互动量指数
+        """
+        # 
+        interaction_index = (likes + comments + shares) / 1000.0
+        
+        return interaction_index
+    
+    def calculate_coverage_index(self, followers: int) -> float:
+        """
+        计算覆盖人群指数
+
+        覆盖人群指数 = 粉丝数 / 10000
+        
+        Args:
+            followers: 粉丝数 (API获取)
+            
+        Returns:
+            float: 覆盖人群指数
+        """
+        # 
+        coverage_index = followers / 10000.0
+        
+        return coverage_index
+    
+    def calculate_conversion_efficiency(self,
+                                      click_count: int,
+                                      view_count: int) -> float:
+        """
+        计算转化效率
+        
+        ：
+        转化效率 = 商品链接点击量 / 内容浏览量
+        
+        Args:
+            click_count: 商品链接点击量 (用户填写)
+            view_count: 内容浏览量 (用户填写)
+            
+        Returns:
+            float: 转化效率
+        """
+        if view_count == 0:
+            return 0.0
+        
+        # 
+        conversion_efficiency = click_count / view_count
+        
+        return conversion_efficiency
+
+
+class PlatformDataProcessor:
+    """平台数据处理类"""
+    
+    @staticmethod
+    def parse_platform_accounts(platform_data: str) -> Dict[str, str]:
+        """
+        解析平台账号数据
+        
+        输入格式：B站：12345678\n抖音：22334455
+        
+        Args:
+            platform_data: 平台账号数据字符串 (用户填写)
+            
+        Returns:
+            Dict[str, str]: 平台账号字典
+        """
+        accounts = {}
+        lines = platform_data.strip().split('\n')
+        
+        for line in lines:
+            if '：' in line or ':' in line:
+                separator = '：' if '：' in line else ':'
+                parts = line.split(separator, 1)
+                if len(parts) == 2:
+                    platform = parts[0].strip()
+                    account = parts[1].strip()
+                    accounts[platform] = account
+        
+        return accounts
+    
+    @staticmethod
+    def calculate_multi_platform_interaction(platform_data: Dict[str, Dict]) -> Tuple[float, float]:
+        """
+        计算多平台互动数据
+        
+        Args:
+            platform_data: 平台数据字典，格式为 {平台名: {likes: int, comments: int, shares: int, followers: int}} (API获取)
+            
+        Returns:
+            Tuple[float, float]: (互动量指数, 覆盖人群指数)
+        """
+        total_interactions = 0
+        total_followers = 0
+        
+        for platform, data in platform_data.items():
+            # 计算互动量
+            interactions = data.get('likes', 0) + data.get('comments', 0) + data.get('shares', 0)
+            total_interactions += interactions
+            
+            # 计算粉丝数
+            followers = data.get('followers', 0)
+            total_followers += followers
+        
+        # 计算指数
+        calculator = TrafficFactorB12Calculator()
+        interaction_index = calculator.calculate_interaction_index(
+            total_interactions, 0, 0  # 已经包含了所有互动数据
+        )
+        coverage_index = calculator.calculate_coverage_index(total_followers)
+        
+        return interaction_index, coverage_index
+
+
+# 热度评分相关函数
+def calculate_heat_score(daily_views: float, favorites: int) -> float:
+    """
+    计算热度分
+    
+    热度评分标准：
+    - 高热度：近7日日均浏览量 > 1000，或收藏数 > 100 → 1.0
+    - 中热度：近7日日均浏览量 ∈ [100, 1000]，或收藏数 ∈ [20, 100] → 0.6
+    - 低热度：近7日日均浏览量 < 100，且收藏数 < 20 → 0.2
+    - 无数据：无任何浏览与互动数据 → 0.0
+    
+    Args:
+        daily_views: 近7日日均浏览量 (API获取)
+        favorites: 收藏数 (API获取)
+        
+    Returns:
+        float: 热度分
+    """
+    if daily_views > 1000 or favorites > 100:
+        return 1.0
+    elif (daily_views >= 100 and daily_views <= 1000) or (favorites >= 20 and favorites <= 100):
+        return 0.6
+    elif daily_views < 100 and favorites < 20:
+        return 0.2
+    else:
+        return 0.0
+
+
+# 示例使用
+if __name__ == "__main__":
+    # 创建计算器实例
+    calculator = TrafficFactorB12Calculator()
+    processor = PlatformDataProcessor()
+    
+    # 示例数据
+    # 搜索指数数据 (API获取)
+    baidu_index = 6000.0
+    wechat_index = 4500.0
+    weibo_index = 3000.0
+    
+    # 行业均值 (系统配置)
+    industry_average = 5000.0
+    
+    # 平台账号数据 (用户填写)
+    platform_accounts = "B站：12345678\n抖音：22334455"
+    accounts = processor.parse_platform_accounts(platform_accounts)
+    
+    # 平台互动数据 (API获取)
+    platform_data = {
+        "B站": {
+            "likes": 1000,
+            "comments": 200,
+            "shares": 50,
+            "followers": 50000
+        },
+        "抖音": {
+            "likes": 2000,
+            "comments": 300,
+            "shares": 100,
+            "followers": 30000
+        }
+    }
+    
+    # 转化效率数据 (用户填写)
+    click_count = 20
+    view_count = 200
+    
+    # 计算各项指标
+    search_index_s1 = calculator.calculate_search_index_s1(baidu_index, wechat_index, weibo_index)
+    interaction_index, coverage_index = processor.calculate_multi_platform_interaction(platform_data)
+    conversion_efficiency = calculator.calculate_conversion_efficiency(click_count, view_count)
+    social_media_spread_s3 = calculator.calculate_social_media_spread_s3(
+        interaction_index, coverage_index, conversion_efficiency
+    )
+    
+    # 计算流量因子B12
+    traffic_factor = calculator.calculate_traffic_factor_b12(
+        search_index_s1, industry_average, social_media_spread_s3
+    )
+    
+    print(f"近30天搜索指数S1: {search_index_s1:.2f}")
+    print(f"行业均值S2: {industry_average:.2f}")
+    print(f"互动量指数: {interaction_index:.4f}")
+    print(f"覆盖人群指数: {coverage_index:.4f}")
+    print(f"转化效率: {conversion_efficiency:.4f}")
+    print(f"社交媒体传播度S3: {social_media_spread_s3:.4f}")
+    print(f"流量因子B12: {traffic_factor:.4f}")