//--------------------------------------------------------------------- public override void Initialize(string dataFile, PlugIns.ICore modelCore) { Model.Core = modelCore; SiteVars.Initialize(); ParametersParser parser = new ParametersParser(Model.Core.StartTime, Model.Core.EndTime); IParameters parameters = Landis.Data.Load<IParameters>(dataFile, parser); Timestep = parameters.Timestep; managementAreas = parameters.ManagementAreas; UI.WriteLine("Reading management-area map {0} ...", parameters.ManagementAreaMap); ManagementAreas.ReadMap(parameters.ManagementAreaMap, managementAreas); UI.WriteLine("Reading stand map {0} ...", parameters.StandMap); Stands.ReadMap(parameters.StandMap); foreach (ManagementArea mgmtArea in managementAreas) mgmtArea.FinishInitialization(); prescriptionMaps = new PrescriptionMaps(parameters.PrescriptionMapNames); UI.WriteLine("Opening harvest log file \"{0}\" ...", parameters.EventLog); log = Data.CreateTextFile(parameters.EventLog); log.AutoFlush = true; log.WriteLine("Time,Stand,Total Sites,Damaged Sites,Cohorts Killed"); }
public override Verb CreateVerb(string[] tokens) { Color(position, tokens[1].Length, KeyWords); variableName = tokens[2]; var open = tokens[3]; Color(VariableName.Length, Types); Color(open.Length, Structures); parameters = null; var index = NextPosition; if (open == "(") { InClassDefinition = true; Color(open.Length, Structures); var parser = new ParametersParser(); if (parser.Parse(source, index).If(out parameters, out var newIndex)) { index = newIndex; } else { return(null); } InClassDefinition = false; } overridePosition = index; return(new NullOp()); }
public void CountAndTeam_Parsing_CheckLogic(string text, int count, string team) { var result = new ParametersParser().ParseCountAndTeam(text); Assert.AreEqual(result.Count, count); Assert.AreEqual(result.Team, team); }
public override bool Initialize(List <IProcessorInput> inputs, string parameters, ILogger logger) { dealprice = new double[2]; dealtime = new DateTime[2]; dealcounter = 0; this.inputs = inputs; this.logger = logger; ParametersParser parser = CreateParser(parameters); min_node = parser.GetInt("MinValue"); gap_position = parser.GetInt("GapPosition"); if (gap_position < 0 || gap_position > Model.Project.Outputs.Count) { return(false); } Fut = parser.GetInt("Future"); if (Fut < 0 || Fut >= inputs.Count) { return(false); } Value = 0; type = 0; next_peak = 0; max_gap = 0; min_gap = 0; ready = false; peak_time = new DateTime(); string name = parser.GetString("Name"); file_name_profit = Path.Combine(logPath, name + "_profit_log.txt"); file_name_lose = Path.Combine(logPath, name + "_lose_log.txt"); return(true); }
public override bool Initialize(List <IProcessorInput> inputs, string parameters, ILogger logger) { this.logger = logger; ParametersParser parser = CreateParser(parameters); //Strike = parser.GetInt("Strike"); Opt = parser.GetInt("Opt"); if (Opt < 0 || Opt >= inputs.Count) { return(false); } int period = parser.GetInt("period"); spread_col = new double[period]; spread_count = 0; if (parser.GetInt("SpreadFilt") == 1) { filt_spread = true; } else { filt_spread = false; } midle_opt_price = 0; koef = parser.GetDouble("SpreadKoef"); time_prev_spred = new DateTime(); this.inputs = inputs; return(true); }
private void CacheParameterValuesByCodes() { if (this.parameterValuesByCodes == null) { this.parameterValuesByCodes = ParametersParser.Parse(this.catalog.Parameters).ToDictionary(a => a.Key, a => a.Value); } }
public override bool Initialize(List <IProcessorInput> inputs, string parameters, ILogger logger) { this.logger = logger; ParametersParser parser = CreateParser(parameters); call = parser.GetInt("Call"); put = parser.GetInt("Put"); if (call < 0 || call >= inputs.Count) { return(false); } if (put < 0 || put >= inputs.Count) { return(false); } strike = parser.GetDouble("Strike"); type = parser.GetInt("Type"); inp_name = parser.GetString("input_name"); //inp_name_2 = parser.GetString("input_name_2"); /* if(inp_name_2 == inp_name) * { * inp_name_2 += "_n"; * }*/ this.inputs = inputs; SyntheticFutureInput.AddKey(inp_name); //SyntheticFutureInput.AddKey(inp_name_2); return(true); }
//--------------------------------------------------------------------- public override void Initialize(string dataFile, PlugIns.ICore modelCore) { Model.Core = modelCore; ParametersParser.SpeciesDataset = Model.Core.Species; ParametersParser parser = new ParametersParser(); IParameters parameters = Data.Load<IParameters>(dataFile, parser); if(parameters == null) UI.WriteLine("Parameters are not loading."); Timestep = parameters.Timestep; mapNameTemplate = parameters.MapFileNames; pctConiferMapNameTemplate = parameters.PctConiferFileName; pctDeadFirMapNameTemplate = parameters.PctDeadFirFileName; fuelTypes = parameters.FuelTypes; slashTypes = parameters.SlashTypes; fuelCoefs = parameters.FuelCoefficients; //coniferIndex = parameters.ConiferIndex; //decidIndex = parameters.DecidIndex; hardwoodMax = parameters.HardwoodMax; deadFirMaxAge = parameters.DeadFirMaxAge; cohorts = Model.Core.SuccessionCohorts as ILandscapeCohorts; if (cohorts == null) throw new ApplicationException("Error: Cohorts don't support age-cohort interface"); SiteVars.Initialize(); }
public void NameAndTeam_Parsing_CheckLogic(string text, string name, string team) { var result = new ParametersParser().ParseNameAndTeam(text); Assert.AreEqual(result.Name, name); Assert.AreEqual(result.Team, team); }
public override Verb CreateVerb(string[] tokens) { var type = tokens[2]; var readOnly = type == "val"; var _override = type == "set"; var whitespaceLength = tokens[3].Length; Color(position, tokens[1].Length, Whitespaces); Color(type.Length, KeyWords); Color(whitespaceLength, Whitespaces); Color(tokens[4].Length, Structures); var parametersParser = new ParametersParser(); var offset = tokens[1].Length + type.Length + whitespaceLength + 1; if (parametersParser.Parse(source, position + offset).If(out var parameters, out var i) && GetExpression(source, i, EndOfLine()).If(out var expression, out var j)) { overridePosition = j; return(new MultiAssign(parameters, expression, readOnly, _override) { Index = NextPosition }); } return(null); }
private static IEnumerable <KeyValuePair <string, string> > ParseArray(object parameterValue, Type type) { if (parameterValue == null) { return(new KeyValuePair <string, string>[] { }); } if (type == typeof(int)) { return(ParametersParser.ParseArray <int>(parameterValue)); } else if (type == typeof(long)) { return(ParametersParser.ParseArray <long>(parameterValue)); } else if (type == typeof(double)) { return(ParametersParser.ParseArray <double>(parameterValue)); } else if (type == typeof(float)) { return(ParametersParser.ParseArray <float>(parameterValue)); } else if (type == typeof(string)) { return(ParametersParser.ParseArray <string>(parameterValue)); } else if (type == typeof(object)) { return(ParametersParser.ParseArray <object>(parameterValue)); } return(new KeyValuePair <string, string>[] { }); }
public static string ParseQuery(HTTP.Parameters parameters) { var queryParameters = ParametersParser.Parse(parameters); var queryArray = queryParameters.Select(pair => string.Format("{0}={1}", pair.Key, pair.Value)); return(string.Join("&", queryArray)); }
public override bool Initialize(List <IProcessorInput> inputs, string parameters, ILogger logger) { if (Models.InputItemInteractivBrokerModel.IB == null) { return(false); } this.logger = logger; ParametersParser parser = CreateParser(parameters); simtradeid = parser.GetInt("SimTrade_ID"); if (simtradeid < 0 || simtradeid > Model.Project.Outputs.Count) { return(false); } tradeId = parser.GetInt("TradeID"); tradeTerminal.FirstBroker = new ModelsAT.BrokerMT(tradeId); tradeTerminal.FirstBroker.setBrokerParam("Name", parser.GetString("MT_name")); tradeTerminal.FirstBroker.setOrderParam("MKT"); tradeTerminal.SecondBroker = new ModelsAT.BrokerIBOptionPair(tradeId, Models.InputItemInteractivBrokerModel.IB); tradeTerminal.SecondBroker.setBrokerParam("Put", parser.GetString("IB_Put_name")); tradeTerminal.SecondBroker.setBrokerParam("Call", parser.GetString("IB_Call_name")); tradeTerminal.SecondBroker.setBrokerParam("Volume", parser.GetString("Volume_IB")); tradeTerminal.SecondBroker.setBrokerParam("LimitPrice", parser.GetString("LMT_Price_IB")); tradeTerminal.SecondBroker.setOrderParam(parser.GetString("OrderType_IB")); SimTrade = Model.Project.Proccesors[simtradeid]; SimTrade.ProcessorAction += EventHandler; if (parser.GetInt("IsReal") == 1) { tradeTerminal.FirstBroker.isReal = true; tradeTerminal.SecondBroker.isReal = true; } Model.OutputsInitializeEnd += InitializeHandler; return(true); }
public override Verb CreateVerb(string[] tokens) { if (!InClassDefinition) { return(null); } Color(position, tokens[1].Length, KeyWords); var name = tokens[2]; Color(name.Length, Variables); var parameterLength = tokens[3].Length; Color(parameterLength, Structures); var index = position + length; var parameters = new Parameters(); if (parameterLength > 0) { var parametersParser = new ParametersParser(); var newIndex = parametersParser.Parse(source, index); if (!newIndex.If(out parameters, out index)) { return(null); } } overridePosition = index; var builder = new CodeBuilder(); if (parameters.Length == 0) { var mangledName = MangledName(name); var cls = new Class(parameters, objectBlock(name), new Block(), ClassName, new string[0], new Parameters(), false); var verb = new CreateClass(mangledName, cls); builder.Verb(verb); builder.End(); builder.Push(); builder.FunctionInvoke(mangledName); builder.AssignToNewField(true, name, builder.Pop(true), global: true); builder.End(); } else { var cls = new Class(parameters, objectBlock(name), new Block(), ClassName, new string[0], new Parameters(), false); var verb = new CreateClass(name, cls); builder.Verb(verb); } if (HelperBlock == null) { HelperBlock = new Block(); } foreach (var verb in builder.Block.AsAdded) { HelperBlock.Add(verb); } return(new NullOp()); }
private void CreateOrEditDataTypeParameterValues(Member member, string parameters) { if (member.PropertyDataTypeId == null || string.IsNullOrEmpty(parameters)) { return; } IDataTypeParameterRepository dataTypeParameterRepository = this.Storage.GetRepository <IDataTypeParameterRepository>(); IDataTypeParameterValueRepository dataTypeParameterValueRepository = this.Storage.GetRepository <IDataTypeParameterValueRepository>(); foreach (KeyValuePair <string, string> valueByCode in ParametersParser.Parse(parameters)) { DataTypeParameter dataTypeParameter = dataTypeParameterRepository.WithDataTypeIdAndCode((int)member.PropertyDataTypeId, valueByCode.Key); DataTypeParameterValue dataTypeParameterValue = dataTypeParameterValueRepository.WithDataTypeParameterIdAndMemberId(dataTypeParameter.Id, member.Id); if (dataTypeParameterValue == null) { dataTypeParameterValue = new DataTypeParameterValue(); dataTypeParameterValue.DataTypeParameterId = dataTypeParameter.Id; dataTypeParameterValue.MemberId = member.Id; dataTypeParameterValue.Value = valueByCode.Value; dataTypeParameterValueRepository.Create(dataTypeParameterValue); } else { dataTypeParameterValue.Value = valueByCode.Value; dataTypeParameterValueRepository.Edit(dataTypeParameterValue); } } this.Storage.Save(); }
public static void Main(string[] args) { var config = new LoaderConfiguration(); var loader = new Loader(config); try { if (args.Length == 0) { loader.Start(ExecutableFactory.Detect()); return; } /** * The parameters are expected to be the HCE ones, e.g. `-window`, `-safemode`, etc. * This effectively makes the SPV3 Loader a wrapper around the HCE executable. */ var parameters = new ParametersParser().Parse(string.Join(" ", args)); /** * This allows explicit declaration of the path which the HCE executable resides in. * If the path isn't declared, then we implicitly attempt to detect the executable. */ var executable = args[0].Contains(Executable.Name) ? new Executable(args[0]) : ExecutableFactory.Detect(); loader.Start(executable, parameters); } catch (Exception e) { Console.WriteLine(e.Message); } }
//--------------------------------------------------------------------- public override void Initialize(string dataFile, PlugIns.ICore modelCore) { this.modelCore = modelCore; ParametersParser.SpeciesDataset = modelCore.Species; ParametersParser parser = new ParametersParser(); IParameters parameters = Data.Load<IParameters>(dataFile, parser); Timestep = parameters.Timestep; mapNameTemplate = parameters.MapNames; ILandscapeCohorts cohorts = modelCore.SuccessionCohorts as ILandscapeCohorts; if (cohorts == null) throw new ApplicationException("Error: Cohorts don't support age-cohort interface"); selectedSpecies = new List<SpeciesMaxAgeCalculator>(); foreach (ISpecies species in parameters.SelectedSpecies) selectedSpecies.Add(new SpeciesMaxAgeCalculator(species, cohorts)); siteMaxAgeCalculator = new SiteMaxAgeCalculator(cohorts); ageBuffer = new BlockRowBuffer<ushort>(modelCore.Landscape); }
public void SetUp() { _rpcConfiguration = MockRepository.GenerateStub<IRpcConfiguration>(); _parametersParser = MockRepository.GenerateStub<ParametersParser>(); _methodInvoker = MockRepository.GenerateStub<MethodInvoker>(); _rpcHandlerInterceptor = MockRepository.GenerateStub<RpcHandlerInterceptor>(); _target = new JsonRpcHandler(_parametersParser, _rpcConfiguration, _methodInvoker, _rpcHandlerInterceptor); }
//--------------------------------------------------------------------- public override void Initialize(string dataFile, PlugIns.ICore modelCore) { //initialize event id event_id = 1; Model.Core = modelCore; SiteVars.Initialize(); ParametersParser parser = new ParametersParser(Model.Core.Species, Model.Core.StartTime, Model.Core.EndTime); IParameters parameters = Landis.Data.Load<IParameters>(dataFile, parser); if (parser.RoundedRepeatIntervals.Count > 0) { UI.WriteLine("NOTE: The following repeat intervals were rounded up to"); UI.WriteLine(" ensure they were multiples of the harvest timestep:"); UI.WriteLine(" File: {0}", dataFile); foreach (RoundedInterval interval in parser.RoundedRepeatIntervals) UI.WriteLine(" At line {0}, the interval {1} rounded up to {2}", interval.LineNumber, interval.Original, interval.Adjusted); } //set timestep Timestep = parameters.Timestep; //set management areas managementAreas = parameters.ManagementAreas; UI.WriteLine("Reading management-area map {0} ...", parameters.ManagementAreaMap); //read management area map ManagementAreas.ReadMap(parameters.ManagementAreaMap, managementAreas); UI.WriteLine("Reading stand map {0} ...", parameters.StandMap); //readMap reads the stand map and adds all the stands to a management area Stands.ReadMap(parameters.StandMap); //finish each managementArea's initialization foreach (ManagementArea mgmtArea in managementAreas) //after reading the stand map, finish the initializations mgmtArea.FinishInitialization(); prescriptionMaps = new PrescriptionMaps(parameters.PrescriptionMapNames); //open log file and write header UI.WriteLine("Opening harvest log file \"{0}\" ...", parameters.EventLog); log = Data.CreateTextFile(parameters.EventLog); log.AutoFlush = true; //include a column for each species in the species dictionary string species_header_names = ""; int i = 0; for (i = 0; i < Model.Core.Species.Count; i++) { species_header_names += Model.Core.Species[i].Name + ","; } log.WriteLine("Time,Management Area,Prescription,Stand,Event Id,Stand Age,Stand Rank,Total Sites,Damaged Sites,Cohorts Killed,{0}", species_header_names); }
public CurriedFunctionParser(string functionName, Parameters firstParameters, Object.VisibilityType visibility, bool overriding) : base("^ /(|sp| '(')") { this.functionName = functionName; this.firstParameters = firstParameters; this.visibility = visibility; this.overriding = overriding; parametersParser = new ParametersParser(); freeParser = new FreeParser(); functionBodyParser = new FunctionBodyParser(); }
public void ParseType_TogglesAreParsed_True() { var parsed = new ParametersParser().Parse("-nosound -novideo -safemode -window"); Assert.IsTrue( parsed.DisableSound && parsed.DisableVideo && parsed.EnableSafeMode && parsed.EnableWindowMode ); }
public override Verb CreateVerb(string[] tokens) { var matcher = new Matcher(); Color(position, length, Structures); var index = position + length; var parameters = new Parameters(); if (variableParser.Scan(source, index)) { var parserResult = variableParser.Result; var value = parserResult.Value; var variable = value.As <Variable>(); if (variable.IsSome) { parameters = new Parameters(new[] { new Parameter(variable.Value.Name) }); index = parserResult.Position; } else { return(null); } } else if (matcher.IsMatch(source.Skip(index), @"^ /s* '('")) { var matcherLength = matcher[0].Length; Color(matcherLength, Structures); index += matcherLength; var patternParametersParser = new ParametersParser(ParametersType.Pattern); if (patternParametersParser.Parse(source, ref index)) { parameters = patternParametersParser.Parameters; } else { return(null); } } var block = anyBlockParser.Parse(source, ref index, false); if (block == null) { return(null); } var spatting = anyBlockParser.Splatting; overridePosition = index; return(new CreateLambda(parameters, block, spatting)); }
public override IActionResult Invoke(IRequestHandler requestHandler, Endpoint endpoint, IEnumerable <KeyValuePair <string, string> > parameters) { string url = string.Format("/{0}", requestHandler.HttpContext.GetRouteValue("url")); if (this.GetBoolArgument(ParametersParser.Parse(endpoint.Parameters), "UseCaching")) { return(requestHandler.HttpContext.RequestServices.GetService <ICache>().GetPageActionResultWithDefaultValue( url + requestHandler.HttpContext.Request.QueryString, () => this.GetActionResult(requestHandler, endpoint, parameters, url) )); } return(this.GetActionResult(requestHandler, endpoint, parameters, url)); }
public void Init() { Species.DatasetParser speciesParser = new Species.DatasetParser(); reader = OpenFile("Species.txt"); try { speciesDataset = speciesParser.Parse(reader); } finally { reader.Close(); } parser = new ParametersParser(speciesDataset); }
private static IEnumerable <KeyValuePair <string, string> > ParseArray <T>(object parameterValue) { var parameterArray = parameterValue as IEnumerable <T>; if (parameterArray == null) { return(new KeyValuePair <string, string>[] { }); } var innerParseResult = parameterArray.SelectMany(item => ParametersParser.ParseValue(item)); return(innerParseResult.Select(parsedPair => new KeyValuePair <string, string>(string.Format("[]{0}", parsedPair.Key), parsedPair.Value))); }
public void Init() { parser = new ParametersParser(); Species.DatasetParser speciesParser = new Species.DatasetParser(); reader = OpenFile("Species.txt"); try { ParametersParser.SpeciesDataset = speciesParser.Parse(reader); } finally { reader.Close(); } }
public void SetUp() { _objectFactory = MockRepository.GenerateStub<ObjectFactory>(); _metadata = MockRepository.GenerateStub<Metadata>(); _parametersParser = MockRepository.GenerateStub<ParametersParser>(); _target = new DirectHandler(_objectFactory, _metadata, _parametersParser); _metadata.Stub(x => x.GetActionType("Action")).Return(typeof(Action)); _metadata.Stub(x => x.GetMethodInfo("Action", "method")).Return(typeof(Action).GetMethod("Method")); _metadata.Stub(x => x.GetMethodInfo("Action", "methodWithParams")).Return(typeof(Action).GetMethod("MethodWithParams")); _metadata.Stub(x => x.GetMethodInfo("Action", "methodThatThrowException")).Return(typeof(Action).GetMethod("MethodThatThrowException")); _metadata.Stub(x => x.GetMethodInfo("Action", "methodWithRawParameters")).Return(typeof(Action).GetMethod("MethodWithRawParameters")); }
public override Verb CreateVerb(string[] tokens) { var type = tokens[2]; var name = tokens[4]; Color(position, tokens[1].Length, Whitespaces); Color(type.Length, KeyWords); Color(tokens[3].Length, Whitespaces); Color(name.Length, Operators); Color(tokens[5].Length, Structures); var index = position + length; var parametersParser = new ParametersParser(); var parsed = parametersParser.Parse(source, index); parsed.If(out var parameters, out index).Must().BeTrue().OrThrow("Operator parser", () => "Parameters malformed"); if (functionBodyParser.Parse(source, index).If(out var block, out var newIndex)) { overridePosition = newIndex; var lambda = new Lambda(new Region(), block, parameters, false); var affinity = 0; var pre = false; switch (type) { case "nofix": affinity = 0; break; case "prefix": affinity = 1; pre = true; break; case "postfix": affinity = 1; break; case "infix": affinity = 2; break; } var userDefinedOperator = new UserDefinedOperator(affinity, pre, lambda); CompilerState.RegisterOperator(name, userDefinedOperator); return(new NullOp()); } return(null); }
public static SqliteConnectionParameters Parse(string connectionString) { ParametersParser parser = new ParametersParser(connectionString); SqliteConnectionParameters connParams = new SqliteConnectionParameters { Group = parser.GetValue(AliasesGroup), Connection = parser.GetValue(AliasesConnection), Template = parser.GetValue(AliasesTemplate), Login = parser.GetValue(AliasesLogin) }; return(connParams); }
public void Init() { Species.DatasetParser speciesParser = new Species.DatasetParser(); reader = OpenFile("Species.txt"); try { speciesDataset = speciesParser.Parse(reader); } finally { reader.Close(); } parser = new ParametersParser(speciesDataset, startTime, endTime); }
//--------------------------------------------------------------------- /// <summary> /// Initializes the component with a data file. /// </summary> /// <param name="dataFile"> /// Path to the file with initialization data. /// </param> /// <param name="startTime"> /// Initial timestep (year): the timestep that will be passed to the /// first call to the component's Run method. /// </param> public void Initialize(string dataFile, int startTime) { ParametersParser.SpeciesDataset = Model.Species; ParametersParser parser = new ParametersParser(); IParameters parameters = Data.Load<IParameters>(dataFile, parser); this.timestep = parameters.Timestep; this.nextTimeToRun = startTime - 1; this.mapNameTemplate = parameters.MapNames; this.selectedSpecies = parameters.SelectedSpecies; cohorts = Model.GetSuccession<AgeCohort.ICohort>().Cohorts; }
public static NetworkInformationConnection Parse(string connectionString) { ParametersParser parser = new ParametersParser(connectionString); ProtocolType protocol; int port = 0; int timeout = 0; if (!Enum.TryParse(parser.GetValue(AliasesProtocol), true, out protocol)) { protocol = ProtocolType.Tcp; } if (!int.TryParse(parser.GetValue(AliasesPort), out port)) { switch (protocol) { case ProtocolType.Tcp: case ProtocolType.Udp: port = 80; // assing default port for tcp/udp break; case ProtocolType.Icmp: port = 1; break; } } if (!int.TryParse(parser.GetValue(AliasesTimeout), out timeout)) { // timeout is not defined explicitly // default value will be used timeout = 0; } string host = parser.GetValue(AliasesHost); if (string.IsNullOrEmpty(host)) { host = connectionString; // assume that connection string is a host name } return(new NetworkInformationConnection( host, port, protocol, timeout )); }
public override bool Initialize(List <IProcessorInput> inputs, string parameters, ILogger logger) { this.logger = logger; ParametersParser parser = CreateParser(parameters); Strike = parser.GetInt("Strike"); Fut = parser.GetInt("Future"); Put = parser.GetInt("Put"); Call = parser.GetInt("Call"); if (Call < 0 || Call >= inputs.Count) { return(false); } if (Fut < 0 || Fut >= inputs.Count) { return(false); } if (Put < 0 || Put >= inputs.Count) { return(false); } int period = parser.GetInt("period"); x = new double[period]; if (parser.GetInt("SpreadFilt") == 1) { filt_spread = true; } else { filt_spread = false; } ready = false; spread_col_call = new double[parser.GetInt("MidPricePutPeriod")]; koef = parser.GetDouble("SpreadKoef"); spread_col_put = new double[parser.GetInt("MidPriceCallPeriod")]; spread_count_call = 0; spread_count_put = 0; midle_opt_price_call = 0; midle_opt_price_put = 0; pos = 0; sumx = 0; time_prev_gap = new DateTime(); time_prev_spred_put = new DateTime(); time_prev_spred_call = new DateTime(); this.inputs = inputs; return(true); }
public void Init() { parser = new ParametersParser(); Species.DatasetParser speciesParser = new Species.DatasetParser(); LineReader speciesReader = OpenFile("SpeciesDataset.txt"); try { ParametersParser.SpeciesDataset = speciesParser.Parse(speciesReader); } finally { speciesReader.Close(); } Data.Output.WriteLine("{0} = \"{1}\"", dataDirPlaceholder, Data.Directory); Data.Output.WriteLine(); }
public override async Task <dynamic> GetDataAsync(HttpContext httpContext, DataSource dataSource) { ParametersParser parametersParser = new ParametersParser(dataSource.DataProviderParameters); Inclusion <Object>[] inclusions = null; if (parametersParser.GetStringParameterValue("RelationType") == "Primary") { inclusions = new Inclusion <Object>[] { new Inclusion <Object>("Properties.Member"), new Inclusion <Object>("Properties.StringValue.Localizations"), new Inclusion <Object>("ForeignRelations.Primary.Properties.Member"), new Inclusion <Object>("ForeignRelations.Primary.Properties.StringValue.Localizations") } } ; else { inclusions = new Inclusion <Object>[] { new Inclusion <Object>("Properties.Member"), new Inclusion <Object>("Properties.StringValue.Localizations"), new Inclusion <Object>("PrimaryRelations.Foreign.Properties.Member"), new Inclusion <Object>("PrimaryRelations.Foreign.Properties.StringValue.Localizations") } }; Object @object = (await httpContext.GetStorage().GetRepository <int, Object, ObjectFilter>().GetAllAsync( new ObjectFilter(stringValue: new LocalizationFilter(value: new StringFilter(equals: httpContext.Request.GetUrl()))), inclusions: inclusions )).FirstOrDefault(); if (@object == null) { return(null); } int relationMemberId = parametersParser.GetIntParameterValue("RelationMemberId"); if (new ParametersParser(dataSource.DataProviderParameters).GetStringParameterValue("RelationType") == "Primary") { return(@object.ForeignRelations.Where(r => r.MemberId == relationMemberId).Select(r => this.CreateViewModel(r.Primary))); } return(@object.PrimaryRelations.Where(r => r.MemberId == relationMemberId).Select(r => this.CreateViewModel(r.Foreign))); } }
private static IEnumerable <KeyValuePair <string, string> > ParseDictionary <T, U>(object parameterValue) { var parameterDictionary = parameterValue as IDictionary <T, U>; if (parameterDictionary == null) { return(new KeyValuePair <string, string>[] { }); } var innerParseResult = parameterDictionary.SelectMany(parameterPair => { var key = parameterPair.Key.ToString(); var parsedItems = ParametersParser.ParseValue(parameterPair.Value); return(parsedItems.Select(item => new KeyValuePair <string, string>(string.Format("[{0}]{1}", key, item.Key), item.Value))); }); return(innerParseResult); }
//--------------------------------------------------------------------- public override void Initialize(string dataFile, PlugIns.ICore modelCore) { this.modelCore = modelCore; ParametersParser.SpeciesDataset = modelCore.Species; ParametersParser parser = new ParametersParser(); IParameters parameters = Data.Load<IParameters>(dataFile, parser); Timestep = parameters.Timestep; mapNameTemplate = parameters.MapNames; selectedSpecies = parameters.SelectedSpecies; cohorts = modelCore.SuccessionCohorts as ILandscapeCohorts; if (cohorts == null) throw new ApplicationException("Error: Cohorts don't support age-cohort interface"); }
public override Verb CreateVerb(string[] tokens) { Color(position, tokens[1].Length, KeyWords); var macroName = tokens[2]; Color(macroName.Length, Variables); Color(tokens[3].Length, Structures); var parametersParser = new ParametersParser(); if (parametersParser.Parse(source, NextPosition).If(out var parameters, out var index) && bodyParser.Parse(source, index).If(out var block, out var newIndex)) { var parameterBlock = new ParameterBlock(parameters, block, parameters.Splatting); overridePosition = newIndex; return(new CreateMacro(macroName, parameterBlock)); } return(null); }
//--------------------------------------------------------------------- /// <summary> /// Initializes the module. /// </summary> /// <param name="parameterUpdates"> /// The list of parameter updates. The year and the file for each /// update has been specified. /// </param> /// <remarks> /// The file for each update is parsed for the set of biomass /// parameters. /// </remarks> public static void Initialize(List<ParametersUpdate> parameterUpdates) { Module.parameterUpdates = parameterUpdates; if (parameterUpdates.Count > 0) { PlugIn.ModelCore.UI.WriteLine(" Loading biomass parameters for climate change:"); ParametersParser parser = new ParametersParser(); foreach (ParametersUpdate update in parameterUpdates) { update.LoadParameters(parser); PlugIn.ModelCore.UI.WriteLine(" Read parameters for year {0} from file \"{1}\"", update.Year, update.File); } indexOfNextUpdate = 0; nextUpdate = parameterUpdates[indexOfNextUpdate]; } else { nextUpdate = null; } }
//--------------------------------------------------------------------- /// <summary> /// Initializes the component with a data file. /// </summary> /// <param name="dataFile"> /// Path to the file with initialization data. /// </param> /// <param name="startTime"> /// Initial timestep (year): the timestep that will be passed to the /// first call to the component's Run method. /// </param> public override void Initialize(string dataFile, PlugIns.ICore modelCore) { this.modelCore = modelCore; ParametersParser.SpeciesDataset = modelCore.Species; ParametersParser parser = new ParametersParser(); IParameters parameters = Data.Load<IParameters>(dataFile, parser); Timestep = parameters.Timestep; //this.nextTimeToRun = startTime - 1; this.mapNameTemplate = parameters.MapFileNames; this.mapDefs = parameters.ReclassMaps; cohorts = modelCore.SuccessionCohorts as ILandscapeCohorts; if (cohorts == null) throw new ApplicationException("Error: Cohorts don't support biomass interface"); }
//--------------------------------------------------------------------- public override void Initialize(string dataFile, PlugIns.ICore modelCore) { Model.Core = modelCore; SiteVars.Initialize(); ParametersParser parser = new ParametersParser(Model.Core.Species, Model.Core.StartTime, Model.Core.EndTime); IParameters parameters = Landis.Data.Load<IParameters>(dataFile, parser); if (parser.RoundedRepeatIntervals.Count > 0) { UI.WriteLine("NOTE: The following repeat intervals were rounded up to"); UI.WriteLine(" ensure they were multiples of the harvest timestep:"); UI.WriteLine(" File: {0}", dataFile); foreach (RoundedInterval interval in parser.RoundedRepeatIntervals) UI.WriteLine(" At line {0}, the interval {1} rounded up to {2}", interval.LineNumber, interval.Original, interval.Adjusted); } Timestep = parameters.Timestep; managementAreas = parameters.ManagementAreas; UI.WriteLine("Reading management-area map {0} ...", parameters.ManagementAreaMap); ManagementAreas.ReadMap(parameters.ManagementAreaMap, managementAreas); UI.WriteLine("Reading stand map {0} ...", parameters.StandMap); Stands.ReadMap(parameters.StandMap); foreach (ManagementArea mgmtArea in managementAreas) mgmtArea.FinishInitialization(); prescriptionMaps = new PrescriptionMaps(parameters.PrescriptionMapNames); UI.WriteLine("Opening harvest log file \"{0}\" ...", parameters.EventLog); log = Data.CreateTextFile(parameters.EventLog); log.AutoFlush = true; log.WriteLine("Time,Stand,Total Sites,Damaged Sites,Cohorts Killed"); }
private dynamic CreateDataSourceViewModel(IRequestHandler requestHandler, DataSource dataSource) { IDataSource dataSourceInstance = StringActivator.CreateInstance <IDataSource>(dataSource.CSharpClassName); if (dataSourceInstance is ISingleObjectDataSource) { return((dataSourceInstance as ISingleObjectDataSource).GetSerializedObject( requestHandler, ParametersParser.Parse(dataSource.Parameters) )); } if (dataSourceInstance is IMultipleObjectsDataSource) { return((dataSourceInstance as IMultipleObjectsDataSource).GetSerializedObjects( requestHandler, ParametersParser.Parse(dataSource.Parameters) )); } return(null); }
public static void Main(string[] args) { var config = new LoaderConfiguration(); var loader = new Loader(config, new StatusOutput()); try { Task.Run(() => { /** * Implicitly detect the HCE executable and start it without any parameters. */ if (args.Length == 0) { loader.Start(ExecutableFactory.Detect()); return; } /** * The parameters are expected to be the HCE ones, e.g. `-window`, `-safemode`, etc. * This effectively makes the SPV3 Loader a wrapper around the HCE executable. */ var parameters = new ParametersParser().Parse(string.Join(" ", args)); /** * This allows explicit declaration of the path which the HCE executable resides in. * If the path isn't declared, then we implicitly attempt to detect the executable. */ var executable = args[0].Contains(Executable.Name) ? new Executable(args[0]) : ExecutableFactory.Detect(); loader.Start(executable, parameters); }).GetAwaiter().GetResult(); } catch (SecurityException e) { Console.WriteLine(e.ToString()); Environment.Exit(1); } }
//--------------------------------------------------------------------- public override void Initialize(string dataFile, PlugIns.ICore modelCore) { Model.Core = modelCore; ParametersParser parser = new ParametersParser(Model.Core.Ecoregions, Model.Core.Species); IParameters parameters = Landis.Data.Load<IParameters>(dataFile, parser); Timestep = parameters.Timestep; // Cohorts must be created before the base class is initialized // because the base class' reproduction module uses the core's // SuccessionCohorts property in its Initialization method. Biomass.Cohorts.Initialize(Timestep, new CohortBiomass()); cohorts = Model.Core.Landscape.NewSiteVar<SiteCohorts>(); landscapeCohorts = new LandscapeCohorts(cohorts); Cohorts = landscapeCohorts; InitialBiomass.Initialize(Timestep); Dead.Pools.Initialize(modelCore, parameters.WoodyDecayRate, parameters.LeafLitterDecayRate); double[,] estabProbabilities = new double[Model.Core.Ecoregions.Count, Model.Core.Species.Count]; foreach (ISpecies species in Model.Core.Species) { foreach (IEcoregion ecoregion in Model.Core.Ecoregions) { estabProbabilities[ecoregion.Index, species.Index] = parameters.EstablishProbability[species][ecoregion]; } } base.Initialize(modelCore, estabProbabilities, parameters.SeedAlgorithm, AddNewCohort); LivingBiomass.Initialize(parameters, cohorts); Cohort.DeathEvent += CohortDied; AgeOnlyDisturbances.Module.Initialize(parameters.AgeOnlyDisturbanceParms); }
//--------------------------------------------------------------------- public override void Initialize(string dataFile, PlugIns.ICore modelCore) { Model.Core = modelCore; ParametersParser parser = new ParametersParser(Model.Core.Ecoregions, Model.Core.Species, Model.Core.StartTime, Model.Core.EndTime); IParameters parameters = Landis.Data.Load<IParameters>(dataFile, parser); Timestep = parameters.Timestep; // Cohorts must be created before the base class is initialized // because the base class' reproduction module uses the core's // SuccessionCohorts property in its Initialization method. Biomass.Cohorts.Initialize(Timestep, new CohortBiomass()); cohorts = Model.Core.Landscape.NewSiteVar<SiteCohorts>(); landscapeCohorts = new LandscapeCohorts(cohorts); Cohorts = landscapeCohorts; InitialBiomass.Initialize(Timestep); Dead.Pools.Initialize(modelCore, parameters.WoodyDecayRate, parameters.LeafLitterDecayRate); base.Initialize(modelCore, Util.ToArray<double>(parameters.EstablishProbability), parameters.SeedAlgorithm, (Reproduction.Delegates.AddNewCohort) AddNewCohort); LivingBiomass.Initialize(parameters, cohorts); Cohort.DeathEvent += CohortDied; AgeOnlyDisturbances.Module.Initialize(parameters.AgeOnlyDisturbanceParms); ClimateChange.Module.Initialize(parameters.ClimateChangeUpdates); }
//--------------------------------------------------------------------- public override void Initialize(string dataFile, PlugIns.ICore modelCore) { Model.Core = modelCore; SiteVars.Initialize(); ParametersParser parser = new ParametersParser(Model.Core.StartTime, Model.Core.EndTime); IParameters parameters = Landis.Data.Load<IParameters>(dataFile, parser); Timestep = parameters.Timestep; managementAreas = parameters.ManagementAreas; UI.WriteLine("Reading management-area map {0} ...", parameters.ManagementAreaMap); ManagementAreas.ReadMap(parameters.ManagementAreaMap, managementAreas); UI.WriteLine("Reading stand map {0} ...", parameters.StandMap); Stands.ReadMap(parameters.StandMap); foreach (ManagementArea mgmtArea in managementAreas) mgmtArea.FinishInitialization(); }
//--------------------------------------------------------------------- public override void Initialize(string dataFile, PlugIns.ICore modelCore) { Model.Core = modelCore; ParametersParser parser = new ParametersParser(); IParameters parameters = Landis.Data.Load<IParameters>(dataFile, parser); Timestep = parameters.Timestep; // Cohorts must be created before the base class is initialized // because the base class' reproduction module uses the core's // SuccessionCohorts property in its Initialization method. cohorts = modelCore.Landscape.NewSiteVar<SiteCohorts>(); landscapeCohorts = new LandscapeCohorts(cohorts); Cohorts = landscapeCohorts; Cohort.DeathEvent += CohortDied; base.Initialize(modelCore, parameters.EstablishProbabilities, parameters.SeedAlgorithm, AddNewCohort); }
//--------------------------------------------------------------------- public override void Initialize(string dataFile, PlugIns.ICore modelCore) { this.modelCore = modelCore; ParametersParser.SpeciesDataset = modelCore.Species; ParametersParser parser = new ParametersParser(); IParameters parameters = Data.Load<IParameters>(dataFile,parser); if (parameters==null) throw new ApplicationException("Error: Missing required parameters. Check the input parameter file"); Timestep = parameters.Timestep; sppagestats_mapNames = parameters.SppAgeStats_MapNames; siteagestats_mapNames = parameters.SiteAgeStats_MapNames; sitesppstats_mapNames = parameters.SiteSppStats_MapNames; ageStatSpecies = parameters.AgeStatSpecies; siteAgeStats = parameters.SiteAgeStats; siteSppStats = parameters.SiteSppStats; cohorts = modelCore.SuccessionCohorts as ILandscapeCohorts; if (cohorts == null) throw new ApplicationException("Error: Cohorts don't support age-cohort interface"); }
//--------------------------------------------------------------------- public override void Initialize(string dataFile, PlugIns.ICore modelCore) { Model.Core = modelCore; ParametersParser parser = new ParametersParser(Model.Core.Ecoregions, Model.Core.Species, Model.Core.StartTime, Model.Core.EndTime); IParameters parameters = Landis.Data.Load<IParameters>(dataFile, parser); Timestep = parameters.Timestep; sufficientLight = parameters.LightClassProbabilities; SiteVars.Initialize(); SpeciesData.Initialize(parameters); EcoregionData.Initialize(parameters); CalibrateMode = parameters.CalibrateMode; CohortBiomass.SpinupMortalityFraction = parameters.SpinupMortalityFraction; // Cohorts must be created before the base class is initialized // because the base class' reproduction module uses the core's // SuccessionCohorts property in its Initialization method. Biomass.Cohorts.Initialize(Timestep, new CohortBiomass()); //cohorts = SiteVars.Cohorts; landscapeCohorts = new LandscapeCohorts(SiteVars.Cohorts); Cohorts = landscapeCohorts; Reproduction.SufficientLight = SufficientLight; InitialBiomass.Initialize(Timestep); base.Initialize(modelCore, Util.ToArray<double>(parameters.EstablishProbability), parameters.SeedAlgorithm, (Reproduction.Delegates.AddNewCohort) AddNewCohort); Cohort.DeathEvent += CohortDied; AgeOnlyDisturbances.Module.Initialize(parameters.AgeOnlyDisturbanceParms); ClimateChange.Module.Initialize(parameters.ClimateChangeUpdates); }
private void HandleArguments() { var pp = new ParametersParser(false); if (pp.HasKey("/update")) Updater.DoUpdate(); else if (pp.HasKey("/firstmonitor")) { ScreenHelper.MoveToDefaultScreen(this); var pid = Process.GetCurrentProcess().Id; var others = from i in Process.GetProcesses() where i.Id != pid && i.ProcessName.Contains("ECalc") select i; foreach (var process in others) process.CloseMainWindow(); } }
public void Init() { parser = new ParametersParser(Data.EcoregionDataset, Data.SpeciesDataset, startYear, endYear); }
public void Init() { parser = new ParametersParser(Data.EcoregionDataset, Data.SpeciesDataset); }
public void SetUp() { _target = new ParametersParser(); }
//--------------------------------------------------------------------- public override void Initialize(string dataFile, PlugIns.ICore modelCore) { Model.Core = modelCore; ParametersParser parser = new ParametersParser(Model.Core.Ecoregions, Model.Core.Species, Model.Core.StartTime, Model.Core.EndTime); IParameters parameters = Landis.Data.Load<IParameters>(dataFile, parser); Timestep = parameters.Timestep; sufficientLight = parameters.LightClassProbabilities; CohortBiomass.SpinupMortalityFraction = parameters.SpinupMortalityFraction; SiteVars.Initialize(); // Initialize climate. A list of ecoregion indices is passed so that // the climate library can operate independently of the LANDIS-II core. List<int> ecoregionIndices = new List<int>(); foreach(IEcoregion ecoregion in Model.Core.Ecoregions) { ecoregionIndices.Add(ecoregion.Index); UI.WriteLine(" Century: preparing climate data: {0} = ecoregion index {1}", ecoregion.Name, ecoregion.Index); } Climate.Initialize(parameters.ClimateFile, ecoregionIndices, false); EcoregionData.Initialize(parameters); SpeciesData.Initialize(parameters); EcoregionData.ChangeParameters(parameters); OtherData.Initialize(parameters); FunctionalType.Initialize(parameters); Outputs.Initialize(parameters); Outputs.InitializeMonthly(parameters); // Cohorts must be created before the base class is initialized // because the base class' reproduction module uses the core's // SuccessionCohorts property in its Initialization method. Biomass.Cohorts.Initialize(Timestep, new CohortBiomass()); //cohorts = Model.Core.Landscape.NewSiteVar<SiteCohorts>(); landscapeCohorts = new LandscapeCohorts(SiteVars.SiteCohorts); //cohorts); Cohorts = landscapeCohorts; Reproduction.SufficientLight = SufficientLight; InitialBiomass.Initialize(Timestep); base.Initialize(modelCore, Util.ToArray<double>(SpeciesData.EstablishProbability), parameters.SeedAlgorithm, (Reproduction.Delegates.AddNewCohort) AddNewCohort); Cohort.DeathEvent += CohortDied; AgeOnlyDisturbances.Module.Initialize(parameters.AgeOnlyDisturbanceParms); Dynamic.Module.Initialize(parameters.DynamicUpdates); //EcoregionData.Initialize(parameters); FireEffects.Initialize(parameters); }