Class DexpiXmlReader

java.lang.Object

neqsim.process.processmodel.dexpi.DexpiXmlReader

public final class DexpiXmlReader
extends Object

Utility for reading DEXPI XML files and converting them into NeqSim process models.

This reader recognises major equipment such as pumps, heat exchangers, tanks and control valves as well as complex reactors, compressors and inline analysers. Piping segments are imported as runnable DexpiStream units tagged with the source line number.

Version:

1.0

Author:

NeqSim

See Also:

• DEXPI Standard

Field Summary

Fields

Modifier and Type	Field	Description
private static final Map<String, EquipmentEnum>	EQUIPMENT_CLASS_MAP
private static final org.apache.logging.log4j.Logger	logger
private static final Map<String, EquipmentEnum>	PIPING_COMPONENT_MAP

Constructor Summary

Constructors

Modifier	Constructor	Description
private	DexpiXmlReader()

Method Summary

Modifier and Type	Method	Description
private static void	addDexpiStream(ProcessSystem processSystem, Element element, Stream templateStream, String baseName)
private static void	addDexpiUnit(ProcessSystem processSystem, Element element, EquipmentEnum equipmentEnum, String baseName, String componentClass)
private static void	addPipingSegments(Document document, ProcessSystem processSystem, Stream templateStream)
private static void	addUnits(Document document, ProcessSystem processSystem, String tagName, Map<String, EquipmentEnum> equipmentMap, String nameAttribute)
private static void	applyNumericAttribute(Element element, String valueAttribute, String unitAttribute, BiConsumer<Double,String> consumer, String defaultUnit)
private static void	applyStreamMetadata(Element element, DexpiStream stream)
private static String	attributeValue(Element element, String attributeName)
private static SystemInterface	createDefaultFluid()
private static Stream	createDefaultTemplateStream()
private static List<Element>	directChildElements(Element element, String tagName)
private static String	ensureUniqueName(ProcessSystem processSystem, String candidate)
private static String	findAttributeInAncestors(Node node, String attributeName)
private static String	firstNonEmpty(String... candidates)
private static String	getGenericAttribute(Element element, String attributeName)
private static boolean	isBlank(String value)
private static boolean	isInsideShapeCatalogue(Node node)	Checks whether the given node is inside a ShapeCatalogue element.
static void	load(File file, ProcessSystem processSystem)	Populates an existing ProcessSystem with units parsed from a DEXPI XML file.
static void	load(File file, ProcessSystem processSystem, Stream templateStream)	Populates an existing ProcessSystem with units parsed from a DEXPI XML file.
static void	load(InputStream inputStream, ProcessSystem processSystem)	Populates an existing ProcessSystem with units parsed from a DEXPI XML stream.
static void	load(InputStream inputStream, ProcessSystem processSystem, Stream templateStream)	Populates an existing ProcessSystem with units parsed from a DEXPI XML stream.
static void	load(InputStream inputStream, ProcessSystem processSystem, Stream templateStream, boolean namespaceAware)	Populates an existing ProcessSystem with units parsed from a DEXPI XML stream.
private static Document	parseDocument(InputStream inputStream, boolean nsAware)
private static List<DexpiInstrumentInfo>	parseInstruments(Document document)	Parses all ProcessInstrumentationFunction elements from the document, resolving loop and actuator associations.
(package private) static List<DexpiInstrumentInfo>	parseInstrumentsFromDocument(Document document)	Parses instruments from an already-parsed DEXPI XML Document.
private static Double	parseNumeric(String valueText)
private static String	prependLineOrFluid(Element element, String baseName)
static ProcessSystem	read(File file)	Reads the provided DEXPI XML file and returns a populated ProcessSystem.
static ProcessSystem	read(File file, Stream templateStream)	Reads the provided DEXPI XML file and returns a populated ProcessSystem using a template Stream for generated piping segments.
static ProcessSystem	read(InputStream inputStream)	Reads the provided DEXPI XML stream and returns a populated ProcessSystem.
static ProcessSystem	read(InputStream inputStream, Stream templateStream)	Reads the provided DEXPI XML stream and returns a populated ProcessSystem using a template Stream for any generated piping segments.
static List<DexpiInstrumentInfo>	readInstruments(File file)	Reads instrument metadata from a DEXPI XML file.
static List<DexpiInstrumentInfo>	readInstruments(InputStream inputStream)	Reads instrument metadata from a DEXPI XML stream.
private static Stream	templateOrDefault(Stream templateStream)

Methods inherited from class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

logger

private static final org.apache.logging.log4j.Logger logger

EQUIPMENT_CLASS_MAP

private static final Map<String, EquipmentEnum> EQUIPMENT_CLASS_MAP

PIPING_COMPONENT_MAP

private static final Map<String, EquipmentEnum> PIPING_COMPONENT_MAP

Constructor Details

DexpiXmlReader

private DexpiXmlReader()

Method Details

read

public static ProcessSystem read(File file)
                          throws IOException,
DexpiXmlReaderException

Reads the provided DEXPI XML file and returns a populated ProcessSystem.

Parameters:

file - DEXPI XML file

Returns:

a process system populated with units found in the XML

Throws:

IOException - if the file cannot be read

DexpiXmlReaderException - if the file cannot be parsed

read

public static ProcessSystem read(File file,
 Stream templateStream)
                          throws IOException,
DexpiXmlReaderException

Reads the provided DEXPI XML file and returns a populated ProcessSystem using a template Stream for generated piping segments.

Parameters:

file - DEXPI XML file

templateStream - stream providing default fluid, temperature, pressure, and flow rate for generated piping segments. If null, a methane/ethane default is used.

Returns:

a process system populated with units found in the XML

Throws:

IOException - if the file cannot be read

DexpiXmlReaderException - if the file cannot be parsed

read

public static ProcessSystem read(InputStream inputStream)
                          throws IOException,
DexpiXmlReaderException

Reads the provided DEXPI XML stream and returns a populated ProcessSystem.

Parameters:

inputStream - stream containing DEXPI XML data

Returns:

a process system populated with units found in the XML

Throws:

IOException - if the stream cannot be read

DexpiXmlReaderException - if the stream cannot be parsed

read

public static ProcessSystem read(InputStream inputStream,
 Stream templateStream)
                          throws IOException,
DexpiXmlReaderException

Reads the provided DEXPI XML stream and returns a populated ProcessSystem using a template Stream for any generated piping segments.

Parameters:

inputStream - stream containing DEXPI XML data

templateStream - stream providing default fluid, temperature, pressure, and flow rate for generated piping segments. If null, a methane/ethane default is used.

Returns:

a process system populated with units found in the XML

Throws:

IOException - if the stream cannot be read

DexpiXmlReaderException - if the stream cannot be parsed

load

public static void load(File file,
 ProcessSystem processSystem)
                 throws IOException,
DexpiXmlReaderException

Populates an existing ProcessSystem with units parsed from a DEXPI XML file.

Parameters:

file - XML file to parse

processSystem - target process system

Throws:

IOException - if reading fails

DexpiXmlReaderException - if the file cannot be parsed

load

public static void load(File file,
 ProcessSystem processSystem,
 Stream templateStream)
                 throws IOException,
DexpiXmlReaderException

Populates an existing ProcessSystem with units parsed from a DEXPI XML file.

Parameters:

file - XML file to parse

processSystem - target process system

templateStream - stream providing default fluid, temperature, pressure, and flow rate for generated piping segments. If null, a methane/ethane default is used.

Throws:

IOException - if reading fails

DexpiXmlReaderException - if the file cannot be parsed

load

public static void load(InputStream inputStream,
 ProcessSystem processSystem)
                 throws IOException,
DexpiXmlReaderException

Populates an existing ProcessSystem with units parsed from a DEXPI XML stream.

Parameters:

inputStream - XML input stream

processSystem - target process system

Throws:

IOException - if reading fails

DexpiXmlReaderException - if the stream cannot be parsed

load

public static void load(InputStream inputStream,
 ProcessSystem processSystem,
 Stream templateStream)
                 throws IOException,
DexpiXmlReaderException

Populates an existing ProcessSystem with units parsed from a DEXPI XML stream.

Parameters:

inputStream - XML input stream

processSystem - target process system

templateStream - stream providing default fluid, temperature, pressure, and flow rate for generated piping segments. If null, a methane/ethane default is used.

Throws:

IOException - if reading fails

DexpiXmlReaderException - if the stream cannot be parsed

load

public static void load(InputStream inputStream,
 ProcessSystem processSystem,
 Stream templateStream,
 boolean namespaceAware)
                 throws IOException,
DexpiXmlReaderException

Populates an existing ProcessSystem with units parsed from a DEXPI XML stream.

Parameters:

inputStream - XML input stream

processSystem - target process system

templateStream - stream providing default fluid, temperature, pressure, and flow rate for generated piping segments. If null, a methane/ethane default is used.

namespaceAware - whether to enable namespace-aware XML parsing

Throws:

IOException - if reading fails

DexpiXmlReaderException - if the stream cannot be parsed

readInstruments

public static List<DexpiInstrumentInfo> readInstruments(File file)
                                                 throws IOException,
DexpiXmlReaderException

Reads instrument metadata from a DEXPI XML file. This returns structured DexpiInstrumentInfo records that describe the P&ID instrumentation without creating live transmitter/controller objects (which require connected streams).

Parameters:

file - DEXPI XML file

Returns:

list of instrument info records parsed from the file

Throws:

IOException - if the file cannot be read

DexpiXmlReaderException - if the file cannot be parsed

readInstruments

public static List<DexpiInstrumentInfo> readInstruments(InputStream inputStream)
                                                 throws IOException,
DexpiXmlReaderException

Reads instrument metadata from a DEXPI XML stream.

Parameters:

inputStream - stream containing DEXPI XML data

Returns:

list of instrument info records parsed from the stream

Throws:

IOException - if the stream cannot be read

DexpiXmlReaderException - if the stream cannot be parsed

parseInstrumentsFromDocument

static List<DexpiInstrumentInfo> parseInstrumentsFromDocument(Document document)

Parses instruments from an already-parsed DEXPI XML Document. Package-visible for use by DexpiSimulationBuilder.

Parameters:

document - the parsed XML document

Returns:

list of instrument info records

parseInstruments

private static List<DexpiInstrumentInfo> parseInstruments(Document document)

Parses all ProcessInstrumentationFunction elements from the document, resolving loop and actuator associations.

Parameters:

document - the parsed XML document

Returns:

list of instrument info records

parseDocument

private static Document parseDocument(InputStream inputStream,
 boolean nsAware)
                               throws DexpiXmlReaderException

Throws:

DexpiXmlReaderException

addUnits

private static void addUnits(Document document,
 ProcessSystem processSystem,
 String tagName,
 Map<String, EquipmentEnum> equipmentMap,
 String nameAttribute)

addPipingSegments

private static void addPipingSegments(Document document,
 ProcessSystem processSystem,
 Stream templateStream)

addDexpiStream

private static void addDexpiStream(ProcessSystem processSystem,
 Element element,
 Stream templateStream,
 String baseName)

addDexpiUnit

private static void addDexpiUnit(ProcessSystem processSystem,
 Element element,
 EquipmentEnum equipmentEnum,
 String baseName,
 String componentClass)

prependLineOrFluid

private static String prependLineOrFluid(Element element,
 String baseName)

ensureUniqueName

private static String ensureUniqueName(ProcessSystem processSystem,
 String candidate)

templateOrDefault

private static Stream templateOrDefault(Stream templateStream)

createDefaultTemplateStream

private static Stream createDefaultTemplateStream()

createDefaultFluid

private static SystemInterface createDefaultFluid()

getGenericAttribute

private static String getGenericAttribute(Element element,
 String attributeName)

attributeValue

private static String attributeValue(Element element,
 String attributeName)

applyStreamMetadata

private static void applyStreamMetadata(Element element,
 DexpiStream stream)

applyNumericAttribute

private static void applyNumericAttribute(Element element,
 String valueAttribute,
 String unitAttribute,
 BiConsumer<Double,String> consumer,
 String defaultUnit)

parseNumeric

private static Double parseNumeric(String valueText)

directChildElements

private static List<Element> directChildElements(Element element,
 String tagName)

findAttributeInAncestors

private static String findAttributeInAncestors(Node node,
 String attributeName)

firstNonEmpty

private static String firstNonEmpty(String... candidates)

isInsideShapeCatalogue

private static boolean isInsideShapeCatalogue(Node node)

Checks whether the given node is inside a ShapeCatalogue element.

Parameters:

node - the XML node to check

Returns:

true if the node has a ShapeCatalogue ancestor

isBlank

private static boolean isBlank(String value)