Write a program called ‘vectormath.py’ to do basic vector calculations in 3 dimensions:

addition, dot product and normalization.

To write a program called 'vectormath.py' that performs basic vector calculations in 3 dimensions, including vector addition, dot product, and normalization, you can follow these steps:

1. Create a new Python file named 'vectormath.py' and open it using a text editor or an integrated development environment (IDE).

2. Define a class called 'Vector3D' to represent a 3D vector. Your class should have the following methods:

- A constructor method '__init__' to initialize the vector components (x, y, and z values) when an instance of the class is created.
- A method 'add' to perform vector addition. This method should take another Vector3D object as a parameter and return a new Vector3D object representing the sum of the two vectors.
- A method 'dot_product' to calculate the dot product of two 3D vectors. This method should also take another Vector3D object as a parameter and return a scalar value representing the dot product.
- A method 'normalize' to normalize the vector. This method should return a new Vector3D object representing the normalized vector.

Here's an example implementation of the program:

```python
import math

class Vector3D:
def __init__(self, x, y, z):
self.x = x
self.y = y
self.z = z

def add(self, other_vector):
new_x = self.x + other_vector.x
new_y = self.y + other_vector.y
new_z = self.z + other_vector.z
return Vector3D(new_x, new_y, new_z)

def dot_product(self, other_vector):
dot = self.x * other_vector.x + self.y * other_vector.y + self.z * other_vector.z
return dot

def normalize(self):
magnitude = math.sqrt(self.x ** 2 + self.y ** 2 + self.z ** 2)
normalized_x = self.x / magnitude
normalized_y = self.y / magnitude
normalized_z = self.z / magnitude
return Vector3D(normalized_x, normalized_y, normalized_z)

# Example usage
vector1 = Vector3D(1, 2, 3)
vector2 = Vector3D(4, 5, 6)

vector_sum = vector1.add(vector2)
dot_product = vector1.dot_product(vector2)
normalized_vector = vector1.normalize()

print("Vector Sum:", vector_sum.x, vector_sum.y, vector_sum.z)
print("Dot Product:", dot_product)
print("Normalized Vector:", normalized_vector.x, normalized_vector.y, normalized_vector.z)
```

In this example, we have defined a Vector3D class with methods for addition, dot product calculation, and normalization. You can use this class to perform basic vector calculations in 3 dimensions by creating Vector3D objects and calling the respective methods as shown in the example usage above.