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