/// <summary>
/// The object that contains the animal parameters
/// </summary>
/// <returns></returns>
public static TAnimalParamSet AnimalParamsGlb()
{
if (_GAnimalParams == null)
{
_GAnimalParams = new TAnimalParamSet();
TGParamFactory.ParamXMLFactory().readDefaults("RUMINANT_PARAM_GLB", ref _GAnimalParams);
}
return (TAnimalParamSet)_GAnimalParams;
}
/// <summary>
/// Alternative copy constructor
/// </summary>
/// <param name="aParent"></param>
/// <param name="srcSet"></param>
public TAnimalParamSet(TParameterSet aParent, TAnimalParamSet srcSet)
: base(aParent/*, srcSet*/)
{
//create a new array
for (int i = 0; i < ConceiveSigs.Length; i++)
ConceiveSigs[i] = new double[2];
ConstructCopy(srcSet);
int Jdx;
if (srcSet != null)
{
if (srcSet.Animal == GrazType.AnimalType.Sheep)
setPotGFW(srcSet.PotentialGFW);
if (srcSet.bUseDairyCurve)
setPeakMilk(srcSet.PotMilkYield);
if (srcSet.FParentage.Length == 0)
{
Array.Resize(ref FParentage, 1);
FParentage[0].sBaseBreed = srcSet.sName;
FParentage[0].fPropn = 1.0;
}
else
{
Array.Resize(ref FParentage, srcSet.FParentage.Length);
for (Jdx = 0; Jdx <= FParentage.Length - 1; Jdx++)
{
FParentage[Jdx].sBaseBreed = srcSet.FParentage[Jdx].sBaseBreed;
FParentage[Jdx].fPropn = srcSet.FParentage[Jdx].fPropn;
}
}
}
}
/// <summary>
/// The strategy for obtaining default parameters is:
/// 1. Attempt to read a base parameter set from a resource called sPrmID in the
/// current module.
/// </summary>
/// <param name="sPrmID"></param>
/// <param name="Params"></param>
public void readDefaults(string sPrmID, ref TParameterSet Params)
{
readFromResource(sPrmID, ref Params, false);
}
/// <summary>
/// Overrides the base function and copies all the animal parameters
/// </summary>
/// <param name="srcSet"></param>
/// <param name="bCopyData"></param>
protected override void copyParams(TParameterSet srcSet, bool bCopyData)
{
int Idx;
base.copyParams(srcSet, false);
TAnimalParamSet prmSet = (TAnimalParamSet)srcSet;
if (bCopyData && (prmSet != null))
{
FBreedSRW = prmSet.FBreedSRW;
FPotFleeceWt = prmSet.FPotFleeceWt;
FDairyIntakePeak = prmSet.FDairyIntakePeak;
FDairyIntakeTime = prmSet.FDairyIntakeTime;
FDairyIntakeShape = prmSet.FDairyIntakeShape;
FUseDairyCurve = prmSet.FUseDairyCurve;
Array.Resize(ref FParentage, prmSet.FParentage.Length);
for (Idx = 0; Idx <= FParentage.Length - 1; Idx++)
FParentage[Idx] = prmSet.FParentage[Idx];
sEditor = prmSet.sEditor;
sEditDate = prmSet.sEditDate;
Animal = prmSet.Animal;
MaxYoung = prmSet.MaxYoung;
Array.Copy(prmSet.SRWScalars,SRWScalars, prmSet.SRWScalars.Length);
FleeceRatio = prmSet.FleeceRatio;
MaxFleeceDiam = prmSet.MaxFleeceDiam;
bDairyBreed = prmSet.bDairyBreed;
PeakMilk = prmSet.PeakMilk;
Array.Copy(prmSet.MortRate, MortRate, prmSet.MortRate.Length);
Array.Copy(prmSet.MortAge, MortAge, prmSet.MortAge.Length);
MortIntensity = prmSet.MortIntensity;
MortCondConst = prmSet.MortCondConst;
MortWtDiff = prmSet.MortWtDiff;
Array.Copy(prmSet.GrowthC,GrowthC, prmSet.GrowthC.Length);
Array.Copy(prmSet.IntakeC, IntakeC,prmSet.IntakeC.Length);
Array.Copy(prmSet.IntakeLactC, IntakeLactC, prmSet.IntakeLactC.Length);
Array.Copy(prmSet.GrazeC, GrazeC, prmSet.GrazeC.Length);
Array.Copy(prmSet.EfficC, EfficC, prmSet.EfficC.Length);
Array.Copy(prmSet.MaintC,MaintC, prmSet.MaintC.Length);
Array.Copy(prmSet.DgProtC,DgProtC, prmSet.DgProtC.Length);
Array.Copy(prmSet.ProtC, ProtC, prmSet.ProtC.Length);
Array.Copy(prmSet.PregC, PregC, prmSet.PregC.Length);
Array.Copy(prmSet.PregScale, PregScale, prmSet.PregScale.Length);
Array.Copy(prmSet.BirthWtScale, BirthWtScale,prmSet.BirthWtScale.Length);
Array.Copy(prmSet.PeakLactC, PeakLactC, prmSet.PeakLactC.Length);
Array.Copy(prmSet.LactC,LactC, prmSet.LactC.Length);
Array.Copy(prmSet.WoolC, WoolC, prmSet.WoolC.Length);
Array.Copy(prmSet.ChillC, ChillC,prmSet.ChillC.Length);
Array.Copy(prmSet.GainC, GainC, prmSet.GainC.Length);
Array.Copy(prmSet.PhosC, PhosC, prmSet.PhosC.Length);
Array.Copy(prmSet.SulfC, SulfC, prmSet.SulfC.Length);
Array.Copy(prmSet.MethC, MethC, prmSet.MethC.Length);
Array.Copy(prmSet.AshAlkC, AshAlkC, prmSet.AshAlkC.Length);
OvulationPeriod = prmSet.OvulationPeriod;
Array.Copy(prmSet.Puberty, Puberty, prmSet.Puberty.Length);
Array.Copy(prmSet.DayLengthConst, DayLengthConst, prmSet.DayLengthConst.Length);
for (int i = 0; i < prmSet.ConceiveSigs.Length; i++)
Array.Copy(prmSet.ConceiveSigs[i], ConceiveSigs[i], prmSet.ConceiveSigs[i].Length);
FertWtDiff = prmSet.FertWtDiff;
Array.Copy(prmSet.ToxaemiaSigs, ToxaemiaSigs, prmSet.ToxaemiaSigs.Length);
Array.Copy(prmSet.DystokiaSigs, DystokiaSigs, prmSet.DystokiaSigs.Length);
Array.Copy(prmSet.ExposureConsts,ExposureConsts, prmSet.ExposureConsts.Length);
SelfWeanPropn = prmSet.SelfWeanPropn;
for (Idx = 0; Idx <= iDefinitionCount() - 1; Idx++)
getDefinition(Idx).setDefined(prmSet.getDefinition(Idx));
}
}
/// <summary>
/// After calling the constructor, this must be called to
/// configure the definitions.
/// </summary>
/// <param name="srcSet"></param>
public void ConstructCopy(TParameterSet srcSet)
{
defineEntries();
copyParams(srcSet, true);
if (FParent != null)
sVersion = FParent.sVersion;
else if (srcSet != null)
sVersion = srcSet.sVersion;
}
/// <summary>
/// Read from internal resource
/// </summary>
/// <param name="sResID"></param>
/// <param name="Params"></param>
/// <param name="bModify"></param>
public void readFromResource(string sResID, ref TParameterSet Params, bool bModify)
{
string paramStr = Properties.Resources.ResourceManager.GetString(sResID);
readFromXML(paramStr, ref Params, bModify);
}
/// <summary>
/// Parses a <parameters> or <set> element in an XML parameter document
/// </summary>
/// <param name="Parser"></param>
/// <param name="aNode"></param>
/// <param name="Params"></param>
/// <param name="bModify"></param>
private void readParamNode(TXMLParser Parser, XmlNode aNode, ref TParameterSet Params, bool bModify)
{
XmlNode childNode;
TParameterSet newParams;
string sTag,
sValues,
sChildName,
sLang,
sDummy;
try
{
Params.sName = Parser.getAttrValue(aNode, "name"); // Name and version information. The
Params.sEnglishName = Params.sName;
if (Params.bRootNode()) // version is passed to child sets
Params.sVersion = Parser.getAttrValue(aNode, "version"); // during creation
childNode = Parser.firstElementChild(aNode, "translate"); // See if tbere's a translation of the name matching our current language setting
while (childNode != null)
{
sLang = Parser.getAttrValue(childNode, "lang");
sDummy = Parser.getText(childNode);
Params.addTranslation(sLang, sDummy);
childNode = Parser.nextElementSibling(childNode, "translate");
}
if (!bModify) // If we are not modifying an existing
while (Params.iChildCount() > 0) // parameter set, then clear any old
Params.deleteChild(Params.iChildCount() - 1); // child parameter sets
sValues = Parser.getAttrValue(aNode, "locales").Trim(); // Populate the locale list
Params.setLocaleText(sValues);
childNode = Parser.firstElementChild(aNode, "par"); // Parse the <par> elements
while (childNode != null)
{
sTag = Parser.getAttrValue(childNode, "name");
sValues = Parser.getText(childNode);
readParamValues(ref Params, sTag, sValues, bModify);
childNode = Parser.nextElementSibling(childNode, "par");
}
Params.deriveParams();
childNode = Parser.firstElementChild(aNode, "set"); // Create child parameter sets from the
while (childNode != null) // <set> elements
{
if (!bModify)
newParams = Params.addChild();
else
{ // If we are modifying an existing
sChildName = Parser.getAttrValue(childNode, "name"); // parameter set, then locate the child
newParams = Params.getChild(sChildName); // set that we are about to parse
if (newParams == null)
newParams = Params.addChild();
}
readParamNode(Parser, childNode, ref newParams, bModify);
childNode = Parser.nextElementSibling(childNode, "set");
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
/// <summary>
/// Constructor for the root set
/// </summary>
public TParameterSet()
{
//new TParameterSet(null, null);
FParent = null;
}
/// <summary>
///
/// </summary>
/// <param name="subSet"></param>
/// <param name="Definition"></param>
/// <returns></returns>
private bool bDiffers(TParameterSet subSet, TParameterDefinition Definition)
{
bool result;
if (!Definition.bValueDefined())
result = false;
else if ((subSet.Parent == null) || (!subSet.Parent.bIsDefined(Definition.sFullName)))
result = true;
else
{
switch (Definition.paramType)
{
case ptyReal: result = (subSet.fParam(Definition.sFullName) != subSet.Parent.fParam(Definition.sFullName));
break;
case ptyInt: result = (subSet.iParam(Definition.sFullName) != subSet.Parent.iParam(Definition.sFullName));
break;
case ptyBool: result = (subSet.bParam(Definition.sFullName) != subSet.Parent.bParam(Definition.sFullName));
break;
case ptyText: result = (subSet.sParam(Definition.sFullName) != subSet.Parent.sParam(Definition.sFullName));
break;
default: result = false;
break;
}
}
return result;
}
private void readFromStream(StreamReader Stream, TParameterSet Params, bool bModify)
{
string sParamStr;
sParamStr = Stream.ReadToEnd();
readFromXML(sParamStr, ref Params, bModify);
}
/// <summary>
/// Sets the value of a parameter in a set, and optionally propagates the value
/// to descendant parameter sets
/// </summary>
/// <param name="Params"></param>
/// <param name="sTag"></param>
/// <param name="sValue"></param>
/// <param name="bPropagate"></param>
private void assignParameter(ref TParameterSet Params, string sTag, string sValue, bool bPropagate)
{
int Idx;
Params.setParam(sTag, sValue);
if (bPropagate)
{
for (Idx = 0; Idx <= Params.iChildCount() - 1; Idx++)
{
TParameterSet child = Params.getChild(Idx);
assignParameter(ref child, sTag, sValue, true);
}
}
}
/// <summary>
/// Parameter set as XML
/// </summary>
/// <param name="Params"></param>
/// <returns></returns>
public string sParamXML(TParameterSet Params)
{
List<string> Strings = new List<string>();
writeParamSet(Params, Strings, "parameters", 0);
return string.Join("\n", Strings.ToArray());
}
/// <summary>
///
/// </summary>
/// <param name="sText"></param>
/// <param name="Params"></param>
/// <param name="bModify"></param>
public void readFromXML(string sText, ref TParameterSet Params, bool bModify)
{
TXMLParser Parser;
Parser = new TXMLParser(sText);
readParamNode(Parser, Parser.rootNode(), ref Params, bModify);
}
/// <summary>
///
/// </summary>
/// <param name="srcSet"></param>
/// <param name="Defn"></param>
protected void copyDefinition(TParameterSet srcSet, TParameterDefinition Defn)
{
int Idx;
if ((Defn.bIsScalar()) && (srcSet != null) && (srcSet.bIsDefined(Defn.sFullName)))
{
switch (Defn.paramType)
{
case ptyReal: setParam(Defn.sFullName, srcSet.fParam(Defn.sFullName));
break;
case ptyInt: setParam(Defn.sFullName, srcSet.iParam(Defn.sFullName));
break;
case ptyBool: setParam(Defn.sFullName, srcSet.bParam(Defn.sFullName));
break;
case ptyText: setParam(Defn.sFullName, srcSet.sParam(Defn.sFullName));
break;
}
}
else if (Defn.bIsScalar())
setUndefined(Defn.sFullName);
else
for (Idx = 0; Idx <= Defn.iCount - 1; Idx++)
copyDefinition(srcSet, Defn.item(Idx));
}
/// <summary>
/// Parses the contents of a <par> element in an XML parameter document.
/// </summary>
/// <param name="Params"></param>
/// <param name="sTag"></param>
/// <param name="sValues"></param>
/// <param name="bPropagate"></param>
private void readParamValues(ref TParameterSet Params, string sTag, string sValues, bool bPropagate)
{
TParameterDefinition Definition;
string sValue;
int Idx;
sValues = sValues.Trim();
if ((sTag != "") && (sValues != ""))
{
Definition = Params.getDefinition(sTag);
if ((Definition == null) || (Definition.iDimension() > 1))
throw new Exception("Invalid tag when reading parameters: " + sTag);
if (Definition.bIsScalar()) // Reference to a single value
assignParameter(ref Params, sTag, sValues, bPropagate);
else
{ // Reference to a list of values
for (Idx = 0; Idx <= Definition.iCount - 1; Idx++)
{
sValue = stripValue(ref sValues);
if (sValue != "") // Null string denotes "leave value at
assignParameter(ref Params, sTag + Definition.item(Idx).sPartName, // default"
sValue, bPropagate);
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="srcSet"></param>
/// <param name="bCopyData"></param>
protected virtual void copyParams(TParameterSet srcSet, bool bCopyData)
{
int Kdx;
if (srcSet != null)
{
FVersion = srcSet.FVersion;
FName = srcSet.FName;
FEnglishName = srcSet.FEnglishName;
Array.Resize(ref FLocales, srcSet.FLocales.Length);
for (Kdx = 0; Kdx <= FLocales.Length - 1; Kdx++)
{
FLocales[Kdx] = srcSet.FLocales[Kdx];
}
FCurrLocale = srcSet.sCurrLocale;
Array.Resize(ref FTranslations, srcSet.FTranslations.Length);
for (Kdx = 0; Kdx <= FTranslations.Length - 1; Kdx++)
{
FTranslations[Kdx] = srcSet.FTranslations[Kdx];
}
}
if (bCopyData)
{
for (Kdx = 0; Kdx <= (iDefinitionCount() - 1); Kdx++)
{
copyDefinition(srcSet, getDefinition(Kdx));
}
deriveParams();
}
}
private void writeParameters(TParameterSet subSet, TParameterDefinition Definition, List<string> Strings, int iIndent)
{
int iDiffCount;
string sLine;
int Idx;
if (Definition.iDimension() > 1) // Multi-dimensional array of
for (Idx = 0; Idx <= Definition.iCount - 1; Idx++) // parameters - recurse
writeParameters(subSet, Definition.item(Idx), Strings, iIndent);
else if (Definition.bIsScalar() && bDiffers(subSet, Definition)) // Single parameter value
{
sLine = new string(' ', iIndent)
+ "<par name=\"" + Definition.sFullName + "\">"
+ subSet.sParam(Definition.sFullName)
+ "</par>";
Strings.Add(sLine);
}
else // List of parameter values (one-
{ // dimensional)
iDiffCount = 0;
for (Idx = 0; Idx <= Definition.iCount - 1; Idx++)
if (bDiffers(subSet, Definition.item(Idx)))
iDiffCount++;
if (iDiffCount > 1) // More than one difference - write
{ // the differing values in a list
sLine = new string(' ', iIndent)
+ "<par name=\"" + Definition.sFullName + "\">";
for (Idx = 0; Idx <= Definition.iCount - 1; Idx++)
{
if (Idx > 0)
sLine += ',';
if (bDiffers(subSet, Definition.item(Idx)))
sLine += subSet.sParam(Definition.item(Idx).sFullName);
}
sLine += "</par>";
Strings.Add(sLine);
}
else if (iDiffCount == 1) // Only one parameter is different -
for (Idx = 0; Idx <= Definition.iCount - 1; Idx++) // write it as a scalar
if (bDiffers(subSet, Definition.item(Idx)))
writeParameters(subSet, Definition.item(Idx), Strings, iIndent);
}
}
// Constructor for creating a child set
/*public TParameterSet(TParameterSet aParent)
{
new TParameterSet(aParent, aParent);
}*/
/// <summary>
/// Copy constructor (with parent)
/// </summary>
/// <param name="aParent"></param>
public TParameterSet(TParameterSet aParent)
{
FParent = aParent;
}
/// <summary>
///
/// </summary>
/// <param name="subSet"></param>
/// <param name="Strings"></param>
/// <param name="sElem"></param>
/// <param name="iIndent"></param>
private void writeParamSet(TParameterSet subSet,
List<string> Strings,
string sElem,
int iIndent)
{
string sLine;
int Idx;
if (!subSet.bRootNode())
Strings.Add("");
sLine = new string(' ', iIndent) + "<" + sElem + " name=\"" + subSet.sEnglishName + "\"";
if (subSet.bRootNode())
sLine += " version=\"" + subSet.sVersion + "\">";
else
{
if (subSet.iLocaleCount() > 0)
{
sLine += " locales=\"" + subSet.getLocale(0);
for (Idx = 1; Idx <= subSet.iLocaleCount() - 1; Idx++)
sLine += ";" + subSet.getLocale(Idx);
sLine += "\"";
}
sLine += ">";
}
Strings.Add(sLine);
if (subSet.iTranslationCount() > 0)
for (Idx = 0; Idx <= subSet.iTranslationCount() - 1; Idx++)
{
sLine = new string(' ', iIndent + 2) + "<translate lang=\"" +
subSet.getTranslation(Idx).sLang + "\">" +
TTypedValue.escapeText(subSet.getTranslation(Idx).sText) + "</translate>";
Strings.Add(sLine);
}
for (Idx = 0; Idx <= subSet.iDefinitionCount() - 1; Idx++)
writeParameters(subSet, subSet.getDefinition(Idx), Strings, iIndent + 2);
for (Idx = 0; Idx <= subSet.iChildCount() - 1; Idx++)
writeParamSet(subSet.getChild(Idx), Strings, "set", iIndent + 2);
sLine = new string(' ', iIndent) + "</" + sElem + ">";
if (!subSet.bRootNode() && (subSet.iChildCount() > 0))
sLine += "<!-- " + subSet.sEnglishName + " -->";
Strings.Add(sLine);
}
/// <summary>
///
/// </summary>
/// <param name="srcSet"></param>
public void CopyAll(TParameterSet srcSet)
{
int Idx;
copyParams(srcSet, true);
while (iChildCount() > srcSet.iChildCount())
{
deleteChild(iChildCount() - 1);
}
while (iChildCount() < srcSet.iChildCount())
{
addChild();
}
for (Idx = 0; Idx <= iChildCount() - 1; Idx++)
{
getChild(Idx).CopyAll(srcSet.getChild(Idx));
}
}
/// <summary>
/// Read the parameters from a file
/// </summary>
/// <param name="sFileName"></param>
/// <param name="Params"></param>
/// <param name="bModify"></param>
public void readFromFile(string sFileName, TParameterSet Params, bool bModify)
{
StreamReader fStream = null;
try
{
fStream = new StreamReader(sFileName);
readFromStream(fStream, Params, bModify);
}
catch (Exception e)
{
if (fStream != null)
fStream = null;
throw new Exception("Cannot load parameter data from \"" + sFileName + "\" \n\n" + e.Message);
}
}
