simpler local vars

GUI/Model/ToCore/SimulationToCore.cpp

@@ -53,37 +53,37 @@ void setParameterDistributionToSimulation(ParameterDistribution::WhichParameter
 }
 
 //! adds DistributionParameters to the ISimulation
-void addDistributionParametersToSimulation(const BeamItem& beam_item,
+void addDistributionParametersToSimulation(const BeamItem& item,
                                            ScatteringSimulation& simulation)
 {
-    ASSERT(dynamic_cast<const GISASBeamItem*>(&beam_item));
+    ASSERT(dynamic_cast<const GISASBeamItem*>(&item));
 
     setParameterDistributionToSimulation<BeamWavelengthItem>(
-        ParameterDistribution::BeamWavelength, beam_item.wavelengthItem(), simulation);
+        ParameterDistribution::BeamWavelength, item.wavelengthItem(), simulation);
     setParameterDistributionToSimulation<BeamInclinationAngleItem>(
-        ParameterDistribution::BeamInclinationAngle, beam_item.inclinationAngleItem(), simulation);
+        ParameterDistribution::BeamInclinationAngle, item.inclinationAngleItem(), simulation);
     setParameterDistributionToSimulation<BeamAzimuthalAngleItem>(
-        ParameterDistribution::BeamAzimuthalAngle, beam_item.azimuthalAngleItem(), simulation);
+        ParameterDistribution::BeamAzimuthalAngle, item.azimuthalAngleItem(), simulation);
 }
 
-void addBackgroundToSimulation(const InstrumentItem& instrumentItem, ISimulation& simulation)
+void addBackgroundToSimulation(const InstrumentItem& item, ISimulation& simulation)
 {
 
-    if (const auto background = instrumentItem.backgroundItem()->createBackground())
+    if (const auto background = item.backgroundItem()->createBackground())
         simulation.setBackground(*background);
 }
 
-std::unique_ptr<ScanResolution> createScanResolution(const BeamDistributionItem* beam_item)
+std::unique_ptr<ScanResolution> createScanResolution(const BeamDistributionItem* item)
 {
-    if (!beam_item)
+    if (!item)
         return nullptr;
 
     const auto* distr_item =
-        dynamic_cast<const SymmetricResolutionItem*>(beam_item->distribution());
+        dynamic_cast<const SymmetricResolutionItem*>(item->distribution());
     if (!distr_item)
         return nullptr;
 
-    const double scale = beam_item->scaleFactor();
+    const double scale = item->scaleFactor();
     auto ranged_distr = distr_item->createIRangedDistribution(scale);
     if (!ranged_distr)
         return nullptr;
@@ -93,60 +93,60 @@ std::unique_ptr<ScanResolution> createScanResolution(const BeamDistributionItem*
         ScanResolution::scanAbsoluteResolution(*ranged_distr, deviation));
 }
 
-void addBeamDivergencesToScan(const BeamItem& beam_item, AlphaScan& scan)
+void addBeamDivergencesToScan(const BeamItem& item, AlphaScan& scan)
 {
-    ASSERT(dynamic_cast<const SpecularBeamItem*>(&beam_item));
+    ASSERT(dynamic_cast<const SpecularBeamItem*>(&item));
 
-    if (const auto resolution = createScanResolution(beam_item.wavelengthItem()))
+    if (const auto resolution = createScanResolution(item.wavelengthItem()))
         scan.setWavelengthResolution(*resolution);
-    if (const auto resolution = createScanResolution(beam_item.inclinationAngleItem()))
+    if (const auto resolution = createScanResolution(item.inclinationAngleItem()))
         scan.setAngleResolution(*resolution);
 }
 
-void setSimulationOptions(ISimulation* simulation, const SimulationOptionsItem& optionItem)
+void setSimulationOptions(ISimulation* simulation, const SimulationOptionsItem& item)
 {
-    simulation->options().setNumberOfThreads(optionItem.numberOfThreads());
-    if (optionItem.useMonteCarloIntegration())
-        simulation->options().setMonteCarloIntegration(true, optionItem.numberOfMonteCarloPoints());
-    simulation->options().setUseAvgMaterials(optionItem.useAverageMaterials());
-    simulation->options().setIncludeSpecular(optionItem.includeSpecularPeak());
+    simulation->options().setNumberOfThreads(item.numberOfThreads());
+    if (item.useMonteCarloIntegration())
+        simulation->options().setMonteCarloIntegration(true, item.numberOfMonteCarloPoints());
+    simulation->options().setUseAvgMaterials(item.useAverageMaterials());
+    simulation->options().setIncludeSpecular(item.includeSpecularPeak());
 }
 
 ScatteringSimulation* createScatteringSimulation(std::unique_ptr<MultiLayer> sample,
-                                                 const GISASInstrumentItem* instrumentItem)
+                                                 const GISASInstrumentItem* item)
 {
-    ScatteringSimulation* result = instrumentItem->createScatteringSimulation(*sample);
+    ScatteringSimulation* result = item->createScatteringSimulation(*sample);
 
-    addDistributionParametersToSimulation(*instrumentItem->beamItem(), *result);
+    addDistributionParametersToSimulation(*item->beamItem(), *result);
 
-    addBackgroundToSimulation(*instrumentItem, *result);
+    addBackgroundToSimulation(*item, *result);
 
     return result;
 }
 
 OffspecSimulation* createOffspecSimulation(std::unique_ptr<MultiLayer> sample,
-                                           const OffspecInstrumentItem* instrumentItem)
+                                           const OffspecInstrumentItem* item)
 {
-    OffspecSimulation* result = instrumentItem->createOffspecSimulation(*sample);
+    OffspecSimulation* result = item->createOffspecSimulation(*sample);
 
-    auto* beamItem = instrumentItem->beamItem();
-    const auto axis = instrumentItem->alphaAxis().createAxis(Units::deg);
+    auto* beamItem = item->beamItem();
+    const auto axis = item->alphaAxis().createAxis(Units::deg);
     result->setBeamParameters(beamItem->wavelength(), *axis, beamItem->getAzimuthalAngle());
 
     // TODO Take care about distributions
     // addDistributionParametersToSimulation(*gisasInstrument->beamItem(),
     //                                                          gisas.get());
 
-    addBackgroundToSimulation(*instrumentItem, *result);
+    addBackgroundToSimulation(*item, *result);
 
     return result;
 }
 
 SpecularSimulation* createSpecularSimulation(std::unique_ptr<MultiLayer> sample,
-                                             const SpecularInstrumentItem* instrument)
+                                             const SpecularInstrumentItem* item)
 {
-    auto* beam_item = instrument->beamItem();
-    auto* const axis_item = beam_item->inclinationAxis();
+    auto* beam_item = item->beamItem();
+
     auto* const footprint = beam_item->footprint();
 
     AlphaScan scan(beam_item->wavelength(), *axis_item->createAxis(Units::deg));
@@ -157,15 +157,15 @@ SpecularSimulation* createSpecularSimulation(std::unique_ptr<MultiLayer> sample,
     auto* result = new SpecularSimulation(scan, *sample);
     result->beam().setIntensity(beam_item->intensity());
 
-    addBackgroundToSimulation(*instrument, *result);
+    addBackgroundToSimulation(*item, *result);
 
     return result;
 }
 
 DepthProbeSimulation* createDepthProbeSimulation(std::unique_ptr<MultiLayer> sample,
-                                                 const DepthProbeInstrumentItem* instrument)
+                                                 const DepthProbeInstrumentItem* item)
 {
-    return instrument->createSimulation(*sample);
+    return item->createSimulation(*sample);
 }
 
 } // namespace