All Classes and Interfaces
Class
Description
Thrown to abort a single simulation on purpose (e.g.
Base class of readers for fixed-width ASCII files: the lines between
startRow and
endRow (every step-th line, empty lines skipped) are passed to
AbstractAsciiReader.processLineOfFile(String, String, int).Base class of readers that read tabular data according to an XML configuration: each child element of the
configuration defines a column (
ColumnData); attribute values may contain parameters of the observable.Base class of readers that take their data from an object (list or map) instead of a file.
Methods for calculating the agreement index
See D.
Methods for calculating the bias/mean error
See D.
Output adapter for the memory interface: stores the output lines of each simulation in a
FWSimResultCache
for later use in the application (charts, calibration, wrapper).Maintenance tool that migrates all solution files (
*.sol.xml) below the workspace directory
(../../) and writes them back.Scans the class path for classes and resources.
Definition of one column of a data reader: the character range in a fixed-width line (1-based
startCol..endCol) or a constant value, name and data type.Prepares the doc comments of a Java source file for the standard javadoc tool:
wiki blocks (
the result of
CommentPreprocessor.process(String, String, String)Creates the documentation page of a single SimComponent or resource transformer at runtime, e.g.
Methods for calculating the concordance correlation coefficient
See D.
Simple implementation of a JDBC connection pool manager (singleton).
Methods for calculating the correlation coefficient
See D.
Interface for CSV files, used for resources and outputs.
How array values are stored in the file.
Output adapter writing the output of an
FWSimOutput to a CSV file (CSVInterface).Resource adapter for CSV files (
CSVInterface).Content of a CSV file (or CSV content string), split into lines and columns.
Conversion of one cell from its string to the value of the column's data type.
Provides static helper methods for database operations, such as copying a table between two connections and reading
a query result into memory.
Interface for databases via JDBC, used for resources and outputs.
Output adapter writing the output of an
FWSimOutput to a database table (DatabaseInterface).Resource adapter for databases (
DatabaseInterface).Delivers data to wrapper clients (R, Python, ...) as simple types: parallel arrays of column names, units, data
type names and values.
Converts result objects (e.g.
Interface for DBF files (and the attribute tables of shape files), read via the DbSchema DBF JDBC driver.
Resource adapter for DBF files and the attribute tables of shape files (
DBFInterface).Custom checker that accepts everything: all checks pass and values are returned unchanged.
Management component: sets management variables (content type
mgm) when the rule of an action is true.Transforms the cache of a source resource line by line with rules: for each data line of the source, the values are
set to the source variables in a copy of the variable map, and each header variable of the transformer is
calculated by its rule (or copied from the source column of the same name if it has no rule).
Default statistic: the mode names an error calculation method of
ErrorCalculationFactory (e.g.Generator that generates no additional simulations: the simulations of a
FWSimProject.PROJECT_MODE.SIMULATION run come
directly from the project data (XML or resource), and without project file a single simulation of the solution is
run.Default iterator: runs the first iteration, and further iterations as long as the constraint is fulfilled, up to
maxCount iterations.Transforms resource data with an SQL statement (child
statement, may contain ${...}
tokens) on the tables of the resources cached in the database (see dbcache).Creates the javadoc of SIMPLACE source trees with the documentation of the SimComponents and resource transformers,
independently of a build tool (console, HPC, Eclipse launch configuration, ant, Maven, ...).
Build step: writes the class comments of the SimComponents and resource transformers of a source tree as resources
<SimpleName>.simdoc next to the compiled classes, so that the documentation page can be created
at runtime from a jar (see ComponentDocPage).Entity resolver that loads DTD and entity files from the class path instead of the network.
Request and response objects (DTOs) of the REST API, collected in one place.
POST /api/sessions/{id}/simulations
Error response of all endpoints
Response to POST /api/sessions/{id}/run - the call returns immediately
Response to GET /api/sessions/{id}/jobs/{jobId}
POST /api/sessions
POST /api/sessions/{id}/run
Response to POST /api/sessions
Response to POST /api/sessions/{id}/simulations
POST /api/sessions/{id}/step
Thrown if an element (e.g.
Methods for calculating the model efficiency
See D.
Perform email validations.
Process-wide lock for all calls into the engine by servers that use
SimplaceWrapper from several
threads (REST wrapper net.simplace.sim.wrapper.rest, web client net.simplace.sim.wrapper.web).Creates equidistant parameter values within a range.
Creates the error calculation method for the label given by the user (e.g.
Labels of the error calculation methods.
Base class of the error calculation methods (goodness-of-fit measures) used by the selectors
(e.g.
ExecutionException is thrown if an error occurs while executing or reading a file.
One file (or a string with file content) used by a file interface.
Opens files, URLs and e-mails in external applications and runs executables and scripts.
Thrown if a file has a wrong format, e.g.
Base class of the file based interfaces.
Singleton manager for temporary and cache directories.
Pool of the files of a file interface.
Static registry of the opened files per session, so that a file used by several adapters is opened only once and
its data can be shared (see
FilePoolManager.getFile(FileData)).Component that outputs the runtime statistics (process times) of the other components, e.g.
Observer of a
FWObservable that shows that the observable is busy while it notifies its observers, e.g.Base class of custom checkers for check level CUSTOM:
FWCheckHelper delegates its checks to an instance of
the class given in the solution (attribute class).Checks the setting of values (limits, owning component, write protection) and the configuration according to the
check level of the session (see
FWCheckHelper.CHECK_LEVEL).Check levels.
How violations of the runtime checks are reported.
Access of the core (simulation, services) to the client that runs it: the layout
settings and the interaction with the user.
A date with a data precision pattern (how precise the date is, derived from the parsed string) and a
visualisation pattern (how it is shown).
some final parameters for Pattern
FWFormattedDate represents a date value at a fixed precision.
This is an enumeration of precisions that are supported by FWFormattedDate.
Factory methods creating JDOM elements of form components (form XML) for generated forms.
Static helper methods of the framework, mainly for parameter maps: reading typed parameters, processing templates
and localizing form component values.
Provider for properties.
Parameter map of a functionality (form) that notifies registered observers (form components) when a parameter
changes.
A class can implement the
Observer interface when it
wants to be informed of changes in observable objects.Source of the parameter values for
FWParameterResolver: the values of the pipeline map (GUI, pipelines,
data readers) or of a simulation variable map, plus the special parameters, which are the same for all sources.Resolves parameters: replaces the placeholders
${name} of texts and evaluates JEXL expressions.A named property set (key to value), stored as XML element
properties.Provider for properties.
Reads values of static fields by reflection, used for
${STATIC:...} parameters.Global registry of the runtime statistics (
ProcessTime) of all components and adapters, by name.Base class of the in-memory data caches.
Output used for calibration runs: collects the values of the given variables in project mode CALIBRATION.
A variable that is varied by a generator, e.g.
Base class of all SimComponents - the smallest unit of a model, containing the algorithms of the scientific model.
Phases of a component unit test.
Code generator for SimComponents: creates the Java source of a
FWSimComponent from the template
codegen/FWSimComponent.javatemplate (class path) and a component definition.A SimComponent composed of several SimComponents.
Code generator for component groups: creates the Java class of a
FWSimComponentGroup and its group
configuration file (.grp.xml) from an AMEI-style model composition (description plus input, internal and
output links).Command line interface of SIMPLACE.
Dependency table of a solution: one
FWSimDataset per use of a variable (which component or setting uses
which variable, and in which role).One entry of the dependency table
FWSimDataframe: a component (root) uses a variable (bind) in a certain
role (category).Entry point of the simulation engine (singleton).
An object that owns simulation variables in a field map, e.g.
Combines several field containers (usually SimComponents) into one group that behaves like a single container, e.g.
Static helper methods for simulations: converting values and arrays, handling project data files and simulation
ids, and more.
Base class of the adapters that only read input data: resources (
resource element, reading from an
interface) and transformers (transform element, deriving data from another resource).Thrown if an instance of a SimComponent could not be created.
Base class of the interfaces (
interface elements of the solution).identifiers for different interface types
Base class of the resource adapters, transformers and output adapters.
Frequency with which the data is read (resources) or written (outputs).
A management component executes actions depending on rules: each
action has a rule and a list of
mgm variables that are set when the rule is true (see FWSimVariable.MODE_TYPE RESET, SET, ITE).Migrates solution and project files of older SIMPLACE versions to the current version
(
FWConstants.SOLUTION_VERSION).A model run of one simulation: holds the SimComponents of the solution and the var map of the simulation, and runs
the simulation day by day.
An output of the solution (
output element).Base class of the adapters that write output data to an interface (database, CSV, memory, NetCDF).
Aggregation cache of one output for one simulation.
Output event, created on each output call of a simulation step (and for calibration results).
Listener that is called on each output call of a simulation step; registered at the output manager of the session.
Manages the outputs of a session (one instance per session).
SimComponent defined completely in the solution, without own Java class: the children of
process (and
optionally integrate) are output variables whose values are calculated by their rules (JEXL) in each
step (resp.Generates the Java source of a SimComponent from a
FWSimpleSimComponent of a solution (Redmine #61), so a
component that was prototyped with JEXL rules in the solution can be turned into a compiled class.Result of the generation.
Post-processing of a session: after the run, the CSV output files are loaded into a temporary in-memory database
(H2), SQL statements summarize them, and query results are written to files.
A project is an ensemble of simulation runs that share the solution and its resources (e.g.
Modes of a project, see the class description.
One output line: the values by column name in column order (
LinkedHashMap), plus the simulation id and the
simulation date the line belongs to.Resource adapters read data from an interface (
FWSimInterface) into a FWSimResourceCache.An alias (
alias element) makes the data of another resource (attribute resource)
available under a second id.Cache of the data read by a resource adapter or transformer.
Manages the resources of a session (one instance per session).
Base class of the resource transformers (
transform element).Cache of output lines in memory, keyed by the date of the line.
A session is one run of a solution with its projects.
Mode the application runs in.
Calibration mode of a session run, taken from the control cache.
A simulation is one configured run of the simulation model.
A solution is the configuration of a simulation read from a solution file (
.sol.xml, grammar
SimSolution.dtd).Holds the statistics (
stat elements) of an output and collects, per simulation, the output columns
they need (observed and simulated values) in a result cache.A statistic of an output that compares simulated with observed values, e.g.
Base class of synchronisation adapters for synchronized projects: when all simulations of a synchronized project
wait,
FWSimSyncManager.sync(Map) is called with their variable maps, so the adapters can exchange data
between the simulations.Holds the synchronisation adapters (
FWSimSyncAdapter) of a session.State of a project run (one instance per session): the project ids, the current project and iteration, the
simulation counters and progress, the calibration mode, the selected simulations and the control variable map
(a copy of the solution variable map used by generators, iterators and selectors).
Base class of the components that control a project run: generators (
FWSimulationGenerator, create the
simulations of a project, e.g.Reads the project file (
.proj.xml) and controls the project run of a session.Event for errors in a simulation or project; in addition to
FWSimulationEvent it contains the exception.Event of a session run, passed to the
FWSimulationListeners: start and end of a simulation (source
FWSimModel), end of a project (source FWSimProject) or end of an iteration (source
FWSimulationControlCache), with the progress in percent.Base class of the simulation generators: a generator creates the simulations (
FWSimSimulation) of a project
(FWSimProject).Base class of the iterators of a calibration: an iterator decides whether another iteration (generate, simulate,
select) is run.
Listener for the events of a session run (registered at the session): start and end of simulations, errors, end of
projects and iterations.
Base class of the selectors of a calibration: a selector selects the best simulations of an iteration by
implementing
FWSimulationSelector.select(ResultSet).A value object groups variables of a large SimComponent to structure its data.
A typed simulation variable.
The content type describes the role of a variable, e.g.
Data types of variable values.
Formats and parses dates either with a pattern or as number of days since 1970 (
EPOCH_DAY).The mode defines how values of an output variable are aggregated if the output frequency is not daily, and how
management variables are applied (RESET, SET, ITE).
Finer categorisation of variables than
FWSimVariable.CONTENT_TYPE, used to group variables in lists (e.g.A link from a source variable to a destination variable, or a fixed value for a destination variable.
The variable map of a simulation: holds all
FWSimVariables of a simulation, keyed by name, together with the
system variables (current date, year, day of year, project and simulation id, spin-up settings, ...).Reads a fixed-width or separated ASCII file (see
AbstractAsciiReader) into a database table; the table is
created from the column definitions if it does not exist.Writes a list or map of values (see
AbstractListReader) as one row into a database table; the table is
created from the column definitions if it does not exist.A SimComponent that needs an integration step after all components have been processed in a time step, e.g.
Static helper methods for file and stream I/O: file names, copying and deleting files and directories, reading and
writing text, CSV and serialised objects, URLs and SMB network shares.
Helper class to determine the operating system the JVM runs on.
Types of operating systems.
SimplaceWrapper for Java clients that step the first simulation of the queue directly and access its
variables as FWSimVariable objects instead of DataContainers.Array functions for JEXL rules (namespace
array:), used likeJEXL builder for SIMPLACE rules: allows all classes (empty permissions) and registers the namespaces
array (JexlArrayBuilder), transform (JexlUnitTransform),
math (StrictMath), check (JexlChecker) and file
(JexlFile).Check functions for JEXL rules (namespace
check:).File functions for JEXL rules and expressions (namespace
file:), e.g.Creates
JexlRuleScripts with the shared SIMPLACE JEXL engine.A rule of a solution (e.g.
How a rule is evaluated.
Checks a rule of a solution without evaluating it, e.g.
Result of a check.
Unit transformation functions for JEXL rules (namespace
transform:).Manages asynchronously running jobs (currently only /run) across all sessions.
Thrown if a job id is unknown (mapped to HTTP 404 by RestServer).
A consumer that may throw checked exceptions.
Maps FWSimulationListener events to the progress of a RestJob.
Wrapper around a Jackson
JsonNode holding either a JSON array or a JSON object.Interface for JSON data, used for resources.
Resource adapter for JSON data (
JSONInterface, e.g.Some workarounds needed by the Julia language scripts to access SimplaceWrapper
Selects the simulation from a project, which fits best to some error method:
Example implementation of a simple selector.
Converts CSV data to a binary little-endian file and back.
Input stream that reads primitive values in little-endian byte order (counterpart of
LittleEndianOutputStream).Output stream that writes primitive values in little-endian byte order and counts the written bytes.
Singleton resource manager for localized strings, read from resource bundles on the class path (e.g.
Static facade for logging with log4j.
Log levels in ascending severity.
Methods for calculating the mean absolute error
See D.
Reads a fixed-width ASCII file into a map: key
rowHead_columnName, value the string of the column.Parameter context of a parameter map (GUI, pipelines, data readers) for
FWParameterResolver: tokens are replaced by
the map values (dates as date and time, an existing empty value by an empty text), expressions get the values
themselves (texts that are numbers as numbers).Static helper methods for aggregating lists of numbers (MIN, MAX, AVG, SUM, COUNT), element-wise array arithmetic,
Gauss-Legendre integration and linear regression.
Some workarounds needed by the Matlab scripts to access SimplaceWrapper
Interface for outputs kept in memory, the fastest way for output that does not have to be written to a file
(e.g.
Thrown if a resource transformer is configured wrongly (e.g.
Thrown if a resource (or interface) cannot be found or read, or its key is wrong.
Methods for calculating the mean relative error
See D.
Methods for calculating the mean squared error
See D.
A map that can hold several values per key.
Interface for NetCDF files, used for resources and outputs.
Output adapter writing the output of an
FWSimOutput to a NetCDF-3 file (NetCDFInterface).Resource adapter for NetCDF files (
NetCDFInterface).Network helper methods, e.g.
This class acts as a factory for unique object identifiers.
An Ontology at present used in SMILE model is to resolve the ambiguity related to the units
in the model.
The OM vocabulary, expressed for the SPI layer in terms of .graph Nodes.
Access to the OM ontology (Ontology of units of Measure, version 1.8), used to resolve unit URIs of variables
into names, symbols and descriptions.
Converts parameters from the JSON representation of the REST API into the form expected by
SimplaceWrapper.
Runtime statistics of a component or adapter: sum, maximum and count of the measured processing times in
milliseconds.
State of an asynchronously running /run call.
Life cycle states of a job.
REST wrapper around net.simplace.sim.wrapper.SimplaceWrapper.
Methods for calculating the relative mean absolute error
See D.
Methods for calculating the root mean squared error
See D.
Methods for calculating the relative root mean squared error
See D.
Wraps a
SimplaceWrapper instance for exactly one REST session.Holds all open sessions in memory.
Thrown if a session id is unknown (mapped to HTTP 404 by RestServer).
Iterator that shrinks the parameter space, i.
Methods for calculating the bias/mean error and comparing signed values.
Edge of the solution graph between two field containers, holding the variable links between them.
Thrown if a variable (SimField, SimVariable) cannot be found or its key is wrong.
Thrown if the type of a variable does not match the list of valid types.
Thrown if a link cannot be established because the source or target is not valid or the key is wrong; also used by
the checker for forbidden write access.
API to use the SIMPLACE engine from other applications and languages (R, Python, Julia, Matlab, Java; see
JavaSimplaceWrapper and the language specific wrappers simplace for R and Python).Deprecated.
not used
Thrown if an error occurs in the creation or use of project data.
Thrown if a new value of a variable exceeds its minimum or maximum (check level STRICT).
Link from a source variable to a destination variable, or a fixed value for a destination variable.
Parameter context of a simulation variable map for
FWParameterResolver: placeholders are replaced by the
variable values (dates as date and time, arrays as {v1,v2,...}), expressions get the variable values
themselves (e.g.Methods for calculating the symmetric mean absolute percentage error
See Wikipedia
Static helper methods for string manipulation, parsing and formatting.
Unicode constants for special characters (mainly German umlauts).
Static helper methods for GZIP compression and TAR archives (based on Apache Commons Compress).
Creates the HTML table of the variables of a SimComponent or resource transformer, as shown in the documentation
(sortable, one row per variable, private variables omitted).
Error calculator that calculates nothing: the value is always 0 and every value counts as better.
Settings of the web client, read from its properties file (web.properties, see web.properties.template next to
WebServer).Routes of the web client (started by
WebServer): runs a solution (optionally with a project) from the
browser, shows progress and log while it runs, shows the CSV outputs as diagrams and offers the output files
written by the run for download.Web client of SIMPLACE: a server of its own (Javalin, own port) that offers a browser page to run a solution,
optionally with a project, a project table or a sensitivity analysis, to follow progress and log, to look at the
CSV outputs as diagrams and to download them (see
WebInterface).Selects the simulation with the best error/deviation for multiple
target variables.
Converts the TracWiki markup of documentation texts to HTML.
Helper methods for XML operations based on JDOM2: parsing, serialising, reading attributes and XPath queries.
Interface for XML files; currently only used for resources.
Resource adapter for XML files (
XMLInterface).Static helper methods for creating, reading, extending and unpacking ZIP archives.