Benefit Richness Scoring Engine

python
# Benefit Richness Scoring Engine
def calculate_richness_score(plan_design, benchmark_cohort):
    component_scores = {}
    
    # Medical Plan Richness (40% weight)
    medical_factors = {
        'deductible_individual': plan_design.deductible_individual,
        'deductible_family': plan_design.deductible_family,
        'oop_max_individual': plan_design.oop_max_individual,
        'oop_max_family': plan_design.oop_max_family,
        'coinsurance': plan_design.coinsurance,
        'pcp_copay': plan_design.pcp_copay,
        'specialist_copay': plan_design.specialist_copay,
        'er_copay': plan_design.er_copay,
        'network_breadth': plan_design.network_provider_count / benchmark_cohort.avg_network_size
    }
    
    # Score each factor (0-100, lower deductible/copay = higher score)
    medical_score = 0
    for factor, value in medical_factors.items():
        if factor in ['deductible_individual', 'deductible_family', 'oop_max_individual', 'oop_max_family']:
            # Inverse scoring: lower is better
            peer_median = benchmark_cohort.median(factor)
            score = max(0, min(100, 100 - ((value - peer_median) / peer_median * 50)))
        elif factor == 'network_breadth':
            # Direct scoring: higher is better
            score = min(100, value * 100)
        else:  # copays
            peer_median = benchmark_cohort.median(factor)
            score = max(0, min(100, 100 - ((value - peer_median) / peer_median * 50)))
        
        medical_score += score / len(medical_factors)
    
    component_scores['medical'] = medical_score
    
    # Pharmacy Richness (30% weight)
    pharmacy_factors = {
        'tier_count': 5 if plan_design.specialty_tier else 4,  # More tiers = worse
        'generic_copay': plan_design.tier1_copay,
        'preferred_brand_copay': plan_design.tier2_copay,
        'nonpreferred_brand_copay': plan_design.tier3_copay,
        'specialty_copay': plan_design.tier4_copay if hasattr(plan_design, 'tier4_copay') else None,
        'prior_auth_prevalence': plan_design.prior_auth_drug_count / plan_design.total_formulary_drugs
    }
    
    pharmacy_score = 0
    scored_factors = 0
    for factor, value in pharmacy_factors.items():
        if value is None:
            continue
        peer_median = benchmark_cohort.median(factor)
        if factor in ['tier_count', 'prior_auth_prevalence']:
            # Inverse: fewer tiers/lower PA = better
            score = max(0, min(100, 100 - ((value - peer_median) / peer_median * 50)))
        else:  # copays
            score = max(0, min(100, 100 - ((value - peer_median) / peer_median * 50)))
        pharmacy_score += score
        scored_factors += 1
    
    component_scores['pharmacy'] = pharmacy_score / scored_factors
    
    # Ancillary Richness (30% weight)
    ancillary_factors = {
        'dental_annual_max': plan_design.dental_annual_max,
        'dental_preventive_coverage': 1.0 if plan_design.dental_preventive_pct == 100 else 0.5,
        'vision_exam_frequency': 12 if plan_design.vision_exam_months == 12 else 24,
        'mental_health_parity': 1.0 if plan_design.mental_health_parity else 0.0,
        'fertility_max': plan_design.fertility_lifetime_max if hasattr(plan_design, 'fertility_lifetime_max') else 0,
        'hsa_employer_contribution': plan_design.hsa_employer_annual if hasattr(plan_design, 'hsa_employer_annual') else 0
    }
    
    ancillary_score = 0
    for factor, value in ancillary_factors.items():
        peer_median = benchmark_cohort.median(factor)
        if peer_median > 0:
            # Direct scoring: higher is better for ancillary
            score = min(100, (value / peer_median) * 100)
        else:
            score = 100 if value > 0 else 0
        ancillary_score += score / len(ancillary_factors)
    
    component_scores['ancillary'] = ancillary_score
    
    # Composite Richness Score
    composite_score = (
        component_scores['medical'] * 0.40 +
        component_scores['pharmacy'] * 0.30 +
        component_scores['ancillary'] * 0.30
    )
    
    # Peer Percentile
    peer_scores = [calculate_richness_score(peer, benchmark_cohort)['composite'] 
                   for peer in benchmark_cohort.peers]
    percentile = sum(1 for s in peer_scores if s < composite_score) / len(peer_scores) * 100
    
    return {
        'composite': composite_score,
        'percentile': percentile,
        'medical': component_scores['medical'],
        'pharmacy': component_scores['pharmacy'],
        'ancillary': component_scores['ancillary'],
        'peer_cohort_size': len(benchmark_cohort.peers)
    }

# Example: Score your plan
your_plan = load_plan_design('2024')
peer_group = load_benchmark_cohort(industry='technology', region='west', size='5000-10000')

result = calculate_richness_score(your_plan, peer_group)

print("Benefit Richness Score: {:.0f}/100".format(result['composite']))
print("Peer Percentile: {:.0f}th".format(result['percentile']))
print("Medical: {:.0f}/100".format(result['medical']))
print("Pharmacy: {:.0f}/100".format(result['pharmacy']))
print("Ancillary: {:.0f}/100".format(result['ancillary']))