Here's how you might construct a process tree object representing the Purchase-to-Pay process using the PM4Py library:

Firstly ensure that the `pm4py` package is installed (`pip install pm4py`). If not installed use pip command accordingly.

```python
    
from pm4py.objects.process_tree.obj import ProcessTree, Operator
   
# Initialize root process tree node
root = ProcessTree(parent=None)
    
# Purchase process operations:
purchase_request = ProcessTree(label="PurchaseRequest", parent=root)

# Validate request activity with no concurrent activity:
validate_request = ProcessTree(operator=Operator.PARALLEL, children=[purchase_request])
 
# Get supplier information activity followed by purchase order creation concurrently:
get_supplier_info = ProcessTree(parent=root)
create_purchase_order = ProcessTree(parent=get_supplier_info)

# Concurrently validate the order and check for stock availability:
validate_order = ProcessTree(label="ValidateOrder", parent=validate_request)
check_stock_availability = ProcessTree(label="CheckStockAvailability", parent=validate_request)


# Create a loop structure
process_tree = ProcessTree()

# Define loop execution flow structure:

while (True):
    # Purchase order creation logic follows sequentially
   
   purchase_order_creation = ProcessTree()
   process_tree.children.append(purchase_order_creation)
   
   # Then check stock availability and if in stock then create invoice
   create_invoice = ProcessTree()
   process_tree.children.append(create_invoice)
   
# In the loop exists when an exception is caught
   
try:
    # Some other process here (invoice payment)
except Exception:
    # Handle error case
   
# This will be the final process tree after exception handling
process_tree_final = process_tree

# Here's how you might use it:

from pm4py.objects.process_tree.obj import plot

# Extract traces using this process tree object 
traces = algo.apply(tree=process_tree)
for trace in traces:
    print("Trace", trace)

plot(tree=tree)
    
```

Please replace the dummy strings "PurchaseRequest", "ValidateOrder", "CheckStockAvailability", "invoice payment" with actual process steps. 

This code might not execute properly standalone due to missing dependencies (`pm4py` package need installation), import errors (`ProcessTree`, `Operator` classes might exist in different location or packages). You should have the correct PM4Py package installed.

Please replace the operators as per your own model, for example, if "X" means XOR then replace it appropriately:

```python
# Example with XOR operator
validate_order = ProcessTree(operator=Operator.X, children=[validate_request])
```

Remember to replace the 'operator' attribute values (`Operator.SEQUENCE`, `Operator.PARALLEL`, `Operator.XOR` etc.) accordingly based on how your process tree is structured.

The above code constructs a very basic skeleton process tree structure following the description provided previously about Purchase-to-Pay process hierarchy and concurrency scenarios.