public virtual void TestParseInvalidAttributesWithDifferentUnitsAndTypes() { XmlNode node = CreateNode("<something value=\"1234.45\" unit=\"xyzabc\" />"); PhysicalQuantity physicalQuantity = (PhysicalQuantity) new PqElementParser().Parse(CreateContext("PQ.BASIC", SpecificationVersion .V02R02), node, this.xmlResult).BareValue; Assert.IsFalse(this.xmlResult.IsValid()); Assert.IsNull(physicalQuantity.Unit, "unit"); node = CreateNode("<something value=\"1234.45\" unit=\"mo\" />"); physicalQuantity = (PhysicalQuantity) new PqElementParser().Parse(CreateContext("PQ.DRUG", SpecificationVersion.V02R02), node , this.xmlResult).BareValue; Assert.IsFalse(this.xmlResult.IsValid()); Assert.IsNull(physicalQuantity.Unit, "unit"); node = CreateNode("<something value=\"1234.45\" unit=\"kg\" />"); physicalQuantity = (PhysicalQuantity) new PqElementParser().Parse(CreateContext("PQ.TIME", SpecificationVersion.V02R02), node , this.xmlResult).BareValue; Assert.IsFalse(this.xmlResult.IsValid()); Assert.IsNull(physicalQuantity.Unit, "unit"); node = CreateNode("<something value=\"1234.45\" unit=\"mo\" />"); physicalQuantity = (PhysicalQuantity) new PqElementParser().Parse(CreateContext("PQ.HEIGHTWEIGHT", SpecificationVersion.V02R02 ), node, this.xmlResult).BareValue; Assert.IsFalse(this.xmlResult.IsValid()); Assert.IsNull(physicalQuantity.Unit, "unit"); node = CreateNode("<something value=\"1234.45\" unit=\"mo\" />"); physicalQuantity = (PhysicalQuantity) new PqElementParser().Parse(CreateContext("PQ.DISTANCE", SpecificationVersion.V02R02 ), node, this.xmlResult).BareValue; Assert.IsFalse(this.xmlResult.IsValid()); Assert.IsNull(physicalQuantity.Unit, "unit"); }
protected ProcessVar(string name, PhysicalQuantity type, VarState state, IProcessVarOwner owner) : base() { this.name = name; this.type = type; this.state = state; this.owner = owner; }
/// <summary> /// Evaluates the operator on scalar operands. /// </summary> /// <param name="Operand">Operand.</param> /// <param name="Variables">Variables collection.</param> /// <returns>Result</returns> public override IElement EvaluateScalar(IElement Operand, Variables Variables) { DoubleNumber D = Operand as DoubleNumber; if (!(D is null)) { return(new PhysicalQuantity(D.Value, this.unit)); } PhysicalQuantity Q = Operand as PhysicalQuantity; if (!(Q is null)) { double Magnitude; if (Unit.TryConvert(Q.Magnitude, Q.Unit, this.unit, out Magnitude)) { return(new PhysicalQuantity(Magnitude, this.unit)); } else { throw new ScriptRuntimeException("Unable to convert from " + Q.Unit.ToString() + " to " + this.unit.ToString() + ".", this); } } throw new ScriptRuntimeException("Unable to set physical unit.", this); }
protected ProcessVar(string name, PhysicalQuantity type, VarState state) : base() { this.name = name; this.type = type; this.state = state; }
private void CheckDenominator(Ratio <N, D> result, bool denominatorFound, XmlNode node, ParseContext context, XmlToModelResult xmlToModelResult) { if (denominatorFound) { if (result.Denominator is PhysicalQuantity) { PhysicalQuantity pqDenominator = (PhysicalQuantity)(object)result.Denominator; //cast to Object for .NET translation if (BigDecimal.ZERO.Equals(pqDenominator.Quantity)) { RecordError("Denominator value can not be zero.", context, node, xmlToModelResult); } else { if (pqDenominator.Quantity == null) { // schema states that the pq values default to "1", without reference to which property; assuming this to mean quantity pqDenominator.Quantity = BigDecimal.ONE; } } } } else { RecordMissingElementError("Denominator", context, node, xmlToModelResult); } }
public virtual void TestPivlPhasePeriod() { XmlToModelResult result = new XmlToModelResult(); XmlNode node = CreateNode("<pivl><period unit=\"d\" value=\"1\"/><phase><low value=\"20120503\"/><high value=\"20120708\"/></phase></pivl>" ); ParseContext context = ParseContextImpl.Create("PIVLTSCDAR1", null, SpecificationVersion.R02_04_03, null, null, Ca.Infoway.Messagebuilder.Xml.ConformanceLevel .MANDATORY, Cardinality.Create("1"), null, true); BareANY parseResult = this.parser.Parse(context, Arrays.AsList(node), result); PhysicalQuantity expectedPeriod = new PhysicalQuantity(BigDecimal.ONE, Ca.Infoway.Messagebuilder.Domainvalue.Basic.UnitsOfMeasureCaseSensitive .DAY); PlatformDate dateLow = DateUtil.GetDate(2012, 4, 3); DateWithPattern dateWithPatternLow = new DateWithPattern(dateLow, "yyyyMMdd"); PlatformDate dateHigh = DateUtil.GetDate(2012, 6, 8); DateWithPattern dateWithPatternHigh = new DateWithPattern(dateHigh, "yyyyMMdd"); Interval <PlatformDate> expectedPhase = IntervalFactory.CreateLowHigh((PlatformDate)dateWithPatternLow, (PlatformDate)dateWithPatternHigh ); Assert.IsTrue(result.IsValid()); Assert.IsTrue(parseResult is PIVLTSCDAR1); PeriodicIntervalTimeR2 pivl = (PeriodicIntervalTimeR2)parseResult.BareValue; Assert.AreEqual(expectedPeriod.Quantity, pivl.Period.Quantity); Assert.AreEqual(expectedPeriod.Unit.CodeValue, pivl.Period.Unit.CodeValue); Assert.AreEqual(expectedPhase, pivl.Phase); Assert.IsNull(pivl.FrequencyRepetitions); Assert.IsNull(pivl.FrequencyQuantity); }
protected virtual PeriodicIntervalTime ParseFrequency(ParseContext context, XmlElement element, Type expectedReturnType, XmlToModelResult xmlToModelResult) { XmlElement numerator = (XmlElement)GetNamedChildNode(element, "numerator"); XmlElement denominator = (XmlElement)GetNamedChildNode(element, "denominator"); if (numerator != null && denominator != null) { Int32?repetitions = ParseNumerator(context, numerator, xmlToModelResult); if (SpecificationVersion.IsExactVersion(SpecificationVersion.V01R04_2_SK, context.GetVersion())) { Interval <PhysicalQuantity> quantityInterval = ParseDenominatorSk(context, denominator, xmlToModelResult); return(PeriodicIntervalTimeSk.CreateFrequencySk(repetitions, quantityInterval == null ? null : quantityInterval.Low, quantityInterval == null ? null : quantityInterval.High)); } else { PhysicalQuantity quantity = ParseDenominator(context, denominator, xmlToModelResult); return(PeriodicIntervalTime.CreateFrequency(repetitions, quantity)); } } else { if (numerator == null) { CreateMandatoryChildElementHl7Error(element, "numerator", xmlToModelResult); } if (denominator == null) { CreateMandatoryChildElementHl7Error(element, "denominator", xmlToModelResult); } return(null); } }
public CurveF(string name, float val, PointF[] data) { this.name = name; this.val = val; this.pq = pq; this.data = data; }
private static PhysicalQuantity AddPhysicalQuantity(PhysicalQuantity q1, PhysicalQuantity q2) { // Units must be the same in order to be added (though an argument can be made that we // could be smart about unit types that can be converted to each other). // Redmine 11271 - special case: if both units are null then the add will be allowed to go through as if the two values had the same units Boolean unitsBothNull = (q1.Unit == null && q2.Unit == null); Boolean unitsBothProvided = (q1.Unit != null && q2.Unit != null); if (unitsBothNull || (unitsBothProvided && StringUtils.Equals(q1.Unit.CodeValue, q2.Unit.CodeValue))) { return(new PhysicalQuantity(Add(q1.Quantity, q2.Quantity), q1.Unit)); } else { //Fix for exception msg. Null Reference Exception otherwise. string q1Units = (q1.Unit == null ? "" : q1.Unit.CodeValue); string q2Units = (q2.Unit == null ? "" : q2.Unit.CodeValue); throw new ArgumentException( "Can't add two quantities of different units: " + q1Units + " and " + q2Units); } }
/// <summary> /// Gets label values for a series vector. /// </summary> /// <param name="Min">Smallest value.</param> /// <param name="Max">Largest value.</param> /// <param name="ApproxNrLabels">Number of labels.</param> /// <returns>Vector of labels.</returns> public static PhysicalQuantity[] GetLabels(PhysicalQuantity Min, PhysicalQuantity Max, int ApproxNrLabels) { double MinValue = Min.Magnitude; double MaxValue; Unit Unit = Min.Unit; if (!Min.Unit.Equals(Max.Unit)) { if (!Unit.TryConvert(Max.Magnitude, Max.Unit, Unit, out MaxValue)) { throw new ScriptException("Incompatible units."); } } else { MaxValue = Max.Magnitude; } double[] Labels = GetLabels(MinValue, MaxValue, ApproxNrLabels); int i, c = Labels.Length; PhysicalQuantity[] Result = new PhysicalQuantity[c]; for (i = 0; i < c; i++) { Result[i] = new PhysicalQuantity(Labels[i], Unit); } return(Result); }
public virtual void TestFormatPhysicalQuantityValidWithTranslations() { CodedTypeR2 <Code> translation1 = new CodedTypeR2 <Code>(); translation1.Code = Ca.Infoway.Messagebuilder.Domainvalue.Payload.AdministrativeGender.MALE; CodedTypeR2 <Code> translation2 = new CodedTypeR2 <Code>(); translation2.Code = Ca.Infoway.Messagebuilder.Domainvalue.Controlact.ActStatus.ACTIVE; string quantity = "33.45"; Ca.Infoway.Messagebuilder.Domainvalue.UnitsOfMeasureCaseSensitive unit = CeRxDomainTestValues.ENZYME_UNIT_MICROMOLES_MINUTE_PER_LITRE; PhysicalQuantity physicalQuantity = new PhysicalQuantity(); physicalQuantity.Quantity = new BigDecimal(quantity); physicalQuantity.Unit = unit; physicalQuantity.Translation.Add(translation1); physicalQuantity.Translation.Add(translation2); IDictionary <string, string> result = new PqR2PropertyFormatterTest.TestablePqR2PropertyFormatter().GetAttributeNameValuePairsForTest (CreateContext("PQ"), physicalQuantity, null); Assert.AreEqual(2, result.Count, "map size"); Assert.IsTrue(result.ContainsKey("value"), "key as expected"); Assert.AreEqual(quantity, result.SafeGet("value"), "value"); Assert.IsTrue(result.ContainsKey("unit"), "unit key as expected"); Assert.AreEqual(unit.CodeValue, result.SafeGet("unit"), "unit"); string xml = new PqR2PropertyFormatterTest.TestablePqR2PropertyFormatter().Format(CreateContext("PQ"), new PQImpl(physicalQuantity ), 0); AssertXml("should see translations", "<name unit=\"U/L\" value=\"33.45\"><translation code=\"M\" codeSystem=\"2.16.840.1.113883.5.1\" displayName=\"Male\"/><translation code=\"active\" codeSystem=\"2.16.840.1.113883.5.14\" displayName=\"Active\"/></name>" , xml); }
private static PhysicalQuantity Half(PhysicalQuantity value_ren) { BigDecimal quantity = value_ren.Quantity; BigDecimal newValue = quantity == null ? null : quantity.Multiply(new BigDecimal("0.5")); return(new PhysicalQuantity(newValue, value_ren.Unit)); }
public CurveF(float val, PhysicalQuantity pq, PointF[] data) { this.name = ""; this.val = val; this.pq = pq; this.data = data; }
/// <summary> /// Constructs a PeriodicIntervalTimeSk using the supplied parameters. /// </summary> /// /// <param name="repetitions_0">number of repetitions</param> /// <param name="quantity_1">the lower boundary of the physical quantity range</param> /// <param name="quantity_2">the upper boundary of the physical quantity range</param> /// <returns>the constructed PeriodicIntervalTime</returns> public static PeriodicIntervalTimeSk CreateFrequencySk(Int32?repetitions_0, PhysicalQuantity quantity_1, PhysicalQuantity quantity_2) { Interval <PhysicalQuantity> ivlPq = IntervalUtil.CreateInterval(quantity_1, quantity_2); return(new PeriodicIntervalTimeSk(null, null, repetitions_0, ivlPq, Representation.FREQUENCY)); }
public virtual void TestFormatValueNonNull() { PhysicalQuantity numerator1 = new PhysicalQuantity(BigDecimal.ONE, Ca.Infoway.Messagebuilder.Domainvalue.Basic.UnitsOfMeasureCaseSensitive .CENTIMETRE); PhysicalQuantity denominator1 = new PhysicalQuantity(new BigDecimal(2), Ca.Infoway.Messagebuilder.Domainvalue.Basic.UnitsOfMeasureCaseSensitive .CUBIC_CENTIMETER); PhysicalQuantity numerator2 = new PhysicalQuantity(BigDecimal.TEN, Ca.Infoway.Messagebuilder.Domainvalue.Basic.UnitsOfMeasureCaseSensitive .MILLIMETER); PhysicalQuantity denominator2 = new PhysicalQuantity(new BigDecimal(11), Ca.Infoway.Messagebuilder.Domainvalue.Basic.UnitsOfMeasureCaseSensitive .CUBIC_MILIMETER); Ratio <PhysicalQuantity, PhysicalQuantity> ratio1 = new Ratio <PhysicalQuantity, PhysicalQuantity>(numerator1, denominator1 ); Ratio <PhysicalQuantity, PhysicalQuantity> ratio2 = new Ratio <PhysicalQuantity, PhysicalQuantity>(numerator2, denominator2 ); SETImpl <RTO <PhysicalQuantity, PhysicalQuantity>, Ratio <PhysicalQuantity, PhysicalQuantity> > set = new SETImpl <RTO <PhysicalQuantity , PhysicalQuantity>, Ratio <PhysicalQuantity, PhysicalQuantity> >(typeof(RTOImpl <PhysicalQuantity, PhysicalQuantity>)); set.RawSet().AddAll(MakeSet(ratio1, ratio2)); string result = new SetPropertyFormatter(this.formatterRegistry).Format(new Ca.Infoway.Messagebuilder.Marshalling.HL7.Formatter.FormatContextImpl (new ModelToXmlResult(), null, "blah", "SET<RTO<PQ.DRUG,PQ.TIME>>", Ca.Infoway.Messagebuilder.Xml.ConformanceLevel.MANDATORY , Cardinality.Create("1-4"), false, SpecificationVersion.R02_04_02, null, null, null, false), set); AssertXml("non null", "<blah><numerator unit=\"cm\" value=\"1\"/><denominator unit=\"cm3\" value=\"2\"/></blah><blah><numerator unit=\"mm\" value=\"10\"/><denominator unit=\"mm3\" value=\"11\"/></blah>" , result); }
public void SetOyMax(float max) { PhysicalQuantity pq = this.yPlotVariable.Variable.Type; double newMax = UnitSystemService.GetInstance().ConvertToSIValue(pq, (double)max); this.psychrometricChartModel.SetOyMax((double)newMax); this.UpdateCurrentStateOrProcess(); }
public virtual void TestParseNoCorrectAttributeNodes() { XmlNode node = CreateNode("<something notvalue=\"\" />"); PhysicalQuantity physicalQuantity = (PhysicalQuantity) new PqR2ElementParser().Parse(CreateContext("PQ", SpecificationVersion .V02R02), node, this.xmlResult).BareValue; Assert.IsTrue(this.xmlResult.IsValid()); Assert.IsNull(physicalQuantity, "PhysicalQuantity"); }
private IDictionary <string, string> GetAttributes(DateDiff period, FormatContext context) { PhysicalQuantity quantity = period.ValueAsPhysicalQuantity; FormatContext newContext = new Ca.Infoway.Messagebuilder.Marshalling.HL7.Formatter.FormatContextImpl("PQ.TIME", context); // getAttributeNameValuePairs is never called with a null value; directly calling it from here is a bit of a cheat, so ensure no null passed in return(quantity == null ? new Dictionary <string, string>() : new PqPropertyFormatter().GetAttributeNameValuePairs(newContext , quantity)); }
private string CreatePeriod(PeriodicIntervalTimeR2 value, FormatContext context, int indentLevel) { PhysicalQuantity period = value.Period; FormatContext periodContext = new Ca.Infoway.Messagebuilder.Marshalling.HL7.Formatter.FormatContextImpl("PQ", PERIOD, context ); PQ periodWrapper = new PQImpl(period); return(this.pqFormatter.Format(periodContext, periodWrapper, indentLevel)); }
public virtual void TestPhysicalQuantityEquals() { PhysicalQuantity pq1 = new PhysicalQuantity(new BigDecimal(1.5), Ca.Infoway.Messagebuilder.Domainvalue.Basic.UnitsOfMeasureCaseSensitive .CENTIMETRE); PhysicalQuantity pq2 = new PhysicalQuantity(new BigDecimal(1.5), Ca.Infoway.Messagebuilder.Domainvalue.Basic.UnitsOfMeasureCaseSensitive .CENTIMETRE); Assert.AreEqual(pq1, pq2); }
public PeriodicIntervalTimeR2(Interval <PlatformDate> phase, PhysicalQuantity period, CalendarCycle alignment, Boolean?institutionSpecified, Int32?frequencyRepetitions, PhysicalQuantity frequencyQuantity) { Phase = phase; Period = period; Alignment = alignment; InstitutionSpecified = institutionSpecified; FrequencyRepetitions = frequencyRepetitions; FrequencyQuantity = frequencyQuantity; }
public static PeriodicIntervalTimeR2 CreateFromPivlR1(PeriodicIntervalTime pivlR1) { DateDiff period = pivlR1.Period; PhysicalQuantity periodPq = (period != null ? period.ValueAsPhysicalQuantity : null); Interval <PlatformDate> phase = pivlR1.Phase; PhysicalQuantity quantity = pivlR1.Quantity; Int32?repetitions = pivlR1.Repetitions; return(new PeriodicIntervalTimeR2(phase, periodPq, null, null, repetitions, quantity)); }
public virtual void TestFormatPhysicalQuantityValueOrUnitNull() { // no name-value pairs PqPropertyFormatter formatter = new PqPropertyFormatter(); PhysicalQuantity physicalQuantity = new PhysicalQuantity(); physicalQuantity.Unit = Ca.Infoway.Messagebuilder.Domainvalue.Basic.UnitsOfMeasureCaseSensitive.MILLIGRAM; formatter.Format(CreateContext(), new PQImpl(physicalQuantity)); Assert.AreEqual("No value provided for physical quantity", this.result.GetHl7Errors()[0].GetMessage()); }
protected PeriodicIntervalTime(DateDiff period_0, Interval <Ca.Infoway.Messagebuilder.PlatformDate> phase_1, Int32?repetitions_2, PhysicalQuantity quantity_3, Representation representation_4) { this.period = period_0; this.phase = phase_1; this.repetitions = repetitions_2; this.quantity = quantity_3; this.representation = representation_4; }
public virtual void TestParseValidAttributesNoUnit() { XmlNode node = CreateNode("<something value=\"1234.45\" />"); PhysicalQuantity physicalQuantity = (PhysicalQuantity) new PqR2ElementParser().Parse(CreateContext("PQ", SpecificationVersion .V02R02), node, this.xmlResult).BareValue; Assert.IsTrue(this.xmlResult.IsValid()); Assert.IsNotNull(physicalQuantity, "PhysicalQuantity"); Assert.AreEqual("1234.45", physicalQuantity.Quantity.ToString(), "value"); Assert.IsNull(physicalQuantity.Unit, "unit"); }
public virtual void TestParseNoCorrectAttributeNodes() { XmlNode node = CreateNode("<something notvalue=\"\" />"); PhysicalQuantity physicalQuantity = (PhysicalQuantity) new PqElementParser().Parse(CreateContext("PQ.BASIC", SpecificationVersion .V02R02), node, this.xmlResult).BareValue; Assert.IsFalse(this.xmlResult.IsValid()); Assert.AreEqual(1, this.xmlResult.GetHl7Errors().Count); Assert.IsNull(physicalQuantity, "PhysicalQuantity"); Assert.IsFalse(this.xmlResult.IsValid(), "result"); }
public virtual void TestParseValidAttributes() { XmlNode node = CreateNode("<something value=\"1234.45\" unit=\"kg\" />"); PhysicalQuantity physicalQuantity = (PhysicalQuantity) new PqR2ElementParser().Parse(CreateContext("PQ", SpecificationVersion .V02R02), node, this.xmlResult).BareValue; Assert.IsTrue(this.xmlResult.IsValid()); Assert.IsNotNull(physicalQuantity, "PhysicalQuantity"); Assert.AreEqual(new BigDecimal("1234.45"), physicalQuantity.Quantity, "quantity"); Assert.AreEqual(CeRxDomainTestValues.KILOGRAM.CodeValue, physicalQuantity.Unit.CodeValue, "unit"); }
/// <exception cref="System.Exception"></exception> private void AssertFormattingAsExpected(string quantity, string formattedQuantity) { PhysicalQuantity physicalQuantity = new PhysicalQuantity(); physicalQuantity.Quantity = new BigDecimal(quantity); physicalQuantity.Unit = CeRxDomainTestValues.CENTIMETRE; IDictionary <string, string> result = new PqR2PropertyFormatterTest.TestablePqR2PropertyFormatter().GetAttributeNameValuePairsForTest (CreateContext("PQ"), physicalQuantity, null); Assert.AreEqual(formattedQuantity, result.SafeGet("value"), "value " + quantity); }
/// <exception cref="Ca.Infoway.Messagebuilder.Marshalling.HL7.XmlToModelTransformationException"></exception> protected override PeriodicIntervalTimeR2 ParseNonNullNode(ParseContext context, XmlNode node, BareANY result, Type expectedReturnType , XmlToModelResult xmlToModelResult) { XmlElement periodElement = (XmlElement)GetNamedChildNode(node, "period"); PhysicalQuantity period = CreatePeriodType(context, periodElement, xmlToModelResult); XmlElement phaseElement = (XmlElement)GetNamedChildNode(node, "phase"); Interval <PlatformDate> phase = CreatePhaseType(context, phaseElement, xmlToModelResult); CalendarCycle alignment = ObtainAlignment(context, (XmlElement)node, xmlToModelResult); bool institutionSpecified = ObtainInstitutionSpecified(context, (XmlElement)node, xmlToModelResult); return(new PeriodicIntervalTimeR2(phase, period, alignment, institutionSpecified, null, null)); }
public virtual void TestFormatPhysicalQuantityValueOrUnitNull() { // no name-value pairs PqR2PropertyFormatter formatter = new PqR2PropertyFormatterTest.TestablePqR2PropertyFormatter(); PhysicalQuantity physicalQuantity = new PhysicalQuantity(); physicalQuantity.Unit = CeRxDomainTestValues.ENZYME_UNIT_MICROMOLES_MINUTE_PER_LITRE; string result = formatter.Format(CreateContext("PQ"), new PQImpl(physicalQuantity)); Assert.IsTrue(this.result.IsValid()); Assert.AreEqual("<name unit=\"U/L\"/>", result.Trim(), "map size"); }