I need you to check and verify the below reward calculation function "calculate_reward(self, saturation_value, performance_metrics)" based on the below requirement, whether the given code satisfies the requirement or not in its computation steps. I implemeted this function with in my reinforcement learning approach.

I have total '8' parameters as a target specifications (1 saturation_value + 7 performance_metrics = 8 total target specifications), they are 'saturation_value', 'Area', 'PowerDissipation', 'SlewRate', 'Gain', 'Bandwidth3dB', 'UnityGainFreq', 'PhaseMargin'. I am optimumly tuning the design dimensions of the transistor in twostage opamp circuit to met the objective target specifications.

RL Reward Function condition, The reward is directly related to the design goal ('8' objective target specifications). We define the reward 𝑟𝑖 at each time step 𝑖 as 𝑟𝑖 = 𝑟, if 𝑟 < 0 or 𝑟𝑖 = 𝑅, if 𝑟 = 0, where 𝑟 = summation of  min{(𝑔𝑗𝑖 − 𝑔𝑗∗ )/(𝑔𝑗𝑖 + 𝑔𝑗∗), 0}. where, it is a normalized difference between the obtained performance metric values 𝑔𝑖 and the given predetermined performance measures (design specifications) 𝑔∗. 
Alter this given condition r, according to my below requirements:
Here my most preference parameter is the 'saturation_value', the desired value must be need to be '1'.
Then among 7 performance_metrics, the desired parameter values of 'Area', 'PowerDissipation' are need to be 'minimize' and 
the desired parameter values of 'SlewRate', 'Gain', 'Bandwidth3dB', 'UnityGainFreq', 'PhaseMargin' are need to be 'maximize'.
condition for rewards r, to be alter according to the required minimum and maximim conditions.
The upper bound of 𝑟 is set to be 0 to avoid overoptimizing the parameters once the given design specifications are reached. All 𝑁 design specifications are equally important. We also give a large reward (i.e., 𝑅 = 10) to encourage the agent if the design goals are reached at some step. The episode return 𝑅𝑠0,𝑔∗ of searching optimal design device parameters for the given goals 𝑔∗ starting from an initial state 𝑠0, is the accumulated reward of all steps: 𝑅𝑠0,𝑔∗ = summation of 𝑟𝑖 . Our goal is to train a good policy to maximize 𝑅𝑠0,𝑔∗ . 

Objective Target specifications Requirement:
saturation_value = 1 (must be attain)
'Area' lesser than '3e-10' (desired value should be lesser than target)
'PowerDissipation' lesser than '2500' (desired value should be lesser than target)
'SlewRate' greater than '20' (desired value should be greater than target)
'Gain' greater than '70' (desired value should be greater than target)
'Bandwidth3dB' greater than '30e3' (desired value should be greater than target)
'UnityGainFreq' greater than or equal to '30e6' (desired value should be greater than target)
'PhaseMargin' between '60-90' (desired value should be greater than target)

Code:
    def calculate_reward(self, saturation_value, performance_metrics):        
        Area = performance_metrics['Area']
        PowerDissipation = performance_metrics['PowerDissipation']
        SlewRate = performance_metrics['SlewRate']
        Gain = performance_metrics['Gain']
        Bandwidth3dB = performance_metrics['Bandwidth3dB']
        UnityGainFreq = performance_metrics['UnityGainFreq']
        PhaseMargin = performance_metrics['PhaseMargin']

        # Check if saturation condition is met
        if saturation_value == 1:
            reward_saturation = 10  # Large reward if saturation condition is met
        else:
            reward_saturation = 0

        # Calculate reward based on other performance metrics and design specifications
        reward = 0
        reward += min((Area - 3e-10) / (Area + 3e-10), 0)
        reward += min((PowerDissipation - 2500) / (PowerDissipation + 2500), 0)
        reward += min((SlewRate - 20) / (SlewRate + 20), 0)
        reward += min((Gain - 70) / (Gain + 70), 0)
        reward += min((Bandwidth3dB - 30000) / (Bandwidth3dB + 30000), 0)
        reward += min((UnityGainFreq - 30000000) / (UnityGainFreq + 30000000), 0)
        #reward += min((phase_margin - 60) / (phase_margin + 60), 0)
        reward += min((PhaseMargin - 60) / (PhaseMargin + 30), 0)

        # Clip the reward to avoid overoptimizing
        reward = max(reward, 0)
        reward = min(reward, 10)

        # Add saturation reward
        reward += reward_saturation

        return reward