private static void MergeNamespaces(ElementEnvironment target, ElementEnvironment source)
{
const string namespaceQuery = "results/test-suite[@type=\"Namespace\"]";
MergeFixtures(target, source);
var destinationChildNamespaces = target.NamespaceElement.XPathSelectElements(namespaceQuery);
foreach (var namespaceElement in source.NamespaceElement.XPathSelectElements(namespaceQuery))
{
var existingNamespace =
destinationChildNamespaces.FirstOrDefault(
x => x.Attribute("name").Value == namespaceElement.Attribute("name").Value);
if (existingNamespace == null)
{
target.NamespaceElement
.XPathSelectElement("results")
.Add(namespaceElement);
}
else
{
MergeNamespaces(new ElementEnvironment(existingNamespace, target.Environment), new ElementEnvironment(namespaceElement, source.Environment));
}
}
}
private static void MergeFixtures(ElementEnvironment target, ElementEnvironment source)
{
const string fixtureQuery = "results/test-suite[@type=\"TestFixture\"]";
var destinationFixtureElements = target.NamespaceElement.XPathSelectElements(fixtureQuery);
foreach (var fixtureElement in source.NamespaceElement.XPathSelectElements(fixtureQuery))
{
// for fixtures that exist in one but not the other, add them to destinationNamespace
var existingFixture =
destinationFixtureElements.FirstOrDefault(
x => x.Attribute("name").Value == fixtureElement.Attribute("name").Value);
if (existingFixture == null)
{
target.NamespaceElement
.XPathSelectElement("results")
.Add(fixtureElement);
}
else
{
existingFixture
.XPathSelectElement("results")
.Add(fixtureElement.XPathSelectElements("results/test-case"));
}
}
}
public void GetDefaults()
{
if (!parent.graph.amberEnvironment.elementEnvironments.ContainsKey(element))
{
Debug.LogErrorFormat("Element {0} not present in Element Environments", element);
return;
}
ElementEnvironment defaultEnvironment = parent.graph.amberEnvironment.elementEnvironments [element];
valency = 0.0;
maxValency = defaultEnvironment.maxValency;
color = defaultEnvironment.color;
vdwRadius = defaultEnvironment.radius;
}
public void GetEnvironmentFromXML()
{
elementEnvironments = new Dictionary <string, ElementEnvironment> ();
XDocument envX = FileIO.ReadXML("Assets/Resources/Data/Elements.xml");
XElement atomsX = envX.Element("elements");
foreach (XElement atomEl in atomsX.Elements("atom"))
{
ElementEnvironment elementEnvironment = new ElementEnvironment();
elementEnvironment.element = atomEl.Attribute("element").Value;
elementEnvironment.radius = float.Parse(atomEl.Element("radius").Value);
elementEnvironment.maxValency = double.Parse(atomEl.Element("maxValency").Value);
elementEnvironment.mass = float.Parse(atomEl.Element("mass").Value);
float r = float.Parse(atomEl.Element("red").Value);
float g = float.Parse(atomEl.Element("green").Value);
float b = float.Parse(atomEl.Element("blue").Value);
elementEnvironment.color = new Color(r, g, b);
foreach (XElement stateEl in atomEl.Elements("state"))
{
elementEnvironment.atomStateDict[stateEl.Attribute("name").Value] = AtomStateFromXmlElement(stateEl);
}
foreach (XElement environmentEl in atomEl.Elements("environment"))
{
AtomEnvironment atomEnvironment = AtomEnvironmentFromXmlElement(environmentEl, elementEnvironment.atomStateDict);
elementEnvironment.environmentDict[atomEnvironment.name] = atomEnvironment;
}
elementEnvironments [elementEnvironment.element] = elementEnvironment;
}
}
public static void Execute(string destPath, params TestRunResult[] results)
{
if (string.IsNullOrWhiteSpace(destPath))
{
destPath = "./TestResults.xml";
}
var destFolder = Path.GetDirectoryName(destPath);
if (!Directory.Exists(destFolder))
{
Directory.CreateDirectory(destFolder);
}
if (results.Length < 1)
{
throw new ArgumentNullException("Need at least one results file to perform merge operation.");
}
var targetDoc = XDocument.Load(results.First().ResultsFilepath);
var targetElementEnvironment = new ElementEnvironment(GetTestSuite(targetDoc), results.First().Environment);
var totals = GetTotals(targetDoc);
AddEnvironmentAttributeToCases(targetElementEnvironment.NamespaceElement, targetElementEnvironment.Environment.Name);
foreach (var result in results.Skip(1))
{
var sourceDoc = XDocument.Load(result.ResultsFilepath);
AccumulateTotals(totals, GetTotals(sourceDoc));
var sourceElementEnvironment = new ElementEnvironment(GetTestSuite(sourceDoc), result.Environment);
AddEnvironmentAttributeToCases(sourceElementEnvironment.NamespaceElement, sourceElementEnvironment.Environment.Name);
MergeNamespaces(targetElementEnvironment, sourceElementEnvironment);
}
WriteTotals(targetDoc, totals);
targetDoc.Save(destPath);
}
//Environment
public IEnumerator CalculateEnvironment(bool overwrite = true, int maxIterations = 4)
{
_busy++;
int selectionNum;
int atomNum;
int environmentCalculatedCount = 0;
Atom atom;
selection = SelectIf();
if (!overwrite)
{
for (atomNum = 0; atomNum < size; atomNum++)
{
if (atoms[atomNum].amberName != "")
{
selection.Remove(atomNum);
}
}
}
yield return(new WaitForSeconds(0.1f));
for (int iteration = 0; iteration < maxIterations; iteration++)
{
if (environmentCalculatedCount == size)
{
break;
}
for (selectionNum = selection.Count - 1; selectionNum >= 0; selectionNum--)
{
atomNum = selection[selectionNum];
atom = atoms[atomNum];
string element = atom.element;
if (!amberEnvironment.elementEnvironments.ContainsKey(element))
{
Debug.LogErrorFormat("Element {0} not included in data file", element);
selection.RemoveAt(atomNum);
continue;
}
ElementEnvironment elementEnvironment = amberEnvironment.elementEnvironments [element];
atom.mass = elementEnvironment.mass;
bool conditionMet = false;
foreach (string key in elementEnvironment.environmentDict.Keys)
{
AtomEnvironment atomEnvironment = elementEnvironment.environmentDict [key];
foreach (EnvironmentCondition environmentCondition in atomEnvironment.environmentConditions)
{
//Meets condition
if (environmentCondition.EvaluateConditions(atoms, atomNum) == 0)
{
atom.amberName = atomEnvironment.amber;
atom.atomState = atomEnvironment.atomState;
atom.vdwRadius = atomEnvironment.radius;
atom.color = atomEnvironment.color;
selection.RemoveAt(atomNum);
conditionMet = true;
break;
}
}
if (conditionMet)
{
break;
}
}
}
yield return(new WaitForSeconds(0.1f));
}
_busy--;
}
//Environment
public IEnumerator CalculateEnvironment(bool overwrite = true, int maxIterations = 4)
{
_busy++;
int atomNum;
int environmentCalculatedCount = 0;
for (atomNum = 0; atomNum < size; atomNum++)
{
selection [atomNum] = 1.0;
}
if (!overwrite)
{
for (atomNum = 0; atomNum < size; atomNum++)
{
if (atoms[atomNum].amberName != "")
{
selection [atomNum] = 0.0;
}
}
}
yield return(new WaitForSeconds(0.1f));
for (int iteration = 0; iteration < maxIterations; iteration++)
{
if (environmentCalculatedCount == size)
{
break;
}
for (atomNum = 0; atomNum < size; atomNum++)
{
if (selection [atomNum] == 0.0)
{
continue;
}
string element = atoms [atomNum].element;
if (!amberEnvironment.elementEnvironments.ContainsKey(element))
{
Debug.LogErrorFormat("Element {0} not included in data file", element);
selection [atomNum] = 0.0;
continue;
}
ElementEnvironment elementEnvironment = amberEnvironment.elementEnvironments [element];
foreach (string key in elementEnvironment.environmentDict.Keys)
{
AtomEnvironment atomEnvironment = elementEnvironment.environmentDict [key];
foreach (EnvironmentCondition environmentCondition in atomEnvironment.environmentConditions)
{
//Meets condition
if (environmentCondition.EvaluateConditions(atoms, atomNum) == 0)
{
atoms [atomNum].amberName = atomEnvironment.amber;
atoms [atomNum].atomState = atomEnvironment.atomState;
atoms [atomNum].vdwRadius = atomEnvironment.radius;
atoms [atomNum].color = atomEnvironment.color;
selection [atomNum] = 0.0;
goto CONDITIONMET;
}
}
}
CONDITIONMET :;
}
yield return(new WaitForSeconds(0.1f));
}
_busy--;
}
