in this below code function 'evaluate_fitness', i implemented the penalty for those objective metrics which doesnot with the desired target metrics, in the present code i made the fitness values as '0.0', if it with in the range. but i need to modify the code to promote the evaluation strategy to get maximum objective metrics, because if the objective metrics satisfies the condition its respective fitness is saturated to '0.0' if the objective metrics superior than the existing values in the required desired target metrics are not getting any insights in the evaluation process, all the values greater than the required target are considered as satisfactory, but i need you to consider the larger values to be less fitness even though it is in the acceptable desired range lesser values to be high fitness values(in negative values). i need minimize the objective metrics 'Area' and 'PowerDissipation' and i need to maxmize the objectives 'SlewRate', 'Gain', 'Bandwidth3dB', 'GainBWProd', and 'UnityGainFreq' and i need to keep the objective metrics 'PhaseMargin' with in the 75-90 is best lesser and greater than the vales are need to be penalize according to the below exinsting code.

# Evaluate fitness values based on constraints and objective_metrics
def evaluate_fitness(objective_metrics):
    # Define your weightage for different metrics
    weights = {
        'Area': -2.0,  # Lower Area is better and heavily penalized
        'PowerDissipation': -2.0,  # Lower PowerDissipation is better and heavily penalized
        'SlewRate': 2.0,  # SlewRate should be greater than 20
        'Gain': 2.0,  # Gain should be greater than 40
        'Bandwidth3dB': 1.0,  # Bandwidth3dB should be greater than 30e3
        'GainBWProd': 1.0,  # GainBWProd should be greater than or equal to 30e6
        'UnityGainFreq': 1.0,  # UnityGainFreq should be greater than or equal to 30e6
        'PhaseMargin': 2.0,  # PhaseMargin should be greater than or equal to 60
    }

    # Define scaling factors for each metric
    scaling_factors = {
        'Area': 1e-6,  # Micro meter square to square meter
        'PowerDissipation': 1,  # Milli watt to watt
        'SlewRate': 1e-6,  # Volt per microsecond to volt per second
        'Gain': 1,  # No scaling for dB
        'Bandwidth3dB': 1e3,  # KHz to Hz
        'GainBWProd': 1e6,  # MHz to Hz
        'UnityGainFreq': 1e6,  # MHz to Hz
        'PhaseMargin': 1,  # No scaling for angle
    }

    # Initialize fitness values for each objective
    fitness_values = {
        'Area': 0.0,
        'PowerDissipation': 0.0,
        'SlewRate': 0.0,
        'Gain': 0.0,
        'Bandwidth3dB': 0.0,
        'GainBWProd': 0.0,
        'UnityGainFreq': 0.0,
        'PhaseMargin': 0.0
    }

    # Calculate fitness for each objective
    for metric, weight in weights.items():
        value = objective_metrics.get(metric, 0.0)
        
        # Normalize the value based on its scaling factor
        normalized_value = value / scaling_factors[metric]

        if metric == 'Area' or metric == 'PowerDissipation':
            # Apply heavy penalties for Area and PowerDissipation
            fitness_values[metric] = weight * normalized_value
        else:
            # For other metrics, apply normal weightage
            if metric == 'SlewRate' and normalized_value < 10:
                # Penalize SlewRate if it's less than 20
                fitness_values[metric] = weight * (normalized_value - 10)
            elif metric == 'Gain' and normalized_value < 70:
                # Penalize Gain if it's less than 40
                fitness_values[metric] = weight * (normalized_value - 70)
            elif metric == 'Bandwidth3dB' and normalized_value < 30:
                # Penalize Bandwidth3dB if it's less than 30e3
                fitness_values[metric] = weight * (normalized_value - 30)
            elif metric == 'GainBWProd' and normalized_value < 10:
                # Penalize GainBWProd if it's less than 30e6
                fitness_values[metric] = weight * (normalized_value - 10)
            elif metric == 'UnityGainFreq' and normalized_value < 10:
                # Penalize UnityGainFreq if it's less than 30e6
                fitness_values[metric] = weight * (normalized_value - 10)
            elif metric == 'PhaseMargin':
                # Adjust 'PhaseMargin' penalties based on specified conditions
                if 60 <= normalized_value <= 95:
                    # No penalty if 'PhaseMargin' is between 60 and 90
                    fitness_values[metric] = 0.0
                elif 45 <= normalized_value <= 59:
                    # Penalize if 'PhaseMargin' is between 45 and 59
                    fitness_values[metric] = 1.0 * (normalized_value - 60)
                elif normalized_value < 45:
                    # Penalize if 'PhaseMargin' is below 60
                    fitness_values[metric] = 3.0 * (normalized_value - 60)
                elif normalized_value > 95:
                    # Penalize if 'PhaseMargin' is above 100
                    fitness_values[metric] = weight * (95 - normalized_value)
                elif normalized_value < 0:
                    # Penalize if 'PhaseMargin' is negative
                    fitness_values[metric] = 3.0 * (normalized_value - 60)

    # Combine the individual fitness values into an aggregated fitness value
    aggregated_fitness = sum(fitness_values.values())

    return aggregated_fitness, fitness_values

def scale_fitness_values(fitness_values, objectives):
    # Determine the maximum deviation for each objective from zero
    max_deviations = {obj: 0 for obj in objectives}
    for individual in fitness_values:
        for obj in objectives:
            deviation = abs(individual[obj])  # Absolute deviation from zero
            if deviation > max_deviations[obj]:
                max_deviations[obj] = deviation

    # Scale the values based on the maximum deviation
    scaled_fitness_values = []
    for individual in fitness_values:
        scaled_individual = {
            obj: abs(individual[obj]) / max_deviations[obj]
            if max_deviations[obj] != 0 else 0.0
            for obj in objectives
        }
        scaled_fitness_values.append(scaled_individual)

    return scaled_fitness_values

aggregated_fitness, fitness_values = evaluate_fitness(combined_metrics)

fitness_values = scale_fitness_values(fitness_values, objectives)