public GlobalLinearization getBestGlobalLinearizationAndEnergy(out long minimalEnergy)
{
GlobalLinearization bestLinearization = null;
minimalEnergy = (long)0x7FFFFFFFFFFFFFFF;
getBestGlobalLinearizationAndEnergyRecursive(rootRewriteTreeElement, ref minimalEnergy, ref bestLinearization);
Ensure.ensureHard(bestLinearization != null);
return(bestLinearization);
}
private long calculateEnergy(GlobalLinearization linearization, CausalSetSystemBlock root)
{
IDictionary <uint, uint> indexInLinearizationByIndex = new Dictionary <uint, uint>();
for (uint i = 0; i < linearization.linearization.Count; i++)
{
uint nodeIndex = linearization.linearization[(int)i];
Ensure.ensureHard(!indexInLinearizationByIndex.ContainsKey(nodeIndex));
indexInLinearizationByIndex[nodeIndex] = i;
}
long energy = 0;
for (uint indexInLinearization = 0; indexInLinearization < linearization.linearization.Count; indexInLinearization++)
{
uint nodeIndex = linearization.linearization[(int)indexInLinearization];
foreach (CausalIndirectionIndex nextNodeIndicesFromCurrentNode in unmodifiedRootSystemBlock.nodes[(int)nodeIndex].next)
{
uint nextNodeIndexFromCurrentNode = root.translateIndirectIndexToIndex(nextNodeIndicesFromCurrentNode);
// translate the index of the next node which follows the current node to the index in the linearization
uint indexInLinearizationOfNextNode = indexInLinearizationByIndex[nextNodeIndexFromCurrentNode];
// calculate energy from current node to next node based on linearization
Debug.Assert(indexInLinearizationOfNextNode >= 0);
int energyFromCurrentNodeToNextNode = (int)indexInLinearizationOfNextNode - (int)indexInLinearization;
// must be greater than zero else we have some really nasty bug in the code
Ensure.ensureHard(energyFromCurrentNodeToNextNode > 0);
energy += energyFromCurrentNodeToNextNode;
}
}
return(energy);
}
private void getBestGlobalLinearizationAndEnergyRecursive(RewriteTreeElement entry, ref long minimalEnergy, ref GlobalLinearization linearization)
{
if (entry != rootRewriteTreeElement)
{
Ensure.ensureHard(entry.globalLinearized != null);
if (entry.globalEnergyAfterRewrite < minimalEnergy)
{
minimalEnergy = entry.globalEnergyAfterRewrite;
linearization = entry.globalLinearized;
}
}
foreach (RewriteTreeElement iterationChildren in entry.childrenRewrites)
{
getBestGlobalLinearizationAndEnergyRecursive(iterationChildren, ref minimalEnergy, ref linearization);
}
}
