Example #1
0
        protected override void Context()
        {
            sut = new DimensionFactory();

            _drugMassDimension = new Dimension(new BaseDimensionRepresentation(), "DrugMass", "g");
            _volumeDimension   = new Dimension(new BaseDimensionRepresentation {
                MassExponent = 3
            }, "Volume", "l");
            _anotherDimensionThatLooksLikeVolumeWithADifferentUnit = new Dimension(new BaseDimensionRepresentation {
                MassExponent = 3, TimeExponent = -1
            }, "01_OTHER", "");
            _flowDimension = new Dimension(new BaseDimensionRepresentation {
                MassExponent = 3, TimeExponent = -1
            }, "flow", "l/min");
            _timeDimension = new Dimension(new BaseDimensionRepresentation {
                TimeExponent = 1
            }, "Time", "min");
            _inversedTimeDimension = new Dimension(new BaseDimensionRepresentation {
                TimeExponent = -1
            }, "InversedTime", "1/min");

            sut.AddDimension(_drugMassDimension);
            sut.AddDimension(_volumeDimension);
            sut.AddDimension(_flowDimension);
            sut.AddDimension(_anotherDimensionThatLooksLikeVolumeWithADifferentUnit);
            sut.AddDimension(_timeDimension);
            sut.AddDimension(_inversedTimeDimension);
            sut.AddDimension(Constants.Dimension.NO_DIMENSION);
        }
Example #2
0
        private static IDimensionFactory generateFactory()
        {
            var factory = new DimensionFactory();

            var amountDimension = new Dimension(new BaseDimensionRepresentation(), Constants.Dimension.AMOUNT, "Molar Volume");

            amountDimension.AddUnit(new Unit("mol", 1, 0));

            var massDimension = new Dimension(new BaseDimensionRepresentation(), DimensionNames.Mass, "g");

            massDimension.AddUnit(new Unit("kg", 1000, 0));
            massDimension.AddUnit(new Unit("mg", 0.001, 0));

            var concentrationDimension = new Dimension(new BaseDimensionRepresentation(), DimensionNames.Concentration, "mol");

            factory.AddDimension(massDimension);
            factory.AddDimension(concentrationDimension);
            factory.AddDimension(amountDimension);
            factory.AddDimension(new Dimension(new BaseDimensionRepresentation(), Constants.Dimension.AMOUNT_PER_TIME, "mol/min"));
            factory.AddDimension(new Dimension(new BaseDimensionRepresentation(), Constants.Dimension.VOLUME, "l"));
            factory.AddDimension(Constants.Dimension.NO_DIMENSION);

            var timeDimension = new Dimension(new BaseDimensionRepresentation(), Constants.Dimension.TIME, Constants.Dimension.Units.Minutes);

            timeDimension.AddUnit(new Unit(Constants.Dimension.Units.Days, 60 * 24, 0));
            timeDimension.AddUnit(new Unit(Constants.Dimension.Units.Hours, 60, 0));
            timeDimension.AddUnit(new Unit(Constants.Dimension.Units.Months, 60 * 24 * 30, 0));
            timeDimension.AddUnit(new Unit(Constants.Dimension.Units.Seconds, 1.0 / 60, 0));
            timeDimension.AddUnit(new Unit(Constants.Dimension.Units.Weeks, 60 * 24 * 7, 0));
            timeDimension.AddUnit(new Unit(Constants.Dimension.Units.Years, 60 * 24 * 365, 0));
            factory.AddDimension(timeDimension);

            return(factory);
        }
Example #3
0
        public ResponseBuilder(NaturalLanguageQuestion questionModel)
        {
            this.staticResources = StaticResources.GetInstance();
            this.questionModel   = questionModel;
            DimensionFactory dimFactory = Prober.Probe(questionModel?.Question);

            ruleEngine  = dimFactory.RuleEngine;
            chartEngine = dimFactory.ChartEngine;
        }
        public IDimension DimensionByName(string dimensionName)
        {
            var found = DimensionFactory.TryGetDimension(dimensionName, out var dimension);

            if (found)
            {
                return(dimension);
            }

            return(DimensionFactory.Dimension(dimensionName));
        }
Example #5
0
        protected override void Context()
        {
            _executionContext = A.Fake <IExecutionContext>();
            _favoriteTask     = A.Fake <IFavoriteTask>();
            _project          = A.Fake <IProject>();
            sut = new ParameterTask(new EntityPathResolver(new ObjectPathFactoryForSpecs()), _executionContext, _favoriteTask);
            var dimensionFactory = new DimensionFactory();

            _volumeDimension = dimensionFactory.AddDimension(new BaseDimensionRepresentation {
                LengthExponent = 3
            }, "Volume", "L");
            _volumeDimension.AddUnit("mL", 1e-3, 0);
            _parameter           = DomainHelperForSpecs.ConstantParameterWithValue(10);
            _parameter.Dimension = _volumeDimension;
            A.CallTo(() => _executionContext.BuildingBlockContaining(_parameter)).Returns(A.Fake <IPKSimBuildingBlock>());
        }
        private static IDimensionFactory createDimensionFactory()
        {
            var dimensionFactory = new DimensionFactory();

            IDimension dimLess = dimensionFactory.AddDimension(new BaseDimensionRepresentation(), "Fraction", " ");

            dimLess.AddUnit("%", 0.01, 0.0, true);

            IDimension length = dimensionFactory.AddDimension(new BaseDimensionRepresentation {
                LengthExponent = 1
            }, "Length", "m");

            length.AddUnit("mm", 0.001, 0.0, true);
            length.AddUnit("cm", 0.01, 0);
            length.AddUnit("µm", 0.000001, 0);
            length.AddUnit("nm", 0.000000001, 0);

            IDimension amount = dimensionFactory.AddDimension(new BaseDimensionRepresentation {
                AmountExponent = 1
            }, "Amount", "mol");

            amount.AddUnit("mmol", 0.001, 0.0, true);
            amount.AddUnit("µmol", 0.000001, 0);

            IDimension mass = dimensionFactory.AddDimension(new BaseDimensionRepresentation {
                MassExponent = 1
            }, "Mass", "kg");

            mass.AddUnit("mg", 0.000001, 0.0, true);
            mass.AddUnit("g", 0.001, 0);
            mass.AddUnit("µg", 0.000000001, 0);
            mass.AddUnit("ng", 0.000000000001, 0);

            IDimension time = dimensionFactory.AddDimension(new BaseDimensionRepresentation {
                TimeExponent = 1
            }, "Time", "s");

            time.AddUnit("min", 60, 0);
            time.AddUnit("h", 3600, 0);
            time.AddUnit("day", 24 * 3600, 0);
            time.AddUnit("ms", 0.001, 0);

            IDimension velocity =
                dimensionFactory.AddDimension(new BaseDimensionRepresentation {
                LengthExponent = 1, TimeExponent = -1
            }, "Velocity", "m/s");

            velocity.AddUnit("mm/s", 0.001, 0.0, true);
            velocity.AddUnit("mm/min", 0.001 / 60.0, 0);
            velocity.AddUnit("µm/s", 0.000001, 0);

            IDimension volume = dimensionFactory.AddDimension(new BaseDimensionRepresentation {
                LengthExponent = 3
            }, "Volume", "m^3");

            volume.AddUnit("cm^3", 0.000001, 0.0, true);
            volume.AddUnit("mm^3", 0.000000001, 0);
            volume.AddUnit("l", 0.001, 0);

            IDimension specificMass =
                dimensionFactory.AddDimension(new BaseDimensionRepresentation {
                LengthExponent = -3, MassExponent = 1
            },
                                              "SpecificMass", "kg/m^3");

            specificMass.AddUnit("g/cm^3", 1000, 0.0, true);
            specificMass.AddUnit("kg/l", 1000, 0);

            dimensionFactory.AddDimension(Constants.Dimension.NO_DIMENSION);
            return(dimensionFactory);
        }
 public IDimension DimensionByName(string dimensionName)
 {
     return(DimensionFactory.Dimension(dimensionName));
 }