Skip to content
Snippets Groups Projects
Commit 50fded7c authored by Matthias Puchner's avatar Matthias Puchner
Browse files

free BeamDistributionItem from SessionItem

parent 5e33a600
No related branches found
No related tags found
1 merge request!624Remove SessionItem from Instrument items
Hide whitespace changes
Inline Side-by-side
GUI/Model/Item/BeamDistributionItem.cpp
+ 21
− 124
View file @ 50fded7c
...@@ -14,167 +14,64 @@ ...@@ -14,167 +14,64 @@
#include "GUI/Model/Item/BeamDistributionItem.h" #include "GUI/Model/Item/BeamDistributionItem.h"
#include "GUI/Model/BaseItem/GroupItem.h" #include "GUI/Model/BaseItem/GroupItem.h"
#include "GUI/Model/MakeItem/DistributionItemCatalog.h"
#include "GUI/Model/Types/DoubleDescriptor.h" #include "GUI/Model/Types/DoubleDescriptor.h"
#include "Param/Distrib/Distributions.h" #include "Param/Distrib/Distributions.h"
namespace {
// create a GroupInfo containing all distributions
GroupInfo createAllDistributionsGroup()
{
GroupInfo info;
info.add(DistributionNoneItem::M_TYPE, "None");
info.add(DistributionGateItem::M_TYPE, "Gate");
info.add(DistributionLorentzItem::M_TYPE, "Lorentz");
info.add(DistributionGaussianItem::M_TYPE, "Gaussian");
info.add(DistributionLogNormalItem::M_TYPE, "Log Normal");
info.add(DistributionCosineItem::M_TYPE, "Cosine");
info.add(DistributionTrapezoidItem::M_TYPE, "Trapezoid");
info.setDefaultType(DistributionNoneItem::M_TYPE);
return info;
}
// create a GroupInfo containing all symmetric distributions
GroupInfo createSymmetricDistributionsGroup()
{
GroupInfo info;
info.add(DistributionNoneItem::M_TYPE, "None");
info.add(DistributionLorentzItem::M_TYPE, "Lorentz");
info.add(DistributionGaussianItem::M_TYPE, "Gaussian");
info.add(DistributionCosineItem::M_TYPE, "Cosine");
info.setDefaultType(DistributionNoneItem::M_TYPE);
return info;
}
} // namespace
BeamDistributionItem::BeamDistributionItem(const QString& name)
: SessionItem(name)
{
mapper()->setOnChildPropertyChange([this](SessionItem* item, const QString&) {
if (item->hasModelType<GroupItem>() && item->parent() == this)
initDistributionItem();
});
}
//! returns parameter distribution to add into the ISimulation
std::unique_ptr<ParameterDistribution> BeamDistributionItem::getParameterDistributionForName( std::unique_ptr<ParameterDistribution> BeamDistributionItem::getParameterDistributionForName(
ParameterDistribution::WhichParameter which) const ParameterDistribution::WhichParameter which) const
{ {
std::unique_ptr<ParameterDistribution> P_par_distr{}; if (const auto* d = distribution()) {
if (auto* distributionItem = dynamic_cast<ResolutionItem*>(getGroupItem(P_DISTRIBUTION))) { auto distribution1D = createDistribution1D();
auto P_distribution = createDistribution1D();
if (P_distribution) { if (distribution1D) {
size_t nbr_samples = distributionItem->numberOfSamples(); const auto nbrOfSamples = d->numberOfSamples();
double sigma_factor(0); const double sigmaFactor = d->hasSigmaFactor() ? d->sigmaFactor() : 0.0;
if (distributionItem->hasSigmaFactor()) const auto limits = d->limits(scaleFactor());
sigma_factor = distributionItem->sigmaFactor();
const auto limits = distributionItem->createRealLimits(scaleFactor()); return std::make_unique<ParameterDistribution>(which, *distribution1D, nbrOfSamples,
sigmaFactor, limits);
P_par_distr = std::make_unique<ParameterDistribution>(
which, *P_distribution, nbr_samples, sigma_factor, limits);
} }
} }
return P_par_distr; return {};
}
void BeamDistributionItem::initDistributionItem()
{
auto* groupItem = item<GroupItem>(P_DISTRIBUTION);
DistributionNoneItem* distributionNone = nullptr;
for (auto* item : groupItem->groupItems()) {
if (item->modelType() == DistributionNoneItem::M_TYPE) {
distributionNone = dynamic_cast<DistributionNoneItem*>(item);
break;
}
}
if (!distributionNone)
return;
const RealLimits limits = distributionNone->meanItem()->limits();
for (auto* item : groupItem->groupItems()) {
auto* distrItem = dynamic_cast<ResolutionItem*>(item);
distrItem->setUnit(distributionNone->unit());
if (item == distributionNone)
continue;
distrItem->init_parameters(distributionNone->mean(), limits);
if (auto* symmetric_distr = dynamic_cast<SymmetricResolutionItem*>(distrItem))
symmetric_distr->meanItem()->setLimits(limits);
}
} }
//! Returns mean value of the distribution.
double BeamDistributionItem::meanValue() const double BeamDistributionItem::meanValue() const
{ {
std::unique_ptr<IDistribution1D> domainDistr = createDistribution1D(); std::unique_ptr<IDistribution1D> domainDistr = createDistribution1D();
if (domainDistr) if (domainDistr)
return domainDistr->mean() / scaleFactor(); return domainDistr->mean() / scaleFactor();
return dynamic_cast<SymmetricResolutionItem*>(getGroupItem(P_DISTRIBUTION))->mean(); return dynamic_cast<SymmetricResolutionItem*>(distribution())->mean();
} }
void BeamDistributionItem::resetToValue(double value) void BeamDistributionItem::resetToValue(double value)
{ {
auto* distributionItem = dynamic_cast<DistributionNoneItem*>( auto* d = new DistributionNoneItem();
setGroupProperty(P_DISTRIBUTION, DistributionNoneItem::M_TYPE)); d->setMean(value);
ASSERT(distributionItem); m_distribution.set(d);
distributionItem->setMean(value);
} }
//! Scales the values provided by distribution (to perform deg->rad conversion in the case
//! of AngleDistributionItems.
double BeamDistributionItem::scaleFactor() const double BeamDistributionItem::scaleFactor() const
{ {
return 1.0; return 1.0;
} }
ResolutionItem* BeamDistributionItem::distribution() const DistributionItem* BeamDistributionItem::distribution() const
{
return dynamic_cast<ResolutionItem*>(getGroupItem(P_DISTRIBUTION));
}
ResolutionItem* BeamDistributionItem::setDistributionType(const QString& model_type)
{ {
ASSERT(model_type == DistributionGateItem::M_TYPE return m_distribution.get();
|| model_type == DistributionLogNormalItem::M_TYPE
|| model_type == DistributionTrapezoidItem::M_TYPE
|| model_type == DistributionCosineItem::M_TYPE
|| model_type == DistributionGaussianItem::M_TYPE
|| model_type == DistributionLorentzItem::M_TYPE
|| model_type == DistributionNoneItem::M_TYPE);
return dynamic_cast<ResolutionItem*>(setGroupProperty(P_DISTRIBUTION, model_type));
} }
SessionItem* BeamDistributionItem::distributionItem() const SelectionDescriptor<DistributionItem*> BeamDistributionItem::distributionSelection() const
{ {
return getItem(P_DISTRIBUTION); return m_distribution;
} }
void BeamDistributionItem::register_distribution_group(const Distributions distributions) void BeamDistributionItem::setDistribution(DistributionItem* d)
{ {
if (distributions == Distributions::All) { m_distribution.set(d);
static const GroupInfo all = createAllDistributionsGroup();
addGroupProperty(P_DISTRIBUTION, all);
} else if (distributions == Distributions::Symmetric) {
static const GroupInfo symmetric = createSymmetricDistributionsGroup();
addGroupProperty(P_DISTRIBUTION, symmetric);
} else
ASSERT(false);
} }
std::unique_ptr<IDistribution1D> BeamDistributionItem::createDistribution1D() const std::unique_ptr<IDistribution1D> BeamDistributionItem::createDistribution1D() const
{ {
if (auto* distItem = dynamic_cast<ResolutionItem*>(getGroupItem(P_DISTRIBUTION))) return distribution()->createDistribution(scaleFactor());
return distItem->createDistribution(scaleFactor());
return {};
} }
GUI/Model/Item/BeamDistributionItem.h
+ 11
− 21
View file @ 50fded7c
...@@ -15,19 +15,16 @@ ...@@ -15,19 +15,16 @@
#ifndef BORNAGAIN_GUI_MODEL_ITEM_BEAMDISTRIBUTIONITEM_H #ifndef BORNAGAIN_GUI_MODEL_ITEM_BEAMDISTRIBUTIONITEM_H
#define BORNAGAIN_GUI_MODEL_ITEM_BEAMDISTRIBUTIONITEM_H #define BORNAGAIN_GUI_MODEL_ITEM_BEAMDISTRIBUTIONITEM_H
#include "GUI/Model/Item/ItemWithDistribution.h" #include "GUI/Model/Group/SelectionProperty.h"
#include "GUI/Model/Item/ResolutionItems.h" #include "GUI/Model/Item/DistributionItems.h"
#include "Param/Distrib/ParameterDistribution.h" #include "Param/Distrib/ParameterDistribution.h"
//! The BeamDistributionItem handles wavelength, inclination and azimuthal parameter //! The BeamDistributionItem handles wavelength, inclination and azimuthal parameter
//! distribution for BeamItem //! distribution for BeamItem
class BA_CORE_API_ BeamDistributionItem : public SessionItem, public ItemWithDistribution { class BeamDistributionItem {
private:
static constexpr auto P_DISTRIBUTION{"Distribution"};
public: public:
explicit BeamDistributionItem(const QString& name); virtual ~BeamDistributionItem() = default;
std::unique_ptr<ParameterDistribution> std::unique_ptr<ParameterDistribution>
getParameterDistributionForName(ParameterDistribution::WhichParameter which) const; getParameterDistributionForName(ParameterDistribution::WhichParameter which) const;
...@@ -37,28 +34,21 @@ public: ...@@ -37,28 +34,21 @@ public:
virtual double scaleFactor() const; virtual double scaleFactor() const;
ResolutionItem* distribution() const override;
ResolutionItem* setDistributionType(const QString& model_type) override;
template <typename T> T* setDistributionType(); template <typename T> T* setDistributionType();
SessionItem* distributionItem() const; DistributionItem* distribution() const;
SelectionDescriptor<DistributionItem*> distributionSelection() const;
void setDistribution(DistributionItem* d);
protected: protected:
enum class Distributions { All, Symmetric };
void register_distribution_group(Distributions distributions);
//! Propagates value, limits etc. stored in DistributionNone type into alls distributions.
void initDistributionItem();
virtual std::unique_ptr<IDistribution1D> createDistribution1D() const; virtual std::unique_ptr<IDistribution1D> createDistribution1D() const;
SelectionProperty<DistributionItem*> m_distribution;
}; };
template <typename T> T* BeamDistributionItem::setDistributionType() template <typename T> T* BeamDistributionItem::setDistributionType()
{ {
static_assert(std::is_base_of<ResolutionItem, T>::value, m_distribution.set<T>();
"Class must be derived from ResolutionItem"); return dynamic_cast<T*>(m_distribution.get());
return setGroupPropertyType<T>(P_DISTRIBUTION);
} }
#endif // BORNAGAIN_GUI_MODEL_ITEM_BEAMDISTRIBUTIONITEM_H #endif // BORNAGAIN_GUI_MODEL_ITEM_BEAMDISTRIBUTIONITEM_H
GUI/Model/Item/ItemWithDistribution.h deleted 100644 → 0
+ 0
− 35
View file @ 5e33a600
// ************************************************************************************************
//
// BornAgain: simulate and fit reflection and scattering
//
//! @file GUI/Model/Item/ItemWithDistribution.h
//! @brief Defines abstract item with a distribution
//!
//! @homepage http://www.bornagainproject.org
//! @license GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
// ************************************************************************************************
#ifndef BORNAGAIN_GUI_MODEL_ITEM_ITEMWITHDISTRIBUTION_H
#define BORNAGAIN_GUI_MODEL_ITEM_ITEMWITHDISTRIBUTION_H
#include "Wrap/WinDllMacros.h"
#include <QString>
class ResolutionItem;
/// Abstract interface of an item with a distribution property
class BA_CORE_API_ ItemWithDistribution {
public:
virtual ResolutionItem* distribution() const = 0;
virtual ResolutionItem* setDistributionType(const QString& model_type) = 0;
virtual ~ItemWithDistribution() = default;
};
#endif // BORNAGAIN_GUI_MODEL_ITEM_ITEMWITHDISTRIBUTION_H
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment