Release: 1.0.1

CHANGELOG.md

@@ -0,0 +1,34 @@
+Changelog for the openPMD Standard
+==================================
+
+1.0.1
+-----
+**Date:** 2017-12-01
+
+Typo and wording changes since the 1.0.0 release.
+
+This release improves wordings, common questions and example snippets.
+Keywords and logic are unchanged and backwards compatible for revision releases.
+
+## Changes to "1.0.0"
+
+### Base Standard
+
+- **backwards compatible changes:**
+  - better examples for `axisLabels` #153
+  - unspecified (user-chosen) `float`/`uint`/`int` are now called `floatX`/`uintX`/`intX` throughout the standard #152
+  - note to store non-openPMD information outside the `basePath` #115
+  - particle position: update python example #119 #127
+  - particle patches: typo in reference to `positionOffset` #135
+
+### Extension
+
+- `ED-PIC`:
+  - **backwards compatible changes:**
+    - `fieldSmoothing`: typo in allowed values #131
+    - `fieldSolver`: typo in PSATD description #133
+    - reference updated to unspecified (user-chosen) `float`/`uint`/`int` as in base standard #152
+
+### Data Converter
+
+No data conversion needed.

EXT_ED-PIC.md

@@ -43,9 +43,9 @@ The individual requirement is given in `scope`.
               [doi:10.1140/epjd/e2014-50162-y](http://dx.doi.org/10.1140/epjd/e2014-50162-y))
       - `PSTD` (*Pseudo-Spectral Time Domain*, e.g.,
                 Q. H. Liu, Letters 15 (3) (1997) 158–165)
-      - `PSATD` (*Pseudo-Spectral Time Domain*, I. Haber, R. Lee, H. Klein,
-                 J. Boris, Advances in electromagnetic simulation techniques,
-                 1973)
+      - `PSATD` (*Pseudo-Spectral Analytical Time Domain*, I. Haber, R. Lee,
+                 H. Klein, J. Boris, Advances in electromagnetic simulation
+                 techniques, 1973)
       - `GPSTD`
       - `other`
       - `none`
@@ -166,7 +166,7 @@ extension. The individual requirement is given in `scope`.
     - type: *(string)*
     - scope: *required*
     - description: applied field filters for E and B
-    - allowed values: same as for `fieldSmoothing`
+    - allowed values: same as for `currentSmoothing`
 
   - `fieldSmoothingParameters`
     - type: *(string)*
@@ -184,20 +184,20 @@ field that should be distributed again on the cells.
 
 - fundamental fields:
   - `E`
-    - type: *(float)* or *(int)* or *(uint)*
+    - type: *(floatX)* or *(intX)* or *(uintX)*
     - description: the electric field
-    - advice to implementors: a *(float)* type is likely the most frequent case
+    - advice to implementors: a *(floatX)* type is likely the most frequent case
                               for this record
     - advice to implementors: must have
                               `unitDimension = (1., 1., -3., -1., 0., 0., 0.)`
                               (V/m = kg * m / (A * s^3))
   - `B`
-    - type: *(float)* or *(int)* or *(uint)*
+    - type: *(floatX)* or *(intX)* or *(uintX)*
     - description: the magnetic field
     - advice to implementors: must have
                               `unitDimension = (0., 1., -2., -1., 0., 0., 0.)`
                               (T = kg / (A * s^2))
-    - advice to implementors: a *(float)* type is likely the most frequent case
+    - advice to implementors: a *(floatX)* type is likely the most frequent case
                               for this record
 
 - auxiliary fields:
@@ -229,7 +229,7 @@ The following additional attributes are defined in this extension.
 The individual requirement is given in `scope`.
 
   - `particleShape`
-    - type: *(float)*
+    - type: *(floatX)*
     - scope: *required*
     - description: the order of the particle assignment function shape
                    (see *Hockney* reprint 1989, ISBN:0-85274-392-0, table 5-1)
@@ -341,7 +341,7 @@ particle. Therefore, this extension requires the two following attributes:
              charge of 100 electrons), then macroweighted must be 1
 
 - `weightingPower`
-  - type: *(double / REAL8)*
+  - type: *(float64 / REAL8)*
   - scope: *required*
   - description: indicates with which power of `weighting` (see below)
                  the quantity should be multiplied, in order to go from the
@@ -382,31 +382,31 @@ momentum change due to collisions) but not as *the* particle momentum that
 should be used to push the particle.
 
   - `charge`
-    - type: *(float)* or *(int)* or *(uint)*
+    - type: *(floatX)* or *(intX)* or *(uintX)*
     - description: electric charge of the macroparticle or of the underlying
                    individual particle (depending on the `macroWeighted` flag)
     - advice to implementors: must have `weightingPower = 1` and
                               `unitDimension = (0., 0., 1., 1., 0., 0., 0.)`
                               (charge = current * time)
 
   - `mass`
-    - type: *(float)* or *(int)* or *(uint)*
+    - type: *(floatX)* or *(intX)* or *(uintX)*
     - description: mass of the macroparticle or of the underlying individual
                    particle (depending on the `macroWeighted` flag)
     - advice to implementors: must have `weightingPower = 1` and
                               `unitDimension = (0., 1., 0., 0., 0., 0., 0.)`
                               (mass)
 
   - `weighting`
-    - type: *(float)* or *(int)* or *(uint)*
+    - type: *(floatX)* or *(intX)* or *(uintX)*
     - description: the number of underlying individual particles that
                    the macroparticles represent
     - advice to implementors: must have `weightingPower = 1`,
                               `macroWeighted = 1`, `unitSI = 1` and
                               `unitDimension == (0., ..., 0.)`
 
   - `momentum/` + components such as `x`, `y` and `z`
-    - type: each component in *(float)* or *(int)* or *(uint)*
+    - type: each component in *(floatX)* or *(intX)* or *(uintX)*
     - description: component-wise momentum of the macroparticle or of the
                    underlying individual particle (depending on the
                    `macroWeighted` flag)
@@ -415,7 +415,7 @@ should be used to push the particle.
                               (momentum = mass * length / time)
 
   - `position/` + components such as `x`, `y` and `z`
-    - type: each component in *(float)* or *(int)* or *(uint)*
+    - type: each component in *(floatX)* or *(intX)* or *(uintX)*
     - description: component-wise position of a particle, relative to
                    `positionOffset`
       - in the case where the `component`s of `positionOffset` are constant,
@@ -426,19 +426,19 @@ should be used to push the particle.
         `positionOffset` must represent the position of the beginning of the
         cell (see below)
     - rationale: dividing the particle position in a beginning of the cell
-                 (as *(int)*) and in-cell position (as *(float)*) can
+                 (as *(intX)*) and in-cell position (as *(floatX)*) can
                  dramatically improve the precision of stored particle
                  positions; this division creates a connection between
                  particles and the fields on their cells
     - advice to implementors: must have `weightingPower = 0` and
                               `unitDimension = (1., 0., 0., 0., 0., 0., 0.)`
                               (length)
-    - advice to implementors: a *(float)* type is likely the most frequent case
+    - advice to implementors: a *(floatX)* type is likely the most frequent case
                               for this record
     - example: use only `x` and `y` in 2D
 
   - `positionOffset/` + components such as `x`, `y` and `z`
-    - type: each component in *(float)* or *(int)* or *(uint)*
+    - type: each component in *(floatX)* or *(intX)* or *(uintX)*
     - description: if the `component`s of this record are non-constant
                    this must represent the position of the beginning of the
                    cell the particle is associated with;
@@ -455,7 +455,7 @@ should be used to push the particle.
     - advice to implementors: must have `weightingPower = 0` and
                               `unitDimension = (1., 0., 0., 0., 0., 0., 0.)`
                               (length)
-    - advice to implementors: an *(int)* or *(uint)* type is likely the most
+    - advice to implementors: an *(intX)* or *(uintX)* type is likely the most
                               frequent case for this record
     - advice to implementors: if you want to neglect the relation between
                               particles and their cells, simply store this
@@ -464,7 +464,7 @@ should be used to push the particle.
 
   - `particlePatches`
     - description: if this sub-group is used in combination with non-constant
-                   components in the `particleOffset` components, the
+                   components in the `positionOffset` components, the
                    position for `offset` and `extent` refers to the
                    position of the beginning of the cell (see `positionOffset`)
     - advice to implementors: the calculation and description of
@@ -477,21 +477,21 @@ should be used to push the particle.
                               in patches "by cell"
 
   - `boundElectrons`
-    - type: *(float)* or *(int)* or *(uint)*
+    - type: *(floatX)* or *(intX)* or *(uintX)*
     - description: number of bound electrons of an ion/atom;
                    to provide information to atomic physics algorithms
     - advice to implementors: must have `weightingPower = 1` and
                               `unitDimension = (0., ..., 0.)` (dimensionless)
 
   - `protonNumber`
-    - type: *(float)* or *(int)* or *(uint)*
+    - type: *(floatX)* or *(intX)* or *(uintX)*
     - description: the atomic number Z of an ion/atom;
                    to provide information to atomic physics algorithms
     - advice to implementors: must have `weightingPower = 1` and
                               `unitDimension = (0., ..., 0.)` (dimensionless)
 
   - `neutronNumber`
-    - type: *(float)* or *(int)* or *(uint)*
+    - type: *(floatX)* or *(intX)* or *(uintX)*
     - description: the neutron number N = the mass number - A and
                    the atomic number Z of an ion/atom;
                    to provide information to atomic physics algorithms