# fd_distribution_plot.py
import numpy as np
import matplotlib.pyplot as plt

def fermi_dirac(E, Ef, T):
    """Calculates the Fermi-Dirac distribution function."""
    kB = 8.617e-5 # Boltzmann constant in eV/K
    return 1 / (np.exp((E - Ef) / (kB * T)) + 1)

# Define energy range
E = np.linspace(-0.5, 0.5, 500) # Energy in eV, centered around Ef=0

# Define Fermi Energy (Ef) at 0 eV for simplicity of plotting relative energies
Ef = 0

# Define temperatures
temperatures = [0.01, 77, 300, 600] # 0.01K (approx 0), 77K (Liquid Nitrogen), 300K (Room Temp), 600K (High Temp)

plt.figure(figsize=(10, 6))

for T in temperatures:
    F_E = fermi_dirac(E, Ef, T)
    plt.plot(E, F_E, label=f'T = {T} K')

plt.axvline(x=Ef, color='r', linestyle='--', label=f'Fermi Level (Ef = {Ef} eV)')
plt.xlabel('Energy (E - E_F) [eV]')
plt.ylabel('Probability of Occupation F(E)')
plt.title('Fermi-Dirac Distribution at Different Temperatures')
plt.grid(True)
plt.legend()
plt.ylim(-0.05, 1.05)
plt.show()

pip install numpy matplotlib
python fd_distribution_plot.py

# carrier_density_concept.py
import numpy as np

def fermi_dirac(E, Ef, T):
    kB = 8.617e-5 # Boltzmann constant in eV/K
    # Adding a small epsilon to the denominator to prevent division by zero in edge cases
    return 1 / (np.exp((E - Ef) / (kB * T)) + 1)

# Define generic band energies (relative values for conceptual understanding)
# Let's say Valence Band max is at E_V = -0.1 eV
# Let's say Conduction Band min is at E_C = 0.1 eV
# So, Band Gap E_g = E_C - E_V = 0.2 eV (small, typical for a narrow-gap semiconductor concept)

E_V = -0.1
E_C = 0.1
Eg = E_C - E_V

# Simulate various materials by adjusting Ef and Band Gap
materials = {
    "Insulator": {"Ef": 0.0, "Eg": 4.0}, # Large gap, Ef in middle
    "Semiconductor (Intrinsic)": {"Ef": 0.0, "Eg": 1.12}, # Silicon E_g, Ef in middle
    "Conductor": {"Ef": 0.0, "Eg": -0.5} # Negative Eg means CB overlaps VB, Ef inside. For illustration only.
}

T_room = 300 # Room temperature in Kelvin

print(f"Conceptual Carrier Concentration at T = {T_room} K")
print("-" * 50)

for material_name, props in materials.items():
    Ef_mat = props["Ef"]
    Eg_mat = props["Eg"]

    # Conceptual calculation of electrons in conduction band and holes in valence band
    # This is a simplification. Actual carrier concentration involves density of states.
    # Here, we're just checking probability of occupation at band edges.

    if material_name == "Conductor":
        # For a conductor, Ef is in the band, so high probability of states near Ef being occupied/empty
        print(f"{material_name}: Very High Carrier Density (Metallic)")
        print("-" * 50)
        continue

    # For Insulators/Semiconductors:
    # Probability of an electron existing at the bottom of the Conduction Band (E_C)
    prob_electron_CB = fermi_dirac(Ef_mat + Eg_mat/2, Ef_mat, T_room)
    # Probability of a state being empty (a hole) at the top of the Valence Band (E_V)
    # 1 - F(E_V) is the probability of a hole
    prob_hole_VB = 1 - fermi_dirac(Ef_mat - Eg_mat/2, Ef_mat, T_room)

    print(f"{material_name}: (Eg = {Eg_mat} eV, Ef = {Ef_mat} eV)")
    print(f"  Approx. Electron probability at CB edge: {prob_electron_CB:.6f}")
    print(f"  Approx. Hole probability at VB edge:     {prob_hole_VB:.6f}")
    print(f"  Combined (Conceptual) Carrier Potential: {prob_electron_CB + prob_hole_VB:.6f}")
    print("-" * 50)

python carrier_density_concept.py

# pn_junction_conceptual_barrier.py
import numpy as np
import matplotlib.pyplot as plt

# Simulate the conceptual energy band bending at a PN junction in equilibrium
# This is a very simplified model, showing band edges relative to a flat Fermi level.

# Define spatial axis for visualization: N-type on left, P-type on right
x = np.linspace(-1, 1, 400) # -1 to 0 for N-side, 0 to 1 for P-side

# Define intrinsic Fermi level (Ef_i) as 0 for reference
Ef_intrinsic = 0

# Define band gap (e.g., Silicon)
Eg_Si = 1.12 # eV

# Conceptual bulk Fermi levels for doped regions relative to intrinsic Fermi level
# N-type: Ef_n is closer to CB (e.g., 0.3 eV above Ef_i)
# P-type: Ef_p is closer to VB (e.g., 0.3 eV below Ef_i)
delta_Ef_doping = 0.3 # eV, conceptual shift due to doping
Ef_n_type_bulk = Ef_intrinsic + delta_Ef_doping
Ef_p_type_bulk = Ef_intrinsic - delta_Ef_doping

# In thermal equilibrium, the Fermi level must be flat across the entire device.
# The bands must bend to accommodate this.
# The amount of band bending (built-in potential) is phi_bi = Ef_n_type_bulk - Ef_p_type_bulk

# The bands are conceptually defined relative to the *local* Fermi level.
# In equilibrium, the global Fermi level is flat (Ef_global = Ef_intrinsic).
# So, E_C(x) = Ef_global + (E_C_bulk_relative_to_Ef_bulk) - E_potential(x)
# E_V(x) = Ef_global + (E_V_bulk_relative_to_Ef_bulk) - E_potential(x)
# Where E_potential(x) is the potential energy for an electron.

# Simulate the potential energy for an electron across the junction
# Let's use a tanh function for smooth transition in the depletion region
depletion_width_half = 0.4 # Half-width of depletion region
# The potential difference is Ef_n_type_bulk - Ef_p_type_bulk
# Scale the tanh function to span this potential difference
potential_energy_shift = (Ef_n_type_bulk - Ef_p_type_bulk) / 2 * np.tanh(x / depletion_width_half * 3)

# Calculate Conduction Band (Ec) and Valence Band (Ev) edges
# Ec_bulk_relative_to_Ef_intrinsic = Ef_intrinsic + Eg_Si/2
# Ev_bulk_relative_to_Ef_intrinsic = Ef_intrinsic - Eg_Si/2

# When Ef is flat (Ef_intrinsic), the bands bend according to the potential.
# E_C = (Ef_intrinsic + Eg_Si/2) - (Ef_n_type_bulk - potential_energy_shift_relative_to_center)
# This formulation needs refinement for clarity.

# Let's define the band edges directly relative to the flat Fermi level, accounting for doping.
# On the N-side, the conduction band minimum (Ec) is effectively at Ef_n_type_bulk + Eg_Si/2
# On the P-side, the valence band maximum (Ev) is effectively at Ef_p_type_bulk - Eg_Si/2

# The actual band edges will smoothly transition from the bulk N-type values to the bulk P-type values,
# such that the Fermi level remains flat.
E_C = np.zeros_like(x)
E_V = np.zeros_like(x)

for i, val_x in enumerate(x):
    # Determine the conceptual 'band-edge' relative to the flat Fermi level
    # This implicitly includes the effect of the built-in potential
    if val_x < 0: # N-side, closer to bulk N behavior
        # Simple linear approximation for band bending in depletion region for conceptual clarity
        if val_x < -depletion_width_half: # Bulk N
            E_C[i] = Ef_intrinsic + Eg_Si/2 - (Ef_n_type_bulk - Ef_intrinsic)
            E_V[i] = Ef_intrinsic - Eg_Si/2 - (Ef_n_type_bulk - Ef_intrinsic)
        else: # Transition region on N-side
            factor = (val_x + depletion_width_half) / depletion_width_half
            E_C_n_bulk = Ef_intrinsic + Eg_Si/2 - (Ef_n_type_bulk - Ef_intrinsic)
            E_V_n_bulk = Ef_intrinsic - Eg_Si/2 - (Ef_n_type_bulk - Ef_intrinsic)
            E_C_junction = Ef_intrinsic + Eg_Si/2 - (Ef_p_type_bulk - Ef_intrinsic)
            E_V_junction = Ef_intrinsic - Eg_Si/2 - (Ef_p_type_bulk - Ef_intrinsic)

            E_C[i] = E_C_n_bulk + factor * (E_C_junction - E_C_n_bulk)
            E_V[i] = E_V_n_bulk + factor * (E_V_junction - E_V_n_bulk)

    else: # P-side, closer to bulk P behavior
        if val_x > depletion_width_half: # Bulk P
            E_C[i] = Ef_intrinsic + Eg_Si/2 - (Ef_p_type_bulk - Ef_intrinsic)
            E_V[i] = Ef_intrinsic - Eg_Si/2 - (Ef_p_type_bulk - Ef_intrinsic)
        else: # Transition region on P-side
            factor = (val_x - depletion_width_half) / (-depletion_width_half) # Goes from 1 to 0
            E_C_p_bulk = Ef_intrinsic + Eg_Si/2 - (Ef_p_type_bulk - Ef_intrinsic)
            E_V_p_bulk = Ef_intrinsic - Eg_Si/2 - (Ef_p_type_bulk - Ef_intrinsic)
            E_C_junction = Ef_intrinsic + Eg_Si/2 - (Ef_n_type_bulk - Ef_intrinsic) # Needs rethinking.
            E_V_junction = Ef_intrinsic - Eg_Si/2 - (Ef_n_type_bulk - Ef_intrinsic) # This isn't right.

            # Simpler approach: Calculate the potential energy for an electron.
            # In equilibrium, total energy (Fermi level) is constant.
            # Potential energy of electron goes from lower (N) to higher (P)
            # Bands shift opposite to electron potential energy.
            built_in_potential_electron = Ef_n_type_bulk - Ef_p_type_bulk # Positive value

            if val_x < -depletion_width_half: # Bulk N
                current_potential = 0
            elif val_x > depletion_width_half: # Bulk P
                current_potential = built_in_potential_electron
            else: # Depletion region
                current_potential = (val_x + depletion_width_half) / (2 * depletion_width_half) * built_in_potential_electron

            E_C[i] = Ef_intrinsic + Eg_Si/2 - current_potential
            E_V[i] = Ef_intrinsic - Eg_Si/2 - current_potential


plt.figure(figsize=(10, 6))
plt.plot(x, E_C, label='Conduction Band (Ec)')
plt.plot(x, E_V, label='Valence Band (Ev)')
plt.axhline(y=Ef_intrinsic, color='r', linestyle='--', label='Fermi Level (Ef) - Equilibrium')
plt.axvline(x=0, color='k', linestyle=':', label='Junction')
plt.fill_between(x, E_V, E_C, where=(E_V < E_C), color='gray', alpha=0.1, label='Band Gap')
plt.xlabel('Position across Junction (Conceptual)')
plt.ylabel('Energy (eV)')
plt.title('Conceptual Energy Band Diagram of a PN Junction (Equilibrium)')
plt.legend()
plt.grid(True)
plt.ylim(Ef_intrinsic - Eg_Si * 1.2, Ef_intrinsic + Eg_Si * 1.2) # Adjust limits for better visibility
plt.xlim(-1, 1)
plt.text(-0.7, Ef_intrinsic + 0.4, 'N-type', fontsize=12, horizontalalignment='center')
plt.text(0.7, Ef_intrinsic + 0.4, 'P-type', fontsize=12, horizontalalignment='center')
plt.show()

python pn_junction_conceptual_barrier.py

# Example: Check CPU information and scaling governors
# This shows how the OS interacts with the CPU's ability to switch states.
# The underlying transistor behavior determines how fast it can switch,
# how much power it consumes, and how hot it gets.

echo "--- CPU Architecture Information ---"
lscpu | grep "Model name\|Architecture\|CPU max MHz\|CPU min MHz"

echo -e "\n--- CPU Core Frequencies (Live Sample) ---"
# Loop to show dynamic frequency scaling, which relies on transistor behavior
for i in $(seq 1 3); do
    echo "Sample $i:"
    # This command reads current CPU frequency from sysfs.
    # For multi-core CPUs, iterate through each core.
    # Adjust `cpu0` as needed for your system (e.g., cpu0 to cpuN-1)
    # Note: On some systems, this might be in /sys/devices/system/cpu/cpu*/cpufreq/scaling_cur_freq
    # or /sys/devices/system/cpu/cpu*/cpufreq/cpuinfo_cur_freq
    if [ -d /sys/devices/system/cpu/cpu0/cpufreq ]; then # Check if cpufreq dir exists for cpu0
        for cpu_dir in /sys/devices/system/cpu/cpu*; do
            CPU_NUM=$(basename "$cpu_dir")
            # Prefer scaling_cur_freq if available, otherwise fallback to cpuinfo_cur_freq
            if [ -f "$cpu_dir/cpufreq/scaling_cur_freq" ]; then
                FREQ=$(cat "$cpu_dir/cpufreq/scaling_cur_freq" | awk '{printf "%.2f MHz", $1/1000}')
                echo "  $CPU_NUM: $FREQ"
            elif [ -f "$cpu_dir/cpufreq/cpuinfo_cur_freq" ]; then
                FREQ=$(cat "$cpu_dir/cpufreq/cpuinfo_cur_freq" | awk '{printf "%.2f MHz", $1/1000}')
                echo "  $CPU_NUM: $FREQ (from cpuinfo_cur_freq)"
            fi
        done
    else
        echo "  (Cannot read live frequency from sysfs. Try: watch -n 1 'grep \"MHz\" /proc/cpuinfo')"
        grep "MHz" /proc/cpuinfo | head -n 1 # Fallback for some systems
    fi
    sleep 1
done

echo -e "\n--- CPU Governor (How frequency is managed) ---"
# The governor controls how the OS dynamically adjusts frequency based on load.
# This directly impacts power consumption and heat, which are Fermi-Dirac dependent.
if [ -f /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor ]; then
    cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor
else
    echo "  (Cannot read CPU governor)"
fi

# dram_leakage_concept.py
import numpy as np
import matplotlib.pyplot as plt

def model_leakage(initial_charge, time_steps, leakage_rate_per_sec, refresh_interval=None):
    """
    Simulates charge decay in a DRAM capacitor due to leakage current.
    Leakage rate is conceptual and represents the flow of charge carriers
    (governed by Fermi-Dirac distribution and band structure)
    across the transistor or through the dielectric.
    """
    charge_history = [initial_charge]
    current_charge = initial_charge

    for t in range(1, time_steps + 1):
        # Charge loss due to leakage
        current_charge -= leakage_rate_per_sec

        # Simulate refresh if interval is set
        if refresh_interval and t % refresh_interval == 0:
            current_charge = initial_charge # Restore to full charge

        charge_history.append(max(0, current_charge)) # Ensure charge doesn't go negative
    return charge_history

# Simulation parameters
initial_charge = 1.0 # Normalized charge (e.g., represents "1" state)
# Conceptual leakage rate. In real DRAM, this is on the order of femtoamps.
# Here, it's just a conceptual decay rate per time step.
leakage_rate = 0.005 # Units per time step
time_steps = 200

# Simulate without refresh
charge_no_refresh = model_leakage(initial_charge, time_steps, leakage_rate)

# Simulate with refresh (e.g., every 50 time steps, typical DRAM refresh is ms)
refresh_interval_steps = 50
charge_with_refresh = model_leakage(initial_charge, time_steps, leakage_rate, refresh_interval_steps)

plt.figure(figsize=(10, 6))
plt.plot(charge_no_refresh, label='Charge without Refresh (bit loss)')
plt.plot(charge_with_refresh, label=f'Charge with Refresh (every {refresh_interval_steps} steps)')
plt.axhline(y=initial_charge * 0.5, color='r', linestyle='--', label='Threshold for "1" (Conceptual)') # 50% for concept
plt.xlabel('Time Steps (Conceptual)')
plt.ylabel('Normalized Charge')
plt.title('Conceptual DRAM Charge Leakage and Refresh')
plt.grid(True)
plt.legend()
plt.ylim(0, initial_charge * 1.1)
plt.show()

python dram_leakage_concept.py

# Example: Check CPU temperature (requires 'lm-sensors' on Linux)
# Install on Debian/Ubuntu: sudo apt install lm-sensors
# Install on Fedora/RHEL: sudo dnf install lm_sensors
# Run 'sudo sensors-detect' first time if needed.

echo "--- System Temperatures ---"
sensors