Submitted To:

SIR ASIM BUTT

REPORT
Parallel Distribution and Computing

Group Members:
Hassan Riaz (F2021266408)

Baseerat Ghazanfar (F2021266166)

Syeda Nimra Zamir (F2021266415)

Abdullah Bin Nauman (F2021266426)

Section
V6
Code:

#include <iostream>
#include <cmath>
#include <vector>
#include <iomanip>

using namespace std;

const double alpha = 0.01;

const double pi = 3.141592653589793;

void initialize(vector<double>& T, int N, double rodLength, double dx) {

for (int i = 0; i <= N; ++i) {
double x = i * dx;
T[i] = 100.0 * sin(pi * x / rodLength);
}
}

void updateTemperature(vector<double>& T, vector<double>& T_new, int N,

double T0, double dt, double dx) {
for (int i = 1; i < N; ++i) {
T_new[i] = T[i] + alpha * dt / (dx * dx) * (T[i - 1] - 2 * T[i] + T[i + 1]);
}
T_new[0] = T0;
T_new[N] = T0;
}

void calculateTemperature() {
double rodLength, queryTime, queryPoint;
const double T0 = 0.0;
const double dx = 0.01;
const double dt = 0.0001;

cout << "Enter rod length (in meters): ";

cin >> rodLength;
cout << "Enter query time (in seconds): ";
cin >> queryTime;
cout << "Enter point to query temperature (in meters): ";
cin >> queryPoint;

if (queryPoint < 0 || queryPoint > rodLength) {

cout << "Invalid point. Please enter a value between 0 and " << rodLength << "
meters.\n";
return;
}

int N = static_cast<int>(rodLength / dx);

vector<double> T(N + 1, T0);
vector<double> T_new(N + 1, T0);
 initialize(T, N, rodLength, dx);

int steps = static_cast<int>(queryTime / dt);

for (int step = 0; step < steps; ++step) {
updateTemperature(T, T_new, N, T0, dt, dx);
T.swap(T_new);
}

int pointIndex = static_cast<int>(queryPoint / dx);

cout << "Temperature at x = " << queryPoint << " m and t = " << queryTime << "
s is: ";
cout << fixed << setprecision(2) << T[pointIndex] << " °C\n";
}

int main() {
int choice;

do {
cout << "\n=== Temperature Simulation Menu ===\n";
cout << "1. Calculate Temperature at a Specific Point and Time\n";
cout << "2. Exit\n";
cout << "Enter your choice: ";
cin >> choice;

switch (choice) {
case 1:
calculateTemperature();
break;
case 2:
cout << "Exiting the program. Goodbye!\n";
break;
default:
cout << "Invalid choice. Please try again.\n";
}
} while (choice != 2);

return 0;
}
History and Background of the Code
The given code numerically solves the one-dimensional heat equation using the explicit finite
difference method (FDM). It is rooted in the principles of heat conduction, one of the earliest and
most studied phenomena in thermodynamics and mathematical physics. Below is the historical and
theoretical context of the code and the techniques it employs:

1. Historical Background of Heat Conduction

Fourier's Pioneering Work (1822)
• The heat equation was first introduced by Joseph Fourier in his book Théorie Analytique de
la Chaleur (The Analytical Theory of Heat) in 1822.
• Fourier proposed that heat diffuses through a medium in a manner proportional to the spatial
gradient of temperature, formalized as:

Emergence of Numerical Methods

• While Fourier's work laid the foundation for analytical solutions to the heat equation, many
real-world problems—such as non-linear boundary conditions or irregular geometries—
required numerical approaches.
• Finite Difference Methods (FDM) emerged in the mid-20th century as an effective way to
approximate solutions for partial differential equations (PDEs) like the heat equation.
Finite Difference Revolution (1940s-1950s)
• The development of digital computers during the 1940s accelerated research into numerical
methods.
• John von Neumann and others in the 1940s analyzed stability criteria for explicit finite
difference schemes.
• The Crank-Nicolson method (1947) was introduced as a stable and accurate alternative to
explicit FDMs.

2. Conceptual Foundations of the Code

Heat Equation
• The code solves the one-dimensional heat equation:

This equation describes how temperature evolves in a rod over time due to heat conduction.
---------------------------------------------------------------------------------------------------------------------------
3. Computational Advancements and Real-World Applications
Numerical Heat Transfer
• Numerical methods like the FDM became integral in fields such as:
o Engineering: Designing heat exchangers, insulation materials, and cooling systems.
o Geophysics: Modeling heat flow in the Earth's crust.
o Medical Physics: Simulating heat diffusion in biological tissues during thermal
therapies.
Modern Applications
• The simulation of temperature distribution is critical in fields like:
o Aerospace: Managing thermal stresses in spacecraft during reentry.
 o Electronics: Ensuring effective heat dissipation in microprocessors.
o Material Science: Analyzing thermal properties of new materials.

4. Educational Relevance of the Code

This code provides a practical introduction to:
1. Numerical Simulation of PDEs: The finite difference approximation is widely used to solve
various PDEs, making this code a useful educational tool.
2. Boundary Value Problems (BVPs): It teaches how to handle BVPs numerically and interpret
the results.
3. Algorithmic Thinking: Implementing and understanding the explicit FDM fosters
computational problem-solving skills.

Summary of the Historical Context

The code is a modern implementation of principles and methods that have been developed over two
centuries:
• Fourier's analytical work laid the groundwork for understanding heat conduction.
• Advances in numerical methods and computing technology enabled practical solutions to
complex heat transfer problems.
• The explicit FDM used here reflects early yet fundamental computational approaches to
solving the heat equation.
This code is a bridge between theoretical physics, numerical mathematics, and computational
applications, embodying the evolution of problem-solving in science and engineering
Literature Review
The code provided represents a numerical solution to the one-dimensional heat conduction equation
using the explicit finite difference method (FDM). Below is a detailed literature review of the
theoretical and practical context of the techniques and concepts used.

1. Heat Conduction and the Heat Equation

Origins
The heat equation is a fundamental partial differential equation (PDE) in physics and mathematics,
first introduced by Joseph Fourier in 1822 in his seminal work Théorie analytique de la chaleur. The
one-dimensional heat equation is expressed as:

Applications
The heat equation is pivotal in:
• Thermodynamics and heat transfer,
• Geophysics for modeling geothermal gradients,
• Biomedical applications like tissue heating during medical treatments,
• Engineering for analyzing heat in devices and systems.

2. Numerical Methods for Solving PDEs

Why Numerical Solutions?
The heat equation often lacks closed-form solutions for complex geometries or boundary conditions.
Numerical techniques approximate solutions using computational methods. Prominent techniques
include:
1. Finite Difference Method (FDM): Discretizes both time and space to solve PDEs.
2. Finite Element Method (FEM): Used for irregular domains and heterogeneous materials.
3. Spectral Methods: Employ global basis functions for high accuracy.
3. Literature on Numerical Heat Conduction
Historical Context
1. Fourier (1822): Introduced the analytical formulation of the heat equation.
2. Von Neumann (1947): Studied the stability of numerical methods for PDEs, including the
explicit FDM.
3. Crank and Nicolson (1947): Developed a semi-implicit FDM for improved accuracy and
stability.
Research and Applications
1. FDM in Heat Transfer:
o Widely adopted for thermal simulations in engineering (e.g., heat exchangers,
building insulation).
o Used for designing thermal control systems in aerospace and automotive industries.
2. Boundary and Initial Conditions:
o Research explores how different boundary conditions (e.g., Neumann, Dirichlet)
affect numerical solutions.
 o The code assumes Dirichlet boundary conditions with fixed temperatures at the rod
ends.
3. Material Properties and Heterogeneity:
o Extensions to include variable thermal properties (e.g., α(x)\alpha(x)α(x)) for
modeling composites or multi-layered materials.
4. Computational Efficiency:
o Efforts focus on optimizing explicit methods or transitioning to implicit schemes to
overcome stability constraints.

Modern Extensions and Alternatives

Implicit Methods
The implicit FDM is unconditionally stable, meaning it does not impose restrictions on Δt\Delta tΔt.
However, it requires solving a system of linear equations at each time step, increasing computational
complexity.
Finite Element Method (FEM)
• Allows modeling complex geometries and non-uniform materials.
• Suitable for multidimensional problems where the explicit FDM struggles.
Crank-Nicolson Scheme
• A semi-implicit method combining the stability of implicit methods with the simplicity of
explicit methods.
• Provides second-order accuracy in both time and space.
Spectral Methods
• Employ global functions (e.g., Fourier series, Chebyshev polynomials) for approximations.
• High accuracy for smooth problems but less effective for discontinuities.
Machine Learning and Data-Driven Models
• Neural networks approximate the solution of the heat equation by learning the underlying
physics.
• Useful for real-time simulations or complex, multi-physics scenarios.

Practical Considerations in the Code

Strengths
• Educational Tool: Introduces students to numerical simulation of heat transfer.
• Ease of Use: The menu-based interface allows user-defined parameters for customization.
• Computational Simplicity: The explicit FDM is straightforward to implement and interpret.
Limitations
 • Stability Constraints: Requires small Δt\Delta tΔt, leading to higher computational time.
• Boundary Conditions: Limited to fixed temperatures at the rod ends.
• Scalability: May not handle larger or more complex problems efficiently.

Future Directions
1. Optimization:
o Use adaptive time-stepping to maintain stability while improving efficiency.
o Parallelize the algorithm for faster simulations on large grids.
2. Modeling Real-World Scenarios:
o Include variable thermal diffusivity or heat sources.
o Extend to two or three dimensions for more realistic applications.
3. Integration with Machine Learning:
o Combine numerical methods with ML to predict temperature distributions under
uncertain parameters.
4. Advanced Numerical Techniques:
o Transition to implicit or Crank-Nicolson methods for improved stability and accuracy.
o Incorporate FEM for irregular geometries or heterogeneous materials.

Conclusion
The code is a straightforward implementation of the explicit FDM for solving the one-dimensional
heat equation. While limited by its simplicity and stability constraints, it serves as a foundation for
understanding numerical heat transfer methods. The extensive body of literature on numerical
methods, ranging from FDM to FEM and spectral techniques, highlights the evolution and
applications of heat conduction modeling across diverse fields.