Duplicate/Reset for Rerun: stop inheriting the previous run's properties

A duplicated calculation starts as an exact copy, and resetForRerun()
then tidies it up -- removing the job log, resetting the state, and
calling removeOutputFiles().  That takes away the raw output but NOT the
properties parsed out of it, which live in their own collection.

So a duplicate arrived carrying the parent's energies, geometry trace
and orbitals, and offered them in the Properties menu as its own,
before it had ever been run, with nothing to say they were inherited.
The same applied to "Reset for Rerun" on a job that had run.

resetForRerun() now removes the properties too.  Evaluation order
matters and is deliberate: && short-circuits, so removeProperties() is
called before the expression rather than inside it, and still runs if
removing the outputs fails.

The input file is deliberately NOT removed.  resetForRerun() already
drops it when the target state is CREATED and keeps it for READY, which
is what makes "Duplicate for Rerun" launchable straight away -- the deck
is derived from the settings, so a duplicate that keeps its settings
should keep it.  Where that goes wrong is when the GENERATOR has
changed rather than the settings, and File > Regenerate Input File is
the answer to that.

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

Author: andy

include/dsm/TaskJob.H

@@ -133,6 +133,10 @@ class TaskJob : public Job,
 
       virtual bool removeInputFiles();
       virtual bool removeOutputFiles();
+
+      /** Remove the extracted properties, leaving the calculation's
+          settings alone. */
+      virtual bool removeProperties();
       virtual bool putInputFile(const string& name, istream *istr);
       virtual bool putOutputFile(const string& name, istream *istr);
       virtual bool putAnyFile(const  string& name, istream* istr);

src/dsm/edsiimpl/TaskJob.C

@@ -699,6 +699,34 @@ bool TaskJob::removeInputFiles()
  *
  * @return Returns true if all output files were removed, otherwise false.
  */
+/**
+ * Remove the properties extracted from a previous run.
+ *
+ * removeOutputFiles() takes away the raw output but NOT the properties
+ * parsed out of it, which live in their own collection.  For a
+ * calculation about to be rerun -- and especially for a duplicate,
+ * which starts life as an exact copy -- leaving them behind means the
+ * Properties menu offers the PREVIOUS run's energies, geometries and
+ * orbitals on a job that has not been run yet, with nothing to say they
+ * are inherited.
+ */
+bool TaskJob::removeProperties()
+{
+  bool ret = true;
+
+  try {
+    getVDoc()->removeProperties();
+  }
+  catch (DavException& davException) {
+    p_msgStack->add("UNABLE_TO_COMPLETE_REQUEST",
+                    davException.what());
+    ret = false;
+  }
+
+  return ret;
+}
+
+
 bool TaskJob::removeOutputFiles()
 {
   bool ret = true;
@@ -1818,7 +1846,17 @@ bool TaskJob::resetForRerun(const ResourceDescriptor::RUNSTATE& toState)
     }
   }
 
-  bool ret = setState(tostate) && removeOutputFiles();
+  //  Properties as well as outputs.  Without this a duplicated
+  //  calculation carries the parent's extracted results -- energies,
+  //  geometry trace, orbitals -- and presents them as its own before it
+  //  has ever been run.  "Duplicate should inherit nothing from the
+  //  parent job beyond the settings."
+  //
+  //  Evaluation order matters: && short-circuits, so removeProperties()
+  //  is called first to guarantee it runs even if removing the outputs
+  //  fails.
+  bool propsGone = removeProperties();
+  bool ret = setState(tostate) && removeOutputFiles() && propsGone;
 
   // set rerun flag so calculation run directory files are removed
   // if/when the job is launched