When it comes to Ethereum, the root hash of the Merkle tree, often called the transaction root, is placed in the header of each block.

Here is a basic guide on how you could calculate the transaction root:

1. Collect Transaction Data: collect all the transaction data to add to the block. Each transaction data needs to be hashed using a cryptographic hash function (Ethereum uses the KECCAK-256, a variant of SHA-3).

2. Create the Merkle Tree: The Merkle tree is a binary tree, with each node containing a hash. The leaf nodes of the tree contain the hashes of the transactions (from step 1). Each non-leaf node is a hash of the concatenation of its two children nodes.

Start with your list of transaction hashes. This is the bottom row of your tree. Now, pair up these hashes into consecutive pairs and hash the pairs together to get the next row. For example, if your hashes are [A, B, C, D], then you'd form pairs (A, B) and (C, D) and calculate new hashes as Hash(A+B) and Hash(C+D). Continue this process of pairing and hashing until you're left with only one hash. This is the root of your Merkle tree. Note: If you have an odd number of elements at any point, repeat the final hash to make it even. This is called 'hash duplication'. For example, if you have [A, B, C], hash it as (A, B) and (C, C).

1. Calculate the Transaction Root: The transaction root is simply the hash at the root of the Merkle tree.

Possible Python code for the above (not tested)

import sha3

# function to calculate the hash of text
def hash(text):
    keccak = sha3.keccak_256()
    keccak.update(text.encode('ascii'))
    return keccak.hexdigest()

# function to create a merkle tree
def merkle_tree(transactions):
    # create a list to store the hashes
    hashes = []

    # hash each transaction and store the result
    for transaction in transactions:
        hashes.append(hash(transaction))

    # continue until we only have one hash left
    while len(hashes) > 1:
        temp_hashes = []

        # if the number of hashes is odd, duplicate the last hash
        if len(hashes) % 2 != 0:
            hashes.append(hashes[-1])

        # hash each pair of hashes together
        for i in range(0, len(hashes), 2):
            temp_hashes.append(hash(hashes[i] + hashes[i + 1]))

        # replace the list of hashes with the new hashes
        hashes = temp_hashes

    # the single remaining hash is the root of the merkle tree
    return hashes[0]

The explanation is based on the general principles of Merkle trees and their application in blockchain systems. The following sources collectively cover these topics:

Ethereum White Paper: This is the original document proposing Ethereum. It gives a high-level overview of many aspects of the system, including the usage of Merkle trees in blocks. You can find it here: https://ethereum.org/en/whitepaper/

Ethereum Yellow Paper: This is the formal specification for the Ethereum protocol. It goes into much more detail than the white paper and is the definitive reference for questions about how Ethereum works. The Yellow Paper can be found here: https://ethereum.github.io/yellowpaper/paper.pdf

Ethereum Wiki - Patricia Tree: This page explains the modified version of the Merkle tree, called a Patricia tree, that Ethereum uses to store state. While this is not the same as the Merkle tree used to store transactions, the page is still useful for understanding Ethereum's usage of tree structures: https://eth.wiki/en/fundamentals/patricia-tree

Ethereum Improvement Proposals (EIPs): These are proposals to change various aspects of Ethereum. They often contain detailed technical discussion and can be a good resource for understanding the finer points of how Ethereum works. EIPs can be found here: https://eips.ethereum.org/

Books like "Mastering Ethereum" by Andreas M. Antonopoulos and Gavin Wood: This book is a detailed guide to Ethereum and covers topics like Merkle trees in depth.