Add copyAlgoToState/copyStateToAlgo bulk helpers and convert 16 modules (#718)

src/Dataflow/Network/Module.cc

@@ -375,124 +375,124 @@
   impl_->metadata_.setMetadata("Module state", stateMetaInfo());
 }
 
 bool Module::executeWithSignals() NOEXCEPT
 {
   auto starting = "STARTING MODULE: " + id().id_;
 
   if (isStoppable())
   {
     dynamic_cast<Stoppable*>(this)->resetStoppability();
   }
 
   runProgrammablePortInput();
 
 #ifdef BUILD_HEADLESS //TODO: better headless logging
   static Mutex executeLogLock("headlessExecution");
   if (!LogSettings::Instance().verbose())
   {
     Guard g(executeLogLock.get());
     std::cout << starting << std::endl;
   }
 #endif
   impl_->executeBegins_(id());
   auto start = std::chrono::steady_clock::now();
   {
     auto isoString = boost::posix_time::to_simple_string(boost::posix_time::microsec_clock::universal_time());
     impl_->metadata_.setMetadata("Last execution timestamp", isoString);
     copyStateToMetadata();
   }
   /// @todo: status() calls should be logged everywhere, need to change legacy loggers. issue #nnn
   status(starting);
   /// @todo: need separate logger per module
   //LOG_DEBUG("STARTING MODULE: " << id_.id_);
   impl_->executionState_->transitionTo(ModuleExecutionState::Value::Executing);
   impl_->returnCode_ = false;
   bool threadStopValue = false;
 
   try
   {
     if (!executionDisabled())
       execute();
 
     impl_->returnCode_ = true;
     getLogger()->setErrorFlag(false);
   }
   catch (const std::bad_alloc&)
   {
     error("MODULE ERROR: bad_alloc caught");
   }
   catch (PortNotFoundException& e)
   {
     std::ostringstream ostr;
     ostr << "Port not found, it may need initializing in the module constructor. " << std::endl << "Message: " << e.what() << std::endl;
     error(ostr.str());
   }
   catch (AlgorithmParameterNotFound& e)
   {
     std::ostringstream ostr;
     ostr << "State key not found, it may need initializing in ModuleClass::setStateDefaults(). " << std::endl << "Message: " << e.what() << std::endl;
     error(ostr.str());
   }
   catch (const ThreadStopped&)
   {
     error("MODULE ERROR: execution thread interrupted by user.");
     threadStopValue = true;
   }
   catch (Core::ExceptionBase& e)
   {
     /// @todo: this block is repetitive (logging-wise) if the macros are used to log AND throw an exception with the same message. Figure out a reasonable condition to enable it.
     //if (LogSettings::Instance().verbose())
     if (!getLogger()->errorReported())
     {
       std::ostringstream ostr;
       ostr << "Caught exception: " << e.typeName() << std::endl << "Message: " << e.what() << "\n" << boost::diagnostic_information(e) << std::endl;
       error(ostr.str());
     }
   }
   catch (const std::exception& e)
   {
     error(std::string("MODULE ERROR: std::exception caught: ") + e.what());
   }
   catch (...)
   {
     error("MODULE ERROR: unhandled exception caught");
   }
   impl_->threadStopped_ = threadStopValue;
 
   auto end = std::chrono::steady_clock::now();
   std::chrono::duration<double> elapsed_seconds = end-start;
   {
     impl_->metadata_.setMetadata("Last execution duration (seconds)", std::to_string(elapsed_seconds.count()));
   }
 
   std::ostringstream finished;
   finished << "MODULE " << id().id_ << " FINISHED " <<
     (impl_->returnCode_ ? "successfully " : "with errors ") << "in " << elapsed_seconds.count() << " seconds.";
   status(finished.str());
 #ifdef BUILD_HEADLESS //TODO: better headless logging
   if (!LogSettings::Instance().verbose())
   {
     Guard g(executeLogLock.get());
     std::cout << finished.str() << std::endl;
   }
 #endif
 
   //TODO: brittle dependency on Completed with executor
   impl_->executionState_->transitionTo(ModuleExecutionState::Value::Completed);
 
   auto expandedEndState = impl_->returnCode_ ? ModuleExecutionState::Value::Completed : ModuleExecutionState::Value::Errored;
   impl_->executionState_->setExpandedState(expandedEndState);
 
   if (!executionDisabled())
   {
     resetStateChanged();
     impl_->inputsChanged_ = false;
   }
 
   impl_->executeEnds_(elapsed_seconds.count(), id());
   return impl_->returnCode_;
 }
 
 void Module::runProgrammablePortInput()
 {
   auto prog = getOptionalInputAtIndex<MetadataObject>(ProgrammablePortId());
@@ -893,6 +893,18 @@
   algo().set(name, get_state()->getValue(name).toVector());
 }
 
+void Module::copyAlgoToState(std::initializer_list<AlgorithmParameterName> names)
+{
+  for (const auto& name : names)
+    get_state()->setValue(name, algo().get(name).value());
+}
+
+void Module::copyStateToAlgo(std::initializer_list<AlgorithmParameterName> names)
+{
+  for (const auto& name : names)
+    algo().set(name, get_state()->getValue(name).value());
+}
+
 ModuleExecutionState& Module::executionState()
 {
   return *impl_->executionState_;

src/Dataflow/Network/Module.h

@@ -184,6 +184,8 @@ namespace Networks {
     void setAlgoStringFromState(const Core::Algorithms::AlgorithmParameterName& name);
     void setAlgoOptionFromState(const Core::Algorithms::AlgorithmParameterName& name);
     void setAlgoListFromState(const Core::Algorithms::AlgorithmParameterName& name);
+    void copyAlgoToState(std::initializer_list<Core::Algorithms::AlgorithmParameterName> names);
+    void copyStateToAlgo(std::initializer_list<Core::Algorithms::AlgorithmParameterName> names);
     //For modules that need to initialize some internal state signal/slots, this needs to be called after set_state to reinitialize.
     virtual void postStateChangeInternalSignalHookup();
 

src/Modules/BrainStimulator/ElectrodeCoilSetup.cc

@@ -56,17 +56,11 @@ ElectrodeCoilSetup::ElectrodeCoilSetup() : Module(ModuleLookupInfo("ElectrodeCoi
 
 void ElectrodeCoilSetup::setStateDefaults()
 {
-  setStateIntFromAlgo(Parameters::NumberOfPrototypes);
-  setStateBoolFromAlgo(Parameters::ProtoTypeInputCheckbox);
-  setStateBoolFromAlgo(Parameters::InvertNormalsCheckBox);
-  setStateBoolFromAlgo(Parameters::AllInputsTDCS);
-  setStateIntFromAlgo(Parameters::ProtoTypeInputComboBox);
-  setStateListFromAlgo(Parameters::TableValues);
-  setStateDoubleFromAlgo(Parameters::ElectrodethicknessSpinBox);
-  setStateBoolFromAlgo(Parameters::ElectrodethicknessCheckBox);
-  setStateBoolFromAlgo(Parameters::OrientTMSCoilRadialToScalpCheckBox);
-  setStateBoolFromAlgo(Parameters::PutElectrodesOnScalpCheckBox);
-  setStateBoolFromAlgo(Parameters::InterpolateElectrodeShapeCheckbox);
+  copyAlgoToState({Parameters::NumberOfPrototypes, Parameters::ProtoTypeInputCheckbox,
+    Parameters::InvertNormalsCheckBox, Parameters::AllInputsTDCS, Parameters::ProtoTypeInputComboBox,
+    Parameters::TableValues, Parameters::ElectrodethicknessSpinBox, Parameters::ElectrodethicknessCheckBox,
+    Parameters::OrientTMSCoilRadialToScalpCheckBox, Parameters::PutElectrodesOnScalpCheckBox,
+    Parameters::InterpolateElectrodeShapeCheckbox});
 }
 
 void ElectrodeCoilSetup::execute()
@@ -77,15 +71,11 @@ void ElectrodeCoilSetup::execute()
 
  if (needToExecute())  //newStatePresent
  {
-   setAlgoBoolFromState(Parameters::ProtoTypeInputCheckbox);
-   setAlgoBoolFromState(Parameters::InvertNormalsCheckBox);
-   setAlgoBoolFromState(Parameters::OrientTMSCoilRadialToScalpCheckBox);
-   setAlgoBoolFromState(Parameters::AllInputsTDCS);
-   setAlgoIntFromState(Parameters::ProtoTypeInputComboBox);
-   setAlgoBoolFromState(Parameters::ElectrodethicknessCheckBox);
-   setAlgoBoolFromState(Parameters::PutElectrodesOnScalpCheckBox);
-   setAlgoBoolFromState(Parameters::InterpolateElectrodeShapeCheckbox);
-   setAlgoDoubleFromState(Parameters::ElectrodethicknessSpinBox);
+   copyStateToAlgo({Parameters::ProtoTypeInputCheckbox, Parameters::InvertNormalsCheckBox,
+     Parameters::OrientTMSCoilRadialToScalpCheckBox, Parameters::AllInputsTDCS,
+     Parameters::ProtoTypeInputComboBox, Parameters::ElectrodethicknessCheckBox,
+     Parameters::PutElectrodesOnScalpCheckBox, Parameters::InterpolateElectrodeShapeCheckbox,
+     Parameters::ElectrodethicknessSpinBox});
 
    if(elc_coil_proto.size()>0)
     {

src/Modules/BrainStimulator/ModelTMSCoil.cc

@@ -52,38 +52,20 @@ ModelTMSCoil::ModelTMSCoil() : Module(staticInfo_, true)
 
 void ModelTMSCoil::setStateDefaults()
 {
-  auto state = get_state();
-  setStateStringFromAlgo(Parameters::Type);
-  setStateIntFromAlgo(Parameters::FigureOf8CoilShape);
-  setStateDoubleFromAlgo(Parameters::Current);
-  setStateIntFromAlgo(Parameters::Rings);
-  setStateDoubleFromAlgo(Parameters::WingsAngle);
-  setStateDoubleFromAlgo(Parameters::InnerRadius);
-  setStateDoubleFromAlgo(Parameters::OuterRadius);
-  setStateDoubleFromAlgo(Parameters::Distance);
-  setStateIntFromAlgo(Parameters::Layers);
-  setStateDoubleFromAlgo(Parameters::LayerStepSize);
-  setStateIntFromAlgo(Parameters::LevelOfDetail);
+  copyAlgoToState({Parameters::Type, Parameters::FigureOf8CoilShape, Parameters::Current,
+    Parameters::Rings, Parameters::WingsAngle, Parameters::InnerRadius, Parameters::OuterRadius,
+    Parameters::Distance, Parameters::Layers, Parameters::LayerStepSize, Parameters::LevelOfDetail});
 }
 
 void ModelTMSCoil::execute()
 {
   AlgorithmOutput output;
 
- if (needToExecute())  //newStatePresent
+ if (needToExecute())
  {
-   auto state = get_state();
-   setAlgoStringFromState(Parameters::Type);
-   setAlgoIntFromState(Parameters::FigureOf8CoilShape);
-   setAlgoDoubleFromState(Parameters::Current);
-   setAlgoIntFromState(Parameters::Rings);
-   setAlgoDoubleFromState(Parameters::WingsAngle);
-   setAlgoDoubleFromState(Parameters::InnerRadius);
-   setAlgoDoubleFromState(Parameters::OuterRadius);
-   setAlgoDoubleFromState(Parameters::Distance);
-   setAlgoIntFromState(Parameters::Layers);
-   setAlgoDoubleFromState(Parameters::LayerStepSize);
-   setAlgoIntFromState(Parameters::LevelOfDetail);
+   copyStateToAlgo({Parameters::Type, Parameters::FigureOf8CoilShape, Parameters::Current,
+     Parameters::Rings, Parameters::WingsAngle, Parameters::InnerRadius, Parameters::OuterRadius,
+     Parameters::Distance, Parameters::Layers, Parameters::LayerStepSize, Parameters::LevelOfDetail});
 
    output = algo().run(AlgorithmInput());
 

src/Modules/BrainStimulator/SetConductivitiesToTetMesh.cc

@@ -51,14 +51,8 @@ SetConductivitiesToMesh::SetConductivitiesToMesh() : Module(ModuleLookupInfo("Se
 
 void SetConductivitiesToMesh::setStateDefaults()
 {
-  setStateDoubleFromAlgo(Parameters::Skin);
-  setStateDoubleFromAlgo(Parameters::SoftBone);
-  setStateDoubleFromAlgo(Parameters::HardBone);
-  setStateDoubleFromAlgo(Parameters::CSF);
-  setStateDoubleFromAlgo(Parameters::GM);
-  setStateDoubleFromAlgo(Parameters::WM);
-  setStateDoubleFromAlgo(Parameters::Electrode);
-  setStateDoubleFromAlgo(Parameters::InternalAir);
+  copyAlgoToState({Parameters::Skin, Parameters::SoftBone, Parameters::HardBone,
+    Parameters::CSF, Parameters::GM, Parameters::WM, Parameters::Electrode, Parameters::InternalAir});
 }
 
 void SetConductivitiesToMesh::execute()
@@ -67,14 +61,8 @@ void SetConductivitiesToMesh::execute()
 
   if (needToExecute())
   {
-    setAlgoDoubleFromState(Parameters::Skin);
-    setAlgoDoubleFromState(Parameters::SoftBone);
-    setAlgoDoubleFromState(Parameters::HardBone);
-    setAlgoDoubleFromState(Parameters::CSF);
-    setAlgoDoubleFromState(Parameters::GM);
-    setAlgoDoubleFromState(Parameters::WM);
-    setAlgoDoubleFromState(Parameters::Electrode);
-    setAlgoDoubleFromState(Parameters::InternalAir);
+    copyStateToAlgo({Parameters::Skin, Parameters::SoftBone, Parameters::HardBone,
+      Parameters::CSF, Parameters::GM, Parameters::WM, Parameters::Electrode, Parameters::InternalAir});
 
     /// algorithm input and run,
     auto input = make_input((InputField, mesh));

src/Modules/BrainStimulator/SetupRHSforTDCSandTMS.cc

@@ -58,13 +58,9 @@ SetupTDCS::SetupTDCS() : Module(ModuleLookupInfo("SetupTDCS", "BrainStimulator",
 
 void SetupTDCS::setStateDefaults()
 {
-  auto state = get_state();
-  setStateIntFromAlgo(Parameters::refnode);
-  setStateDoubleFromAlgo(Parameters::normal_dot_product_bound);
-  setStateDoubleFromAlgo(Parameters::pointdistancebound);
-  setStateIntFromAlgo(Parameters::number_of_electrodes);
-  setStateBoolFromAlgo(Parameters::GetContactSurface);
-  state->setValue(Parameters::SurfaceAreaValues, VariableList());
+  copyAlgoToState({Parameters::refnode, Parameters::normal_dot_product_bound,
+    Parameters::pointdistancebound, Parameters::number_of_electrodes, Parameters::GetContactSurface});
+  get_state()->setValue(Parameters::SurfaceAreaValues, VariableList());
 }
 
 void SetupTDCS::execute()
@@ -86,9 +82,7 @@ void SetupTDCS::execute()
   {
     auto state = get_state();
 
-    setAlgoIntFromState(Parameters::refnode);
-    setAlgoDoubleFromState(Parameters::normal_dot_product_bound);
-    setAlgoDoubleFromState(Parameters::pointdistancebound);
+    copyStateToAlgo({Parameters::refnode, Parameters::normal_dot_product_bound, Parameters::pointdistancebound});
 
     algo().set(Parameters::GetContactSurface, state->getValue(Parameters::GetContactSurface).toBool());
 

src/Modules/Fields/InterfaceWithCleaver.cc

@@ -48,12 +48,10 @@ InterfaceWithCleaver::InterfaceWithCleaver() : Module(staticInfo_)
 
 void InterfaceWithCleaver::setStateDefaults()
 {
-  setStateBoolFromAlgo(InterfaceWithCleaverAlgorithm::Verbose);
-  setStateBoolFromAlgo(InterfaceWithCleaverAlgorithm::Padding);
   setStateStringFromAlgoOption(InterfaceWithCleaverAlgorithm::VolumeScalingOption);
-  setStateDoubleFromAlgo(InterfaceWithCleaverAlgorithm::VolumeScalingX);
-  setStateDoubleFromAlgo(InterfaceWithCleaverAlgorithm::VolumeScalingY);
-  setStateDoubleFromAlgo(InterfaceWithCleaverAlgorithm::VolumeScalingZ);
+  copyAlgoToState({InterfaceWithCleaverAlgorithm::Verbose, InterfaceWithCleaverAlgorithm::Padding,
+    InterfaceWithCleaverAlgorithm::VolumeScalingX, InterfaceWithCleaverAlgorithm::VolumeScalingY,
+    InterfaceWithCleaverAlgorithm::VolumeScalingZ});
 }
 
 void InterfaceWithCleaver::execute()
@@ -62,12 +60,10 @@ void InterfaceWithCleaver::execute()
 
   if (needToExecute())
   {
-    setAlgoBoolFromState(InterfaceWithCleaverAlgorithm::Verbose);
-    setAlgoBoolFromState(InterfaceWithCleaverAlgorithm::Padding);
     setAlgoOptionFromState(InterfaceWithCleaverAlgorithm::VolumeScalingOption);
-    setAlgoDoubleFromState(InterfaceWithCleaverAlgorithm::VolumeScalingX);
-    setAlgoDoubleFromState(InterfaceWithCleaverAlgorithm::VolumeScalingY);
-    setAlgoDoubleFromState(InterfaceWithCleaverAlgorithm::VolumeScalingZ);
+    copyStateToAlgo({InterfaceWithCleaverAlgorithm::Verbose, InterfaceWithCleaverAlgorithm::Padding,
+      InterfaceWithCleaverAlgorithm::VolumeScalingX, InterfaceWithCleaverAlgorithm::VolumeScalingY,
+      InterfaceWithCleaverAlgorithm::VolumeScalingZ});
 
     auto output = algo().run(withInputData((InputFields, fields)));
 

src/Modules/Fields/InterfaceWithCleaver2.cc

@@ -53,15 +53,9 @@ InterfaceWithCleaver2::InterfaceWithCleaver2() : Module(staticInfo_)
 
 void InterfaceWithCleaver2::setStateDefaults()
 {
-  setStateBoolFromAlgo(Parameters::Verbose);
-  setStateBoolFromAlgo(Parameters::SimpleMode);
-  setStateBoolFromAlgo(Parameters::ReverseJacobians);
-  setStateDoubleFromAlgo(Parameters::Lipschitz);
-  setStateDoubleFromAlgo(Parameters::AlphaLong);
-  setStateDoubleFromAlgo(Parameters::AlphaShort);
-  setStateDoubleFromAlgo(Parameters::VolumeScaling);
-  setStateDoubleFromAlgo(Parameters::VolumeMultiplier);
-  setStateIntFromAlgo(Parameters::MeshMode);
+  copyAlgoToState({Parameters::Verbose, Parameters::SimpleMode, Parameters::ReverseJacobians,
+    Parameters::Lipschitz, Parameters::AlphaLong, Parameters::AlphaShort,
+    Parameters::VolumeScaling, Parameters::VolumeMultiplier, Parameters::MeshMode});
 }
 
 void InterfaceWithCleaver2::execute()
@@ -72,15 +66,9 @@ void InterfaceWithCleaver2::execute()
 
   if (needToExecute())
   {
-    setAlgoBoolFromState(Parameters::Verbose);
-    setAlgoBoolFromState(Parameters::SimpleMode);
-    setAlgoBoolFromState(Parameters::ReverseJacobians);
-    setAlgoDoubleFromState(Parameters::Lipschitz);
-    setAlgoDoubleFromState(Parameters::AlphaLong);
-    setAlgoDoubleFromState(Parameters::AlphaShort);
-    setAlgoDoubleFromState(Parameters::VolumeScaling);
-    setAlgoDoubleFromState(Parameters::VolumeMultiplier);
-    setAlgoIntFromState(Parameters::MeshMode);
+    copyStateToAlgo({Parameters::Verbose, Parameters::SimpleMode, Parameters::ReverseJacobians,
+      Parameters::Lipschitz, Parameters::AlphaLong, Parameters::AlphaShort,
+      Parameters::VolumeScaling, Parameters::VolumeMultiplier, Parameters::MeshMode});
 
     auto output = algo().run(withInputData((InputFields, fields)
       (SizingField, optionalAlgoInput(sizing))

src/Modules/Fields/RefineTetMeshLocally.cc

@@ -58,16 +58,11 @@ RefineTetMeshLocally::RefineTetMeshLocally()
 
 void RefineTetMeshLocally::setStateDefaults()
 {
- setStateDoubleFromAlgo(Parameters::RefineTetMeshLocallyIsoValue);
- setStateDoubleFromAlgo(Parameters::RefineTetMeshLocallyEdgeLength);
- setStateDoubleFromAlgo(Parameters::RefineTetMeshLocallyVolume);
- setStateDoubleFromAlgo(Parameters::RefineTetMeshLocallyDihedralAngleSmaller);
- setStateDoubleFromAlgo(Parameters::RefineTetMeshLocallyDihedralAngleBigger);
- setStateIntFromAlgo(Parameters::RefineTetMeshLocallyMaxNumberRefinementIterations);
- setStateIntFromAlgo(Parameters::RefineTetMeshLocallyRadioButtons);
- setStateBoolFromAlgo(Parameters::RefineTetMeshLocallyDoNoSplitSurfaceTets);
- setStateBoolFromAlgo(Parameters::RefineTetMeshLocallyCounterClockWiseOrdering);
- setStateBoolFromAlgo(Parameters::RefineTetMeshLocallyUseModuleInputField);
+  copyAlgoToState({Parameters::RefineTetMeshLocallyIsoValue, Parameters::RefineTetMeshLocallyEdgeLength,
+    Parameters::RefineTetMeshLocallyVolume, Parameters::RefineTetMeshLocallyDihedralAngleSmaller,
+    Parameters::RefineTetMeshLocallyDihedralAngleBigger, Parameters::RefineTetMeshLocallyMaxNumberRefinementIterations,
+    Parameters::RefineTetMeshLocallyRadioButtons, Parameters::RefineTetMeshLocallyDoNoSplitSurfaceTets,
+    Parameters::RefineTetMeshLocallyCounterClockWiseOrdering, Parameters::RefineTetMeshLocallyUseModuleInputField});
 }
 
 void RefineTetMeshLocally::execute()
@@ -76,15 +71,11 @@ void RefineTetMeshLocally::execute()
 
   if (needToExecute())
   {
-    setAlgoDoubleFromState(Parameters::RefineTetMeshLocallyIsoValue);
-    setAlgoDoubleFromState(Parameters::RefineTetMeshLocallyEdgeLength);
-    setAlgoDoubleFromState(Parameters::RefineTetMeshLocallyVolume);
-    setAlgoDoubleFromState(Parameters::RefineTetMeshLocallyDihedralAngleSmaller);
-    setAlgoDoubleFromState(Parameters::RefineTetMeshLocallyDihedralAngleBigger);
-    setAlgoBoolFromState(Parameters::RefineTetMeshLocallyDoNoSplitSurfaceTets);
-    setAlgoBoolFromState(Parameters::RefineTetMeshLocallyCounterClockWiseOrdering);
-    setAlgoBoolFromState(Parameters::RefineTetMeshLocallyUseModuleInputField);
-    setAlgoIntFromState(Parameters::RefineTetMeshLocallyMaxNumberRefinementIterations);
+    copyStateToAlgo({Parameters::RefineTetMeshLocallyIsoValue, Parameters::RefineTetMeshLocallyEdgeLength,
+      Parameters::RefineTetMeshLocallyVolume, Parameters::RefineTetMeshLocallyDihedralAngleSmaller,
+      Parameters::RefineTetMeshLocallyDihedralAngleBigger, Parameters::RefineTetMeshLocallyDoNoSplitSurfaceTets,
+      Parameters::RefineTetMeshLocallyCounterClockWiseOrdering, Parameters::RefineTetMeshLocallyUseModuleInputField,
+      Parameters::RefineTetMeshLocallyMaxNumberRefinementIterations});
     auto RadioButton = (get_state()->getValue(Parameters::RefineTetMeshLocallyRadioButtons)).toInt();
     if (RadioButton == -1)
       RadioButton = 0;

src/Modules/Legacy/Converters/ConvertBundleToField.cc

@@ -77,12 +77,8 @@ ConvertBundleToField::ConvertBundleToField() :
 
 void ConvertBundleToField::setStateDefaults()
 {
-  auto state = get_state();
-  setStateBoolFromAlgo(Parameters::MergeNodes);
-  setStateBoolFromAlgo(Parameters::MatchNodeValues);
-  setStateBoolFromAlgo(Parameters::MakeNoData);
-  setStateDoubleFromAlgo(Parameters::Tolerance);
-  state->setValue(Fields::Parameters::ForcePointCloud, false);
+  copyAlgoToState({Parameters::MergeNodes, Parameters::MatchNodeValues, Parameters::MakeNoData, Parameters::Tolerance});
+  get_state()->setValue(Fields::Parameters::ForcePointCloud, false);
 }
 
 void ConvertBundleToField::execute()
@@ -91,10 +87,7 @@ void ConvertBundleToField::execute()
 
   if (needToExecute())
   {
-    setAlgoBoolFromState(Parameters::MakeNoData);
-    setAlgoBoolFromState(Parameters::MergeNodes);
-    setAlgoBoolFromState(Parameters::MatchNodeValues);
-    setAlgoDoubleFromState(Parameters::Tolerance);
+    copyStateToAlgo({Parameters::MakeNoData, Parameters::MergeNodes, Parameters::MatchNodeValues, Parameters::Tolerance});
 
     auto output = algo().run(withInputData((InputBundle, bundle)));
     auto outputField = output.get<Field>(Core::Algorithms::AlgorithmParameterName(OutputField));

src/Modules/Legacy/Fields/GetDomainBoundary.cc

@@ -53,15 +53,9 @@ GetDomainBoundary::GetDomainBoundary()
 
 void GetDomainBoundary::setStateDefaults()
 {
-  setStateIntFromAlgo(Parameters::MinRange);
-  setStateIntFromAlgo(Parameters::MaxRange);
-  setStateIntFromAlgo(Parameters::Domain);
-
-  setStateBoolFromAlgo(Parameters::UseRange);
-  setStateBoolFromAlgo(Parameters::AddOuterBoundary);
-  setStateBoolFromAlgo(Parameters::InnerBoundaryOnly);
-  setStateBoolFromAlgo(Parameters::NoInnerBoundary);
-  setStateBoolFromAlgo(Parameters::DisconnectBoundaries);
+  copyAlgoToState({Parameters::MinRange, Parameters::MaxRange, Parameters::Domain,
+    Parameters::UseRange, Parameters::AddOuterBoundary, Parameters::InnerBoundaryOnly,
+    Parameters::NoInnerBoundary, Parameters::DisconnectBoundaries});
 }
 
 void GetDomainBoundary::execute()
@@ -101,17 +95,11 @@ void GetDomainBoundary::execute()
       get_state()->setValue(Parameters::MaxRange, maxrange);
     }
 
-    auto state = get_state();
-
-    setAlgoIntFromState(Parameters::MinRange);
-    setAlgoIntFromState(Parameters::MaxRange);
-    setAlgoIntFromState(Parameters::Domain);
-    setAlgoBoolFromState(Parameters::UseRange);
-    setAlgoBoolFromState(Parameters::AddOuterBoundary);
-    setAlgoBoolFromState(Parameters::InnerBoundaryOnly);
-    setAlgoBoolFromState(Parameters::NoInnerBoundary);
-    setAlgoBoolFromState(Parameters::DisconnectBoundaries);
+    copyStateToAlgo({Parameters::MinRange, Parameters::MaxRange, Parameters::Domain,
+      Parameters::UseRange, Parameters::AddOuterBoundary, Parameters::InnerBoundaryOnly,
+      Parameters::NoInnerBoundary, Parameters::DisconnectBoundaries});
 
+    auto state = get_state();
     if (!state->getValue(Parameters::UseRange).toBool())
     {
       int guiValue = state->getValue(Parameters::Domain).toInt();

src/Modules/Legacy/Fields/JoinFields.cc

@@ -49,11 +49,8 @@ JoinFields::JoinFields() : Module(staticInfo_)
 
 void JoinFields::setStateDefaults()
 {
-  setStateBoolFromAlgo(Parameters::merge_elems);
-  setStateBoolFromAlgo(Parameters::merge_nodes);
-  setStateBoolFromAlgo(Parameters::match_node_values);
-  setStateBoolFromAlgo(Parameters::make_no_data);
-  setStateDoubleFromAlgo(Parameters::tolerance);
+  copyAlgoToState({Parameters::merge_elems, Parameters::merge_nodes, Parameters::match_node_values,
+    Parameters::make_no_data, Parameters::tolerance});
   get_state()->setValue(Parameters::ForcePointCloud, false);
 }
 
@@ -65,11 +62,8 @@ void JoinFields::execute()
   {
     bool forcepointcloud = get_state()->getValue(Parameters::ForcePointCloud).toBool();
 
-    setAlgoBoolFromState(Parameters::merge_elems);
-    setAlgoBoolFromState(Parameters::match_node_values);
-    setAlgoBoolFromState(Parameters::merge_nodes);
-    setAlgoBoolFromState(Parameters::make_no_data);
-    setAlgoDoubleFromState(Parameters::tolerance);
+    copyStateToAlgo({Parameters::merge_elems, Parameters::match_node_values, Parameters::merge_nodes,
+      Parameters::make_no_data, Parameters::tolerance});
 
     auto output = algo().run(withInputData((InputFields, fields)));
     auto outputField = output.get<Field>(Core::Algorithms::AlgorithmParameterName(OutputField));