Breadcrumbs

About

Intro Page

Shadows (Ray Optics)

Developed by E. Behringer

This set of exercises guides the student in exploring computationally the behavior of light patterns and shadows generated by simple light sources together with apertures in thin, opaque barriers. It requires the student to generate, and describe the results of simulating, light patterns and shadows. Diffraction is ignored. The numerical approach used is summing over a two-dimensional spatial grid while applying a logical mask (‘transparency function’). Please note that this set of computational exercises can be affordably coupled to simple experiments with small light bulbs and apertures cut into (or barriers cut out of) opaque paper sheets. A possible extension is to compare the predicted light patterns to experimental measurements. This set of exercises could be incorporated as an initial activity in an intermediate optics laboratory.

Subject Area	Waves & Optics
Levels	First Year and Beyond the First Year
Available Implementation	Python
Learning Objectives	Students who complete this set of exercises will be able to predict and visually represent the irradiance distribution at a screen generated by a point light source and an aperture (Exercise 1); predict and visually represent the irradiance distribution at a screen generated by multiple point light sources and an aperture (Exercise 2); predict and visually represent the irradiance distribution at a screen generated by multiple point light sources and a complex aperture (Exercise 3); predict and visually represent the irradiance distribution at a screen generated by a two-dimensional array of point light sources and an aperture (Exercise 4);, and predict and visually represent the irradiance distribution at a screen generated by a two-dimensional array of point light sources and an opaque barrier (Exercise 5).
Time to Complete	120 min

Exercise 1

EXERCISE 1: IRRADIANCE AT A SCREEN DUE TO A POINT SOURCE

We imagine that a point source of light at illuminates an aperture in an opaque barrier located at as shown below.

The irradiance of the light appearing at point on the viewing screen located at is then given by

I (x, y, z) = A r 2 T (x, y) (2)

where is a constant, is the distance from (the source) to (the screen point), and is a function we call the ‘transparency function’. If the line from the source at to the screen point passes through the aperture, then ; otherwise, . In the case where the aperture is a rectangle of width in the -direction and height in the -direction, show that the value of the transparency function is given byAlt Figure

T (x, y) = ⎧ ⎩ ⎨ ⎪ ⎪ 1, 0, if ∣ ∣ ∣ x S + x - x S z - z S ∣ ∣ z S ∣ ∣ ∣ ∣ ∣ < w 2 and ∣ ∣ ∣ y S + y - y S z - z S ∣ ∣ z S ∣ ∣ ∣ ∣ ∣ < h 2 otherwise . (3)

Compute the irradiance on an array of uniformly spaced screen points on the viewing screen for an aperture with cm and cm in the following cases:

[cm]	[cm]	[cm]	[cm]
0.0	0.0	-20.0	40.0
5.0	0.0	-20.0	40.0
0.0	5.0	-20.0	40.0
0.0	0.0	-10.0	40.0
0.0	0.0	-40.0	40.0
0.0	0.0	-20.0	60.0
0.0	0.0	-20.0	20.0

Does the computed light pattern change as you expect when you change the source and screen locations? Are the edges of the light pattern sharp or fuzzy? (How do you define “sharp” and “fuzzy”?) Why?

Shadows_Exercise_1.py

# Shadows_Exercise_1.py

# A point source is located a specified distance from

# a rectangular aperture that is centered on the origin.

# A screen is located a specified distance from

# the aperture.

# This file will generate a filled contour plot of

# the irradiance of the light reaching the screen

# versus lateral coordinates (x,y)

# Written by:

# Ernest R. Behringer

# Department of Physics and Astronomy

# Eastern Michigan University

# Ypsilanti, MI 48197

# (734) 487-8799

# ebehringe@emich.edu

# 20160112-13 original code by ERB

# 20160609 clean up by ERB

# import the commands needed to make the plot

from pylab import xlabel,ylabel,show,contourf,axis,colorbar,figure,title,xlim,ylim

from matplotlib import cm

# import the command needed to make a 1D array

from numpy import meshgrid,absolute,where,zeros,linspace

# inputs

zs = -20.0 # distance between the source and aperture [cm]

zsc = 40.0 # distance between the screen and aperture [cm]

rso = [5.0,0.0] # (x,y) location of the source [cm,cm]

ap_width = 4.0 # aperture width [cm]

ap_height = 3.0 # aperture height [cm]

screen_width = 60.0 # screen width [cm]

screen_height = 60.0 # wcreen height [cm]

nw = 240 # Number of screen width intervals

nh = 240 # Number of screen height intervals

# initialize needed arrays to zero

screen_x = zeros((nw+1,nh+1)) # x coordinates of screen points

screen_y = zeros((nw+1,nh+1)) # y coordinates of screen points

rsq = zeros((nw+1,nh+1)) # source-to-screen point distance, squared

x0 = zeros((nw+1,nh+1)) # x coordinates of ray intercepts at aperture plane

y0 = zeros((nw+1,nh+1)) # y coordinates of ray intercepts at aperture plane

# initialize values

screen_xx = linspace(-0.5*screen_width,0.5*screen_width,nw+1)

screen_yy = linspace(-0.5*screen_height,0.5*screen_height,nh+1)

# create the meshgrid on which to evaluate the irradiance

screen_xx, screen_yy = meshgrid(screen_xx,screen_yy)

# Calculate grid increments

deltaw = screen_width/nw # grid increment, width [cm]

deltah = screen_height/nh # grid increment, height [cm]

# Define the array of screen x and screen y values

for i in range (0,nw+1):

for j in range (0,nh+1):

screen_x[i,j] = -0.5*screen_width + deltaw*i

screen_y[i,j] = -0.5*screen_height + deltah*j

# Calculate the intensity at each screen point

for i in range (0,nw+1):

for j in range (0,nh+1):

# First calculate the square of the distance from source to screen

rsq = (screen_x[i,j]-rso[0])**2 + (screen_y[i,j]-rso[1])**2 + (zsc - zs)**2

# Calculate x and y coordinates at the aperture

x0[i,j] = rso[0] + abs(zs)*(screen_x[i,j] - rso[0])/(zsc - zs)

y0[i,j] = rso[1] + abs(zs)*(screen_y[i,j] - rso[1])/(zsc - zs)

# Check if the coordinates fall within the aperture

maskx = where(absolute(x0) < 0.5*ap_width,1.0,0.0)

masky = where(absolute(y0) < 0.5*ap_height,1.0,0.0)

# Calculate the intensity

irradiance = maskx*masky/rsq

# make a filled contour plot of the period vs overlap and length ratios

figure()

contourf(screen_yy,screen_xx,irradiance,100,cmap=cm.bone)

axis('equal')

xlim(-0.5*screen_width,0.5*screen_width)

ylim(-0.5*screen_height,0.5*screen_height)

xlabel(" $x$ [cm]",size = 16)

ylabel(" $y$ [cm]",size = 16)

title('Illumination pattern: $w =$ %s cm, $h =$ %s'%(ap_width,ap_height),size = 16)

colorbar().set_label(label='Irradiance [arb. units]',size=16)

show()

Translations

Code	Language		Translator	Run

Credits

Fremont Teng; Loo Kang Wee; based on codes by E. Behringer

Resources / Open Source Physics @ Singapore"

This briefing document summarizes the main themes and important ideas presented in the provided excerpts from the PICUP Exercise 1 virtual lab. The exercise focuses on understanding the irradiance of light from a point source as it passes through an aperture and reaches a screen.

Main Themes:

Modeling Light Propagation: The exercise models light as originating from a point source and propagating in straight lines. The concept of a point source at coordinates $P_s = (x_s, y_s, z_s)$ is introduced as the origin of the light.
The Role of an Aperture: An opaque barrier with an aperture (opening) is placed at $z = 0$ . This aperture selectively allows light to pass through, modifying the irradiance pattern on the screen. The concept of a "transparency function" $T(x, y)$ is central to describing the effect of the aperture.
Irradiance Calculation: The document provides a formula for calculating the irradiance $I(x, y, z)$ at a point $P = (x, y, z)$ on the viewing screen located at $z = z_{sc}$ :
"The irradiance of the light appearing at point $P = (x, y, z)$ on the viewing screen located at $z = z_{sc}$ is then given by
$I(x, y, z) = \frac{A}{r^2} T(x, y) \quad (2)$ "
Here, $A$ is a constant related to the source intensity, $r$ is the distance from the source to the screen point, and $T(x, y)$ is the transparency function of the aperture.
Transparency Function: The transparency function $T(x, y)$ determines whether a point on the $z=0$ plane allows light to pass through to a specific point on the screen.
"If the line from the source at $P_s$ to the screen point $P$ passes through the aperture, then $T(x, y) = 1$ ; otherwise, $T(x, y) = 0$ ."
Rectangular Aperture: The exercise specifically considers a rectangular aperture of width $w$ in the $x$ -direction and height $h$ in the $y$ -direction, centered at the origin of the $z=0$ plane. The document derives the transparency function for such an aperture:
"In the case where the aperture is a rectangle of width $w$ in the $x$ -direction and height $h$ in the $y$ -direction, show that the value of the transparency function is given by
$T(x, y) = \begin{cases} 1, & \text{if } \left| x_S + \frac{x - x_S}{z - z_S} z_S \right| < \frac{w}{2} \text{ and } \left| y_S + \frac{y - y_S}{z - z_S} z_S \right| < \frac{h}{2} \ 0, & \text{otherwise} \end{cases} \quad (3)$ "
This formula essentially checks if the ray from the source passing through the point $(x, y)$ on the screen at $z=z_{sc}$ intersects the aperture at $z=0$ within its defined width and height. Note that the provided formula in the excerpt has some formatting issues, the corrected interpretation considers the coordinates at the aperture plane projected from the source and screen points.
Computational Simulation: The excerpts also include segments of Python code using pylab and matplotlib libraries. This indicates that the exercise involves a computational simulation to calculate and visualize the irradiance pattern on the screen. The code initializes arrays to represent the screen coordinates (screen_x, screen_y), the squared distance from the source to the screen (rsq), and the coordinates of the ray intercepts at the aperture plane (x0, y0).
Determining Aperture Passage: The code uses conditional statements (where) based on the calculated intercept coordinates (x0, y0) and the aperture dimensions (ap_width, ap_height) to create masks (maskx, masky). These masks effectively implement the transparency function, determining which points on the screen receive light.

Most Important Ideas and Facts:

Irradiance is inversely proportional to the square of the distance from the point source: This fundamental concept is implied in the formula $I \propto 1/r^2$ when the transparency is 1.
The aperture acts as a spatial filter: It blocks light rays that do not pass through it, shaping the irradiance pattern on the screen.
The transparency function is a binary function (0 or 1) for a simple opaque barrier with an opening: It indicates whether a given path from the source to the screen is blocked or clear.
For a rectangular aperture, the conditions for light to pass through depend on the source position, the screen position, and the aperture dimensions. The provided formula (3) mathematically defines this condition.
Computational tools are used to simulate and visualize the irradiance pattern: The Python code demonstrates how numerical methods can be employed to solve this physics problem for a large number of screen points.
The simulation involves calculating the intersection point of the light ray with the aperture plane: This step is crucial for determining the value of the transparency function for each screen point.

Quotes:

"We imagine that a point source of light at $P_s = (x_s, y_s, z_s)$ illuminates an aperture in an opaque barrier located at $z = 0$ as shown below."
"The irradiance of the light appearing at point $P = (x, y, z)$ on the viewing screen located at $z = z_{sc}$ is then given by $I(x, y, z) = \frac{A}{r^2} T(x, y) \quad (2)$ "
"If the line from the source at $P_s$ to the screen point $P$ passes through the aperture, then $T(x, y) = 1$ ; otherwise, $T(x, y) = 0$ ."
"In the case where the aperture is a rectangle of width $w$ in the $x$ -direction and height $h$ in the $y$ -direction, show that the value of the transparency function is given by $T(x, y) = \begin{cases} 1, & \text{if } \left| x_S + \frac{x - x_S}{z - z_S} z_S \right| < \frac{w}{2} \text{ and } \left| y_S + \frac{y - y_S}{z - z_S} z_S \right| < \frac{h}{2} \ 0, & \text{otherwise} \end{cases} \quad (3)$ "
maskx = where(absolute(x0) < 0.5*ap_width,1.0,0.0)
masky = where(absolute(y0) < 0.5*ap_height,1.0,0.0)

This exercise provides a fundamental understanding of how light from a point source is affected by an aperture and how the resulting irradiance pattern can be modeled and simulated. The concepts of irradiance, transparency function, and geometric optics are central to this exercise.

Study Guide: Irradiance Due to a Point Source

Key Concepts

Point Source: An idealized source of light that emits uniformly in all directions from a single spatial location.
Irradiance (I): The power per unit area incident on a surface. It quantifies the amount of electromagnetic power received by a surface.
Inverse Square Law: The principle that the intensity of light (or other radial phenomena) from a point source is inversely proportional to the square of the distance from the source.
Aperture: An opening or hole through which light can pass. In this context, it's an opening in an opaque barrier.
Opaque Barrier: A material that does not allow light to pass through it.
Viewing Screen: The surface where the irradiance pattern due to the light source and aperture is observed.
Transparency Function (T(x, y)): A function that describes whether a point (x, y) in the aperture plane allows light to pass through. It is 1 if the light ray passes through the aperture at that point and 0 otherwise.
Source Coordinates (P_s = (x_s, y_s, z_s)): The spatial coordinates of the point source of light.
Screen Coordinates (P = (x, y, z)): The spatial coordinates of a point on the viewing screen.
Aperture Plane (z = 0): The plane where the opaque barrier with the aperture is located.
Screen Plane (z = z_sc): The plane where the viewing screen is located at a distance z_sc from the aperture plane.
Rectangular Aperture (width w, height h): An aperture with a rectangular shape, defined by its width in the x-direction and its height in the y-direction.
Ray Intercepts (x0, y0): The coordinates in the aperture plane where a straight line drawn from the source to a point on the screen intersects the aperture plane.
Masking: The process of selectively allowing or blocking light based on whether the ray intercepts fall within the defined boundaries of the aperture.

Quiz

Describe the setup of the system being modeled. Where are the light source, opaque barrier with an aperture, and viewing screen located relative to each other in the 3D space?
What is irradiance, and what are its units (though not explicitly mentioned, infer based on "power per unit area")? How does the model calculate the irradiance at a point on the viewing screen?
Explain the role of the transparency function T(x, y) in determining the irradiance pattern on the screen. What values can it take and what do these values signify?
How does the model account for the size and shape of the aperture when calculating the irradiance? Specifically, how is a rectangular aperture with width w and height h defined in terms of the transparency function?
Explain the concept of ray intercepts at the aperture plane. How are the x and y coordinates (x0, y0) of these intercepts calculated based on the source and screen coordinates?
What happens to the irradiance at a point on the screen if the straight line from the point source to that screen point does not pass through the aperture? Explain using the transparency function.
Describe how the provided Python code initializes the arrays screen_x and screen_y. What do these arrays represent in the simulation?
Explain the purpose of the rsq array in the Python code. How is it calculated, and why is this quantity important for determining irradiance?
What do the maskx and masky arrays in the Python code represent? How are they used to simulate the effect of the rectangular aperture?
How does the simulation determine whether a point on the screen is illuminated by the point source through the rectangular aperture? Reference the conditions involving x0, y0, ap_width, and ap_height.

Quiz Answer Key

The system consists of a point source of light at coordinates (x_s, y_s, z_s), an opaque barrier with an aperture located at the plane z = 0, and a viewing screen located at the plane z = z_sc. The light source illuminates the aperture, and the light passing through the aperture creates an irradiance pattern on the viewing screen.
Irradiance is the power of electromagnetic radiation per unit area incident on a surface. Its units would be power/area (e.g., Watts per square meter). The model calculates irradiance at a screen point using the formula I(x, y, z) = (A/r^2) * T(x, y), where A is a constant related to the source intensity, r is the distance from the source to the screen point, and T(x, y) is the transparency function.
The transparency function T(x, y) determines if light passing through a specific point (x, y) on the aperture plane reaches the screen. It takes a value of 1 if the ray from the source to the screen point passes through the aperture at (x, y), meaning it's transparent, and 0 if it is blocked by the opaque barrier.
For a rectangular aperture of width w in the x-direction and height h in the y-direction, the transparency function T(x, y) is 1 if the projected coordinates of the screen point back onto the aperture plane fall within the bounds of -w/2 to w/2 in x and -h/2 to h/2 in y. Otherwise, T(x, y) is 0.
Ray intercepts at the aperture plane are the points (x0, y0) where straight lines originating from the point source and passing through points on the viewing screen would intersect the z = 0 plane (the location of the aperture). They are calculated using geometric projection based on the source, screen, and aperture plane z-coordinates and the screen x and y coordinates.
If the straight line from the point source to a point on the screen does not pass through the aperture, the transparency function T(x, y) for the corresponding intercept point on the aperture plane will be 0. According to the irradiance formula, if T(x, y) = 0, then the irradiance I(x, y, z) at that screen point will also be 0, meaning no light reaches that point.
The Python code initializes screen_x and screen_y as two-dimensional arrays filled with zeros, having dimensions (nw+1) x (nh+1). These arrays are later populated with the x and y coordinates of the uniformly spaced points on the viewing screen where the irradiance is to be calculated.
The rsq array in the Python code represents the square of the distance between the point source and each point on the viewing screen. It is calculated using the squared differences in x, y, and z coordinates. This distance is inversely proportional to the irradiance according to the inverse square law component of the irradiance formula.
The maskx array is a 2D array where each element is 1.0 if the absolute value of the x-coordinate of the ray intercept (x0) is less than half the aperture width (0.5*ap_width), and 0.0 otherwise. Similarly, masky does the same check for the y-coordinate of the ray intercept (y0) and half the aperture height (0.5*ap_height). These masks determine if the ray passes through the rectangular aperture in the x and y dimensions, respectively.
The simulation determines that a point on the screen is illuminated if and only if the x-coordinate of the ray intercept at the aperture plane (x0) satisfies absolute(x0) < 0.5*ap_width AND the y-coordinate of the ray intercept (y0) satisfies absolute(y0) < 0.5*ap_height. Both conditions must be true for the light to pass through the rectangular aperture and illuminate the corresponding screen point.

Essay Format Questions

Discuss the relationship between the position of the point source, the dimensions and location of the aperture, and the resulting irradiance pattern observed on the viewing screen. How would changing these parameters affect the pattern's size, shape, and intensity distribution?
Explain the significance of the transparency function in modeling the effect of an aperture on the propagation of light from a point source. How does this function simplify the calculation of irradiance on a screen placed after the aperture?
Describe the process by which the provided JavaScript model (as suggested by the title) or the analogous Python code simulates the irradiance at a screen due to a point source passing through an aperture. Focus on the key steps involved in determining whether a screen point is illuminated and the relative intensity of the light at that point.
Consider the case of different shaped apertures (e.g., circular, triangular). How would the transparency function T(x, y) need to be modified to model these scenarios, and what general principles of light propagation would still apply in determining the irradiance pattern?
Analyze the assumptions made in this model, such as the point source and the straight-line propagation of light. How might the results differ if a more realistic extended light source were used, or if diffraction effects became significant (which are not accounted for here)?

Glossary of Key Terms

Point Source: An idealized light emitter originating from a single infinitesimal location, radiating uniformly in all directions.
Irradiance: The amount of radiant power incident per unit area of a surface, typically measured in Watts per square meter (W/m²).
Aperture: An opening in an otherwise opaque barrier that allows light to pass through.
Opaque: Impenetrable by light; not transparent.
Transparency Function: A mathematical function that describes the transmission of light through a plane (e.g., the aperture plane), where a value of 1 indicates full transmission and 0 indicates blockage.
Source Coordinates: The x, y, and z values that define the spatial location of the light source.
Screen Coordinates: The x, y, and z values that define a specific point on the viewing screen where irradiance is being calculated.
Aperture Plane: The two-dimensional plane (in this case, z = 0) where the aperture is located.
Screen Plane: The two-dimensional plane (in this case, z = z_sc) where the viewing screen is located.
Rectangular Aperture: An aperture with a rectangular shape, defined by its width along one axis (x) and its height along another (y).
Ray Intercept: The point where a straight line tracing the path of light from the source to a point on the screen intersects the plane of the aperture.
Masking: The process of selectively allowing or disallowing something based on defined criteria; in this context, blocking light if the ray intercept falls outside the aperture boundaries.

Version:

Frequently Asked Questions: Irradiance from a Point Source through an Aperture

1. What is irradiance and how is it being considered in this context?

Irradiance, in this context, refers to the power of light per unit area arriving at a point on a viewing screen. The sources describe a scenario where a point source of light illuminates an aperture in an opaque barrier, and we are interested in determining the irradiance of the light that passes through the aperture and appears on a screen located at a certain distance.

2. What are the key components and their spatial relationships in this setup?

The setup involves a point source of light located at coordinates $(x_s, y_s, z_s)$ , an opaque barrier with an aperture situated at the plane $z=0$ , and a viewing screen positioned at $z = z_{sc}$ . The spatial relationships are crucial for determining which light rays from the source pass through the aperture and where they land on the screen.

3. What is the significance of the transparency function $T(x, y)$ ?

The transparency function, $T(x, y)$ , describes whether a point $(x, y)$ in the aperture allows light to pass through. It has a value of 1 if the line from the source to a point on the screen passes through the aperture at coordinates that project to $(x, y)$ on the $z=0$ plane, and 0 otherwise. This function essentially defines the shape and size of the aperture as seen from the perspective of the source and the screen point.

4. How does the irradiance at a point on the screen relate to the transparency function and the distance from the source?

The irradiance $I(x, y, z)$ at a point on the screen is given by the formula $I(x, y, z) = \frac{A}{r^2} T(x, y)$ , where $A$ is a constant related to the source intensity, $r$ is the distance from the source to the point on the screen, and $T(x, y)$ is the transparency function. This equation shows that the irradiance is inversely proportional to the square of the distance from the source and directly proportional to the transparency of the aperture for the path connecting the source and the screen point.

5. How is the transparency function defined for a rectangular aperture of width $w$ and height $h$ ?

For a rectangular aperture centered at the origin in the $z=0$ plane with width $w$ in the x-direction and height $h$ in the y-direction, the transparency function $T(x, y)$ is 1 if the projected coordinates of the ray intercept on the aperture plane, $(x_0, y_0)$ , satisfy $|x_0| < w/2$ and $|y_0| < h/2$ , and 0 otherwise. The provided formula (3) gives the conditions on the screen coordinates $(x, y)$ for which the transparency is 1, considering the source position $(x_s, y_s, z_s)$ and the aperture dimensions.

6. How are the coordinates of the ray intercept at the aperture plane ( $x_0, y_0$ ) calculated for a given source and screen point?

The coordinates of the ray intercept $(x_0, y_0)$ at the aperture plane ( $z=0$ ) are determined by projecting the line segment connecting the source $(x_s, y_s, z_s)$ and a point on the screen $(x, y, z_{sc})$ onto the $z=0$ plane. The provided code snippets show the calculation using similar triangles: $x_0 = rso[0] + abs(zs)(screen_x[i,j] - rso[0])/(zsc - zs)$ and $y_0 = rso[1] + abs(zs)(screen_y[i,j] - rso[1])/(zsc - zs)$. Here, $rso$ represents the source coordinates $(x_s, y_s)$ , $zs$ is $z_s$ , $zsc$ is $z_{sc}$ , and $(screen_x, screen_y)$ are the coordinates on the viewing screen.

7. How can the irradiance be computed for an array of points on the viewing screen?

To compute the irradiance on an array of uniformly spaced points on the viewing screen, one would iterate through each screen point $(x, y)$ at $z = z_{sc}$ . For each point, the corresponding intercept coordinates $(x_0, y_0)$ at the aperture plane ( $z=0$ ) are calculated. Then, it is checked whether these intercept coordinates fall within the dimensions of the aperture (defined by $w$ and $h$ ). If they do, the transparency function $T(x, y)$ is 1; otherwise, it is 0. Finally, the irradiance at the screen point is calculated using the formula $I(x, y, z) = \frac{A}{r^2} T(x, y)$ , where $r$ is the distance between the source and the screen point. The provided Python code outlines this process.

8. What practical steps are involved in simulating and visualizing the irradiance pattern on the screen?

Simulating and visualizing the irradiance pattern involves several steps:

Defining the system parameters: Specifying the position of the point source $(x_s, y_s, z_s)$ , the dimensions and location of the rectangular aperture (width $w$ , height $h$ , at $z=0$ ), and the position and dimensions of the viewing screen ( $z = z_{sc}$ , screen width, screen height, number of points).
Creating a grid of screen points: Generating the coordinates of the points on the viewing screen where the irradiance will be calculated.
Calculating ray intercepts: For each screen point, determining the corresponding coordinates $(x_0, y_0)$ at the aperture plane by projecting the ray from the source to the screen point.
Applying the transparency function: Checking if each calculated $(x_0, y_0)$ falls within the aperture boundaries to determine the value of $T(x, y)$ (1 if inside, 0 if outside).
Calculating the distance and irradiance: Computing the distance $r$ from the source to each screen point and then using the formula $I(x, y, z) = \frac{A}{r^2} T(x, y)$ to find the irradiance at each screen point.
Visualizing the results: Using plotting libraries (like pylab and matplotlib as shown in the code) to create a visual representation of the irradiance distribution on the screen, often as a contour plot or a heatmap, where the intensity of color or the height of contours represents the irradiance value.

1 1 1 1 1 1 1 1 1 1 Rating 0.00 (0 Votes)

Details: Written by Loo Kang Wee; Parent Category: 03 Waves; Category: 04 Light; Published: 15 April 2016; Created: 15 April 2016; Last Updated: 22 March 2025; Hits: 6423