/// <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); } }