d3f_util_plugin.cpp

/* 
 * SPDX-FileCopyrightText: 2025 Gesellschaft fuer Anlagen- und Reaktorsicherheit gGmbH
 * SPDX-License-Identifier: EUPL-1.2
 * SPDX-FileContributor: Julian Hilbert
 * SPDX-FileContributor: Goethe Universität Frankfurt
 * SPDX-FileType: SOURCE
 * 
 * This file is part of d3f++.
 * d3f++ is an extension for UG4. Licensing information and citation requirements of UG4 are provided in LICENSES/UG4-LGPL_2.1
 */


#include "bridge/util.h"
#include "bridge/util_domain_dependent.h"
#include "bridge/util_domain_algebra_dependent.h"
#include "common/ug_config.h"
#include "common/error.h"
#include "util/subset_user_data.h"
#include "d3f_util_plugin.h"
using namespace std;
using namespace ug::bridge;

namespace ug{
    namespace d3f_util{

        template <typename TData, typename TDomain, typename TTraits=user_data_traits<TData> >
        void RegisterSubsetUserData(Registry& reg, string grp)
        {   static const int dim = TDomain::dim;
            string dimSuffix = GetDimensionSuffix<dim>();
            string dimTag = GetDimensionTag<dim>();

            string type = TTraits::name();

            //	ScaleAddLinker"Type"
            {
                typedef SubsetUserData<TData, TDomain> T;
                typedef typename T::TUserData TUserData;
                typedef DependentUserData<TData, dim> TBase;
                string name = string("SubsetUserData").append(type).append(dimSuffix);
                reg.add_class_<T, TBase>(name, grp)
                    .add_constructor()
                    .template add_constructor<void (*)(const SubsetUserData<TData, TDomain>&)>()
                    .add_method("insert", static_cast<void (T::*)(SmartPtr<CplUserData<TData, dim>>, size_t)>(&T::insert))
                    .add_method("set_domain", static_cast<void (T::*)(SmartPtr<TDomain>)>(&T::set_domain))
				    .set_construct_as_smart_pointer(true);
                reg.add_class_to_group(name, string("SubsetUserData").append(type), dimTag);
            }

        }
/**
 * Class exporting the functionality. All functionality that is to
 * be used in scripts or visualization must be registered here.
 */
        struct FunctionalityUtil
        {



/**
 * Function called for the registration of Dimension dependent parts.
 * All Functions and Classes depending on the Dimension
 * are to be placed here when registering. The method is called for all
 * available Dimension types, based on the current build options.
 *
 * @param reg				registry
 * @param parentGroup		group for sorting of functionality
 */
            template <typename TDomain>
            static void Domain(Registry& reg, string grp)
            {
                string suffix = GetDomainSuffix<TDomain>();
                string tag = GetDomainTag<TDomain>();
                static const int dim = TDomain::dim;
                RegisterSubsetUserData<number, TDomain>(reg, grp);
                RegisterSubsetUserData<MathVector<dim>, TDomain>(reg, grp);
                RegisterSubsetUserData<MathMatrix<dim, dim>, TDomain>(reg, grp);
                RegisterSubsetUserData<MathTensor<4,dim>, TDomain>(reg, grp);


            }
            static void Common(Registry& reg, string grp)
            {



            }


        }; // end Functionality

// end group plugin_template
/// \}

    } // end namespace RiverNetworks


/**
 * This function is called when the plugin is loaded.
 */
    void
    InitUGPlugin_d3f_Util(Registry* reg, string grp)
    {
        grp.append("/SpatialDisc/d3f");
        typedef d3f_util::FunctionalityUtil FunctionalityUtil;

        try{
            RegisterCommon<FunctionalityUtil>(*reg,grp);
            RegisterDomainDependent<FunctionalityUtil>(*reg,grp);

        }
        UG_REGISTRY_CATCH_THROW(grp);
    }

}// namespace ug