Step 1: Calculate the un-directional minimum distances

Definition: the un-directional minimum distance between any two reference sites is the minimum distance consists of a number of links connecting these two reference sites, regardless of their directions.
Notation: umd_{rs_i-rs_j} - un-directional minimum distance between reference site rs_i and reference site rs_j
Method: Dijkstra minimum distance algorithm.

Step 2: Determine a given reference site's relative position

Given a link of interests [F-T], the table below shows all possible positions that a random reference site rs_i can be relative to link [F-T]:

Relative Position	Explanation	Conditions
Upstream	`--(rs_i)------------------------- ----------(F)=====>(T)----------`	umd_{rs_i-F} < umd_{rs_i-T} AND length(F-T) < umd_{rs_i-T}
Overlap F	`----------(F/rs_i)--------------- ----------(F/rs_i)===>(T)--------`	umd_{rs_i-F} = 0
In Between	`--------------(rs_i)------------- ----------(F)=====>(T)----------`	umd_{rs_i-F} + umd_{rs_i-T} <= length(F-T)
Overlap T	`-----------------(T/rs_i)-------- ----------(F)===>(T/rs_i)--------`	umd_{rs_i-T} = 0
Downstream	`------------------------(rs_i)--- ----------(F)=====>(T)----------`	umd_{rs_i-F} > umd_{rs_i-T} AND length(F-T) < umd_{rs_i-F}

Step 3: Determine a given link's relative position

Given another link [F_i-T_i], its position can be of the following 25 cases relative to link [F-T]:

		F_i's relative position to link [F-T]
		Upstream	Overlap F	In Between	Overlap T	Downstream
T_i's relative position to link [F-T]	Upstream	Case1	Case2	Case3	Case4	Case5
	Overlap F	Case6	Case7	Case8	Case9	Case10
	In Between	Case11	Case12	Case13	Case14	Case15
	Overlap T	Case16	Case17	Case18	Case19	Case20
	Downstream	Case21	Case22	Case23	Case24	Case25

Step 4: Determine the direction and the distance between two crashes

When calculating the distance from a current primary crash crash_cur (occurred on link [F-T]) to a potential secondary crash crash_i (occurred on link [F_i-T_i]), the following equation is used:
d = sign₁*(sign₂*umd_{F_i-F} - offset_{crash_cur}) + offset_{crash_i}.
where,
umd_{F_i-F}, offset_{crash_i}, and offset_{crash_cur} are all non-negative distances. When d > 0, crash_i is downstream of crash_cur in either direction; when d < 0, crash_i is upstream of crash_cur in either direction. When link [F_i-T_i], is in the same direction to link [F-T], sign₁ = 1, otherwise sign₁ = -1. When F_i is upstream of link [F-T], sign₂ = -1; when F_i overlaps with F, sign₂ = 0; otherwise, sign₂ = 1. Below is a summary matrix:

		F_i's relative position to link [F-T]
		Upstream	Overlap F	In Between	Overlap T	Downstream
T_i's relative position to link [F-T]	Upstream	Case1 if umd_{F_i-F} > umd_{T_i-F}, sign₁ = 1, if umd_{F_i-F} < umd_{T_i-F}, sign₁ = -1; sign₂ = -1	Case2 sign₁ = -1; sign₂ = 0;	Case3 sign₁ = -1; sign₂ = 1;	Case4 sign₁ = -1; sign₂ = 1;	Case5 sign₁ = -1; sign₂ = 1;
	Overlap F	Case6 sign₁ = 1; sign₂ = -1;	Case7 not exist	Case8 sign₁ = -1; sign₂ = 1;	Case9 sign₁ = -1; sign₂ = 1;	Case10 sign₁ = -1; sign₂ = 1;
	In Between	Case11 sign₁ = 1; sign₂ = -1;	Case12 sign₁ = 1; sign₂ = 0;	Case13 if umd_{F_i-F} < umd_{T_i-F}, sign₁ = 1, if umd_{F_i-F} > umd_{T_i-F}, sign₁ = -1; sign₂ = 1	Case14 sign₁ = -1; sign₂ = 1;	Case15 sign₁ = -1; sign₂ = 1;
	Overlap T	Case16 sign₁ = 1; sign₂ = -1;	Case17 sign₁ = 1; sign₂ = 0;	Case18 sign₁ = 1; sign₂ = 1;	Case19 not exist	Case20 sign₁ = -1; sign₂ = 1;
	Downstream	Case21 sign₁ = 1; sign₂ = -1;	Case22 sign₁ = 1; sign₂ = 0;	Case23 sign₁ = 1; sign₂ = 1;	Case24 sign₁ = 1; sign₂ = 1;	Case25 if umd_{F_i-F} < umd_{T_i-F}, sign₁ = 1, if umd_{F_i-F} > umd_{T_i-F}, sign₁ = -1; sign₂ = 1

Appendix A: Enumeration of All Cases

Case1(table)

--->(F_i)=>(T_i)------->(F)=>(T)--->:
This case is true when umd_{F_i-F} > umd_{T_i-F}. In this case, link [F_i-T_i] is upstream of link [F-T] and in the same direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = -umd_{F_i-F} + offset_{crash_cur} - offset_{crash_cur}.
<---(T_i)<=(F_i)<-------------------- --------------------->(F)=>(T)--->:
This case is true when umd_{F_i-F} < umd_{T_i-F}. In this case, link [F_i-T_i] is upstream of link [F-T] and in the opposite direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = (-1)*(-umd_{F_i-F} - offset_{crash_i} - offset_{crash_cur}).

Case2(table)

<---(T_i)<===(F/F_i)<---------------- ----------->(F/F_i)=>(T)----------->:
In this case, link [F_i-T_i] is upstream of link [F-T] and in the opposite direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = (-1)*(-offset_{crash_i} - offset_{crash_cur}).

Case3(table)

<--(T_i)<==========(F_i)<------------ ------------>(F)======>(T)------->:
In this case, link [F_i-T_i] is overlapped with link [F-T] and in the opposite direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = (-1)*(umd_{F_i-F} - offset_{crash_i} - offset_{crash_cur}).

Case4(table)

<---(T_i)<===============(T/F_i)<--- ---------------->(F)===>(T/F_i)--->:
In this case, link [F_i-T_i] is containing link [F-T] and in the opposite direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = (-1)*(umd_{F_i-F} - offset_{crash_i} - offset_{crash_cur}).

Case5(table)

<---(T_i)<=================(F_i)<--- ----------->(F)===>(T)----------->:
In this case, link [F_i-T_i] is containing link [F-T] and in the opposite direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = (-1)*(umd_{F_i-F} - offset_{crash_i} - offset_{crash_cur}).

Case6(table)

------------->(F_i)=>(F/T_i)=>(T)--->:
In this case, link [F_i-T_i] is upstream of link [F-T] and in the same direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = -umd_{F_i-F} + offset_{crash_i} - offset_{crash_cur}.

Case7(table)

Such case doen't exist since F_i and T_i overlap.

Case8(table)

<---(F/T_i)<====(F_i)<--------------- --->(F/T_i)==============>(T)------>:
In this case, link [F_i-T_i] is contained by link [F-T] and in the opposite direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = (-1)*(umd_{F_i-F} - offset_{crash_i} - offset_{crash_cur}).

Case9(table)

<---(F/T_i)<========(T/F_i)<--------- --->(F/T_i)========>(T/F_i)--------->:
In this case, link [F_i-T_i] is paired link of link [F-T] and in the opposite direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = (-1)*(umd_{F_i-F} - offset_{crash_i} - offset_{crash_cur}).

Case10(table)

<---(F/T_i)<=========(F_i)<---------- --->(F/T_i)=====>(T)--------------->:
In this case, link [F_i-T_i] is containing link [F-T] and in the opposite direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = (-1)*(umd_{F_i-F} - offset_{crash_i} - offset_{crash_cur}).

Case11(table)

--->(F_i)==========>(T_i)-----------> -------------->(F)=======>(T)----->:
In this case, link [F_i-T_i] is overlapped with link [F-T] and in the same direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = -umd_{F_i-F} + offset_{crash_i} - offset_{crash_cur}.

Case12(table)

--->(F/F_i)====>(T_i)---------------> --->(F/F_i)=========>(T)----------->:
In this case, link [F_i-T_i] is contained by link [F-T] and in the same direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = offset_{crash_i} - offset_{crash_cur}.

Case13(table)

----------->(F_i)==>(T_i)-----------> --->(F)=================>(T)------>:
This case is true when umd_{F_i-F} < umd_{T_i-F}. In this case, link [F_i-T_i] is contained by link [F-T] and in the same direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = umd_{F_i-F} + offset_{crash_i} - offset_{crash_cur}.
<-----------(T_i)<==(F_i)<----------- --->(F)=================>(T)------>:
This case is true when umd_{F_i-F} > umd_{T_i-F}. In this case, link [F_i-T_i] is contained by link [F-T] and in the opposite direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = (-1)*(umd_{F_i-F} - offset_{crash_i} - offset_{crash_cur}).

Case14(table)

<-------(T_i)<=====(T/F_i)<---------- --->(F)==========>(T/F_i)---------->:
In this case, link [F_i-T_i] is contained by link [F-T] and in the opposite direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = (-1)*(umd_{F_i-F} - offset_{crash_i} - offset_{crash_cur}).

Case15(table)

<-------(T_i)<=======(F_i)<---------- --->(F)======>(T)----------------->:
In this case, link [F_i-T_i] is overlapped with link [F-T] and in the opposite direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = (-1)*(umd_{F_i-F} - offset_{crash_i} - offset_{crash_cur}).

Case16(table)

--->(F_i)================>(T/T_i)---> ---------------->(F)====>(T/T_i)--->:
In this case, link [F_i-T_i] is containing link [F-T] and in the same direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = -umd_{F_i-F} + offset_{crash_i} - offset_{crash_cur}.

Case17(table)

--->(F/F_i)========>(T/T_i)---------> --->(F/F_i)========>(T/T_i)--------->:
In this case, link [F_i-T_i] is matching link [F-T] and in the same direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = offset_{crash_i} - offset_{crash_cur}.

Case18(table)

------------>(F_i)====>(T/T_i)------> --->(F)==============>(T/T_i)------>:
In this case, link [F_i-T_i] is contained by link [F-T] and in the same direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = umd_{F_i-F} + offset_{crash_i} - offset_{crash_cur}.

Case19(table)

Such case doen't exist since F_i and T_i overlap.

Case20(table)

<-------------(T/T_i)<===(F_i)<------ --->(F)======>(T/T_i)-------------->:
In this case, link [F_i-T_i] is downstream of link [F-T] and in the opposite direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = (-1)*(umd_{F_i-F} - offset_{crash_i} - offset_{crash_cur}).

Case21(table)

--->(F_i)==============>(T_i)-------> ---------->(F)===>(T)------------->:
In this case, link [F_i-T_i] is containing link [F-T] and in the same direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = -umd_{F_i-F} + offset_{crash_i} - offset_{crash_cur}.

Case22(table)

--->(F/F_i)============>(T_i)-------> --->(F/F_i)======>(T)-------------->:
In this case, link [F_i-T_i] is containing link [F-T] and in the same direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = offset_{crash_i} - offset_{crash_cur}.

Case23(table)

--------->(F_i)======>(T_i)---------> --->(F)=======>(T)---------------->:
In this case, link [F_i-T_i] is overlapped with link [F-T] and in the same direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = umd_{F_i-F} + offset_{crash_i} - offset_{crash_cur}.

Case24(table)

------------->(T/F_i)==>(T_i)-------> --->(F)======>(T/F_i)-------------->:
In this case, link [F_i-T_i] is downstream of link [F-T] and in the same direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = umd_{F_i-F} + offset_{crash_i} - offset_{crash_cur}.

Case25(table)

-------------------->(F_i)=>(T_i)---> --->(F)=>(T)---------------------->:
This case is true when umd_{F_i-F} < umd_{T_i-F}. In this case, link [F_i-T_i] is downstream of link [F-T] and in the same direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = umd_{F_i-F} + offset_{crash_i} - offset_{crash_cur}.
<----------------(T_i)<=(F_i)<------- --->(F)=>(T)---------------------->:
This case is true when umd_{F_i-F} > umd_{T_i-F}. In this case, link [F_i-T_i] is downstream of link [F-T] and in the opposite direction.
The distance from crash_cur on [F-T] to crash_i on [F_i-T_i] can be calculated as d = (-1)*(umd_{F_i-F} - offset_{crash_i} - offset_{crash_cur}).