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 (
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 like
JEXL 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.