Quantum ESPRESSO: add the Geometry runtype (calculation='relax')

Reported from a live session: "Tested QE implementation. Very broken ...
Nothing in Runtype details -- can't edit. Final edit doesn't bring
anything up. Launch doesn't do anything."

Most of that follows from one line. QuantumESPRESSO.edml declared a
single <runtype>Energy</runtype>, by design -- ai.qe's header still says
"PHASE 1, REDUCED SCOPE. calculation='scf' only". So QE could do single
points and nothing else: qeruntype.py built a dialog only for Energy and
was empty for anything else, and with no usable runtype there is nothing
to edit and nothing to launch.

Geometry now maps to calculation='relax', end to end:

  * QuantumESPRESSO.edml offers the runtype.
  * ai.qe gains QECalculationType(), which maps the ECCE runtype name
    onto pw.x's &CONTROL calculation value and dies in the MAIN FLOW for
    anything unsupported -- not inside a ##token## resolver, where such a
    die used to be swallowed and emit a deck with the line silently
    missing.
  * A relax forces tprnfor on regardless of the checkbox, because pw.x
    needs forces to move the ions. The control is not hidden; the deck
    stays valid even if someone unticks it.
  * qe.tpl gains a ##QEIons## slot. The resolver returns empty for scf,
    so the line is dropped -- pw.x rejects &IONS outright on an scf run.
  * qeruntype.py gains a Geometry branch exposing forc_conv_thr and
    nstep, the two values that decide whether an optimisation finishes
    in six steps or sixty, or stops at the cap WITHOUT converging while
    still writing a final geometry that looks like success. Forces are
    deliberately not offered there, since ai.qe overrides them.

Verified the whole chain rather than the pieces: ai.qe generated the deck
from a .frag/.param pair with RunType: Geometry, the real pw.x 6.7
accepted it and ran to convergence ("JOB DONE", final coordinates
written), and qe.desc read the trajectory back. That output is now the
fixture, replacing the hand-written input I had used for the GEOMTRACE
work -- which matches the convention the other QE cases already state,
that every fixture deck is generated by ai.qe itself.

Still absent, each needing more than a runtype entry: vc-relax (needs the
CELL namelist and LATTICEVEC extraction so the changing box can be
animated), nscf/bands, md, and phonons (ph.x is a separate executable).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01EFMUNbw2UpRPmgsqviAowb

Author: andy

data/client/cap/QuantumESPRESSO.edml

@@ -96,10 +96,24 @@
      Energy maps to calculation='scf'.  Forces and the stress tensor
      are available on an scf run (tprnfor / tstress) and are exposed as
      Runtype Details checkboxes, so a separate Gradient runtype would
-     add nothing in phase 1. -->
+     add nothing.
+
+     Geometry maps to calculation='relax', added once qe.desc could
+     extract GEOMTRACE; there is no point offering an optimisation
+     whose trajectory ECCE cannot display.  It forces tprnfor on
+     regardless of the checkbox, because pw.x needs forces to move the
+     ions, and it emits an &IONS namelist that an scf run must not have.
+
+     Still absent, and each needs work beyond a runtype entry:
+     vc-relax (needs the CELL namelist and LATTICEVEC extraction so the
+     changing box can be animated), nscf/bands (a second run reusing the
+     first one's charge density, which does not fit
+     one-input/one-output), md, and phonons (ph.x is a separate
+     executable). -->
 <Editor theorydialog="qetheory.py" runtypedialog="qeruntype.py">
   <Theory category="PW" name="PW" needsBasis="false">
     <runtype>Energy</runtype>
+    <runtype>Geometry</runtype>
   </Theory>
 
   <TheorySummary topLabel="Plane Waves-">

scripts/codereg/qeruntype.py

@@ -73,6 +73,43 @@ def __init__(self, parent, helpURL):
             propSizer.AddWidget(self.printStress)
             self.panelSizer.Add(propSizer)
 
+        elif EcceGlobals.RunType == "Geometry":
+
+            # calculation='relax'.  Forces are NOT offered as a choice
+            # here: pw.x needs them to move the ions, so ai.qe forces
+            # tprnfor on for a relax whatever a checkbox said.  Offering
+            # a control that is then overridden would be worse than
+            # offering none.
+            convSizer = EcceBoxSizer(self, label="Convergence", cols=1)
+
+            # forc_conv_thr, in Ry/bohr.  pw.x's own default is 1.0d-3,
+            # stated explicitly so the deck does not change meaning if
+            # that default ever does.  Exposed because it is the single
+            # knob that decides whether an optimisation finishes in six
+            # steps or sixty.
+            self.forceConv = EcceExpInput(self,
+                                          unit="Ry/bohr",
+                                          name="ES.Runtype.PW.ForcConvThr",
+                                          default=1e-3,
+                                          hardRange="(0..)",
+                                          label="Force Convergence:",
+                                          export=1)
+            convSizer.AddWidget(self.forceConv)
+
+            # nstep: pw.x defaults to 50 for relax.  A run that hits the
+            # cap stops WITHOUT converging and still writes a final
+            # geometry, which looks like success, so the value is worth
+            # having in front of the user.
+            self.maxSteps = EcceSpinCtrl(self,
+                                         hardRange="[1..)",
+                                         softRange="[1..500]",
+                                         name="ES.Runtype.PW.NStep",
+                                         default=50,
+                                         label="Maximum Steps:",
+                                         export=1)
+            convSizer.AddWidget(self.maxSteps)
+            self.panelSizer.Add(convSizer)
+
         self.AddButtons()
 
     def CheckDependency(self):

scripts/parsers/ai.qe

@@ -492,15 +492,73 @@ sub warnOnOddElectronCount {
 # &CONTROL.  outdir and pseudo_dir are also rewritten at launch time by
 # qe.launchpp, which is where launch-time-only knowledge belongs; what is
 # written here has to be valid on its own so a hand-run deck works.
+# Maps ECCE's runtype name onto pw.x's &CONTROL calculation value.
+#
+# Phase 1 was scf only. "Geometry" was added once GEOMTRACE extraction
+# existed to read the result back (verified against a real 6-step BFGS
+# water relax with pw.x 6.7) -- there is no point offering an
+# optimisation whose trajectory ECCE cannot display.
+#
+# Dies in the MAIN FLOW rather than inside a ##token## resolver: ai.*
+# template engines run resolvers through eval, and a die inside one used
+# to be swallowed silently, emitting a deck with the line missing. That
+# is fixed (a6d0512) but the rule stands -- validate before generation,
+# as &verifyPeriodic does.
+sub QECalculationType {
+  my $runtype = $AbiDict{"RunType"};
+  return "scf"   if ($runtype eq "Energy");
+  return "relax" if ($runtype eq "Geometry");
+  die "Runtype '$runtype' is not supported for Quantum ESPRESSO.\n" .
+      "  Supported: Energy (scf), Geometry (relax).\n";
+}
+
 sub QEControl {
   my @l = ();
+  my $calc = &QECalculationType;
   push(@l, "&CONTROL");
-  push(@l, "  calculation = 'scf'");
+  push(@l, "  calculation = '" . $calc . "'");
   push(@l, "  prefix = '" . &Prefix . "'");
   push(@l, "  outdir = './qe.scratch'");
   push(@l, "  pseudo_dir = '" . &pseudoDir . "/'");
-  push(@l, "  tprnfor = " . &FortranLogical("ES.Runtype.PW.PrintForces", 1));
+  # A relax cannot run without forces, whatever the checkbox says --
+  # pw.x needs them to move the ions. Forcing it here rather than
+  # hiding the control is deliberate: the generated deck stays valid
+  # even if someone unticks it.
+  my $forces = ($calc eq "relax")
+             ? ".true."
+             : &FortranLogical("ES.Runtype.PW.PrintForces", 1);
+  push(@l, "  tprnfor = " . $forces);
   push(@l, "  tstress = " . &FortranLogical("ES.Runtype.PW.PrintStress", 0));
+  if ($calc eq "relax") {
+    #  Both come from the Geometry branch of qeruntype.py. Defaults match
+    #  pw.x's own (1.0d-3 Ry/bohr, 50 steps) and are stated explicitly so
+    #  the deck does not change meaning if those defaults ever do.
+    push(@l, "  forc_conv_thr = " . &numOr("ES.Runtype.PW.ForcConvThr", "1.0d-3"));
+    push(@l, "  nstep = " . &numOr("ES.Runtype.PW.NStep", "50"));
+  }
+  push(@l, "/");
+  my $r = join("\n", @l);
+  $_ = $r;
+  return $r;
+}
+
+# &IONS. Only present for a relax: pw.x rejects the namelist outright on
+# an scf run ("calculation='scf': namelist &IONS not needed"), so this
+# resolver returns the empty string and modifyInputFile drops the line.
+#
+# NOTE for whoever adds vc-relax: it needs &CELL as well, and the cell
+# then changes per step, which means LATTICEVEC extraction (qe.desc has
+# none yet) before it is worth offering -- GTStepCmd already animates a
+# changing box, it just has no producer for QE.
+sub QEIons {
+  my $calc = &QECalculationType;
+  return "" if ($calc ne "relax");
+
+  my @l = ();
+  push(@l, "&IONS");
+  #  bfgs is pw.x's own default for relax; stated explicitly so the deck
+  #  does not change meaning if that default ever does.
+  push(@l, "  ion_dynamics = 'bfgs'");
   push(@l, "/");
   my $r = join("\n", @l);
   $_ = $r;

scripts/parsers/qe.tpl

@@ -1,6 +1,7 @@
 ##QEControl##
 ##QESystem##
 ##QEElectrons##
+##QEIons##
 ##QEAtomicSpecies##
 ##QECellParameters##
 ##QEAtomicPositions##

tests/parsers/cases.py

@@ -1075,22 +1075,27 @@
     dict(
         #  The only QE fixture that is an OPTIMISATION rather than a single
         #  point, and therefore the only one that exercises [GEOMTRACE].
-        #  Produced by a real pw.x 6.7 run on this machine (input checked in
-        #  alongside it), deliberately started from a distorted water
-        #  geometry so BFGS has something to do: 6 steps to convergence.
         #
-        #  7 ATOMIC_POSITIONS blocks, not 6: the last is the duplicate
-        #  printed inside "Begin final coordinates". Harmless for animation
-        #  (the last frame simply repeats) and asserted here so that if a
-        #  future QE version stops echoing it, the count change is noticed
+        #  Like its siblings, the deck was GENERATED BY ai.qe (with
+        #  RunType: Geometry) and then run to completion by the real
+        #  pw.x 6.7 on this machine -- so this case exercises the whole
+        #  chain: the Geometry runtype reaching calculation='relax', the
+        #  &IONS namelist an scf run must not have, forc_conv_thr and
+        #  nstep from the runtype dialog's keys, pw.x accepting all of it,
+        #  and qe.desc reading the trajectory back.
+        #
+        #  4 ATOMIC_POSITIONS blocks: 3 BFGS steps plus the duplicate
+        #  printed inside "Begin final coordinates". The duplicate is
+        #  harmless for animation (the last frame simply repeats) and is
+        #  asserted so that a future QE version dropping it is noticed
         #  rather than silently absorbed.
         name='qe-h2o-relax',
         desc='qe.desc',
         fixture='qe/h2o_relax.pwout',
         parse_args=('.', 'GeomOpt', 'PW', 'PW', '0'),
         expect={
             'VERSION': dict(keys={'VERSION': {'values': 'PWSCF 6.7MaX'}}),
-            'GEOMTRACE': dict(blocks=7, keys={'GEOMTRACE': {
+            'GEOMTRACE': dict(blocks=4, keys={'GEOMTRACE': {
                 'size': '1 3 3',
                 'units': 'Angstrom'}}),
         },