OpenDXA

A modified Dislocation Extraction Algorithm pipeline for reconstructing dislocation networks from atomistic data.

Overview

OpenDXA is one of the most ambitious plugins in the VOLT ecosystem. It does not just flag a few suspicious atoms and stop there. It runs a longer reconstruction pipeline that starts with local structure identification, builds crystalline regions, works through interface geometry, and ends by tracing dislocation lines and Burgers information.

That is why this plugin tends to produce several outputs instead of a single result file. You are not only getting the dislocation network back. You are also getting supporting geometry and structure-analysis data that help explain how the network was inferred.

Parameters

Parameter	Type	Default	Description
`crystalStructure`	`string`	`BCC`	Reference crystal structure. Options: `BCC`, `FCC`, `HCP`, `SC`, `CUBIC_DIAMOND`, `HEX_DIAMOND`.
`identificationMode`	`string`	`CNA`	Structure identification mode. Options: `CNA`, `PTM`, `DIAMOND`.
`rmsd`	`float`	`0.1`	RMSD threshold for PTM classification.
`maxTrialCircuitSize`	`int`	`14`	Maximum Burgers circuit size.
`circuitStretchability`	`int`	`9`	Circuit stretchability factor.
`lineSmoothingLevel`	`float`	`1.0`	Dislocation line smoothing level.
`linePointInterval`	`float`	`2.5`	Point interval on dislocation lines.
`onlyPerfectDislocations`	`bool`	`false`	Restrict the result to perfect dislocations.
`markCoreAtoms`	`bool`	`false`	Historical parameter. Core-atom export is currently not emitted by the implementation.

Practical notes

PTM is the richest mode when you need orientations and correspondences.
The plugin emits more than just dislocation lines. Meshes, simulation-cell data, structure stats, and grouped atoms are part of the normal output story.
The markCoreAtoms parameter still appears in the interface, but the current implementation does not export a _core_atoms.msgpack file.

Output

type Vec3 = [float, float, float];
type Mat3x3 = [Vec3, Vec3, Vec3];

type Quaternion = [float, float, float, float];

`{outputBase}_dislocations.msgpack`

interface DislocationSegment {
    segment_id: int;
    points: Vec3[];
    length: float;
    num_points: int;
    burgers_vector: Vec3;
    magnitude: float;
    fractional: string;
}

interface JunctionInformation {
    total_junctions: int;
    junction_arm_distribution: Record<int, int>;
}

interface CircuitInformation {
    total_circuits: int;
    dangling_circuits: int;
    blocked_circuits: int;
    average_edge_count: float;
    edge_count_range: {
        min: int;
        max: int;
    };
}

interface NetworkStatistics {
    total_network_length: float;
    segment_count: int;
    junction_count: int;
    dangling_segments: int;
    average_segment_length: float;
    density: float;
    total_segments_including_degenerate: int;
}

interface DislocationsOutput {
    main_listing: {
        dislocations: int;
        total_points: int;
        average_segment_length: float;
        max_segment_length: float;
        min_segment_length: float;
        total_length: float;
    };
    sub_listings: {
        dislocation_segments: DislocationSegment[];
        junction_information: JunctionInformation;
        circuit_information: CircuitInformation;
        network_statistics: NetworkStatistics;
    };
}

`{outputBase}_defect_mesh.msgpack`

interface MeshPoint {
    index: int;
    position: Vec3;
}

interface MeshFacet {
    vertices: [int, int, int];
}

interface MeshOutput {
    main_listing: {
        total_nodes: int;
        total_facets: int;
    };
    sub_listings: {
        points: MeshPoint[];
        facets: MeshFacet[];
    };
    topology?: {
        euler_characteristic: int;
        is_completely_good: boolean;
        is_completely_bad: boolean;
    };
}

`{outputBase}_interface_mesh.msgpack`

Same schema as MeshOutput.

`{outputBase}_simulation_cell.msgpack`

interface LatticeVector {
    x: float;
    y: float;
    z: float;
}

interface SimulationCellOutput {
    matrix: Mat3x3;
    volume: float;
    is_2d: boolean;
    lattice_vectors: {
        a: LatticeVector;
        b: LatticeVector;
        c: LatticeVector;
    };
    lattice_parameters: {
        a_length: float;
        b_length: float;
        c_length: float;
    };
    periodic_boundary_conditions: {
        x: boolean;
        y: boolean;
        z: boolean;
    };
    angles: {
        alpha: float;
        beta: float;
        gamma: float;
    };
    reciprocal_lattice: {
        matrix: Mat3x3;
        volume: float;
    };
    dimensionality: {
        is_2d: boolean;
        effective_dimensions: 2 | 3;
    };
}

`{outputBase}_ptm_data.msgpack`

Only exported when identificationMode is PTM.

interface PTMPerAtomProperties {
    id: int;
    correspondences: int;
    structure_type?: int;
    orientation: Quaternion;
}

interface PTMDataOutput {
    main_listing: {
        total_atoms: int;
        include_structure_type: boolean;
    };
    "per-atom-properties": PTMPerAtomProperties[];
}

`{outputBase}_atoms.msgpack`

Atoms grouped by identified structure type name.

interface Atom {
    id: int;
    pos: Vec3;
}

interface AtomsOutput {
    export: {
        AtomisticExporter: Record<string, Atom[]>;
    };
}

`{outputBase}_structure_analysis_stats.msgpack`

This file contains both summary statistics and per-atom structural information.

interface StructureAnalysisStatsOutput {
    main_listing: {
        total_atoms: int;
        analysis_method: string;
        [key: `${string}_count`]: int;
        [key: `${string}_percentage`]: float;
        total_identified: int;
        total_unidentified: int;
        identification_rate: float;
        unique_structure_types: int;
    };
}