Add support for 'CaseFunction' written in C#

arcane/src/arcane/core/CaseFunction2.h

@@ -0,0 +1,116 @@
+// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
+//-----------------------------------------------------------------------------
+// Copyright 2000-2023 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
+// See the top-level COPYRIGHT file for details.
+// SPDX-License-Identifier: Apache-2.0
+//-----------------------------------------------------------------------------
+/*---------------------------------------------------------------------------*/
+/* CaseFunction2.h                                             (C) 2000-2023 */
+/*                                                                           */
+/* Fonction du jeu de données avec type de valeur explicite.                 */
+/*---------------------------------------------------------------------------*/
+#ifndef ARCANE_CORE_CASEFUNCTION2_H
+#define ARCANE_CORE_CASEFUNCTION2_H
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
+#include "arcane/utils/Real3.h"
+#include "arcane/core/CaseFunction.h"
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
+namespace Arcane
+{
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+/*!
+ * \internal
+ * \brief Implémentation de CaseFunction permettant de retourner directement
+ * la valeur associée à un paramètre sans passer par une référence.
+ *
+ * Cela est principalement utilisé pour simplifier les extensions C# en évitant
+ * les différentes surcharges de value().
+ *
+ * Pour utiliser cette classe, il faut implémenter les méthodes 'valueAs*'
+ * pour les deux types d'argument \a Integer et \a Real et pour les
+ * différents types de retour possibles.
+ */
+class ARCANE_CORE_EXPORT CaseFunction2
+: public CaseFunction
+{
+ public:
+
+  //! Construit une fonction du jeu de données.
+  explicit CaseFunction2(const CaseFunctionBuildInfo& cfbi)
+  : CaseFunction(cfbi)
+  {}
+
+ protected:
+
+  void value(Real param, Real& v) const override
+  {
+    v = valueAsReal(param);
+  }
+  void value(Real param, Integer& v) const override
+  {
+    v = valueAsInteger(param);
+  }
+  void value(Real param, bool& v) const override
+  {
+    v = valueAsBool(param);
+  }
+  void value(Real param, String& v) const override
+  {
+    v = valueAsString(param);
+  }
+  void value(Real param, Real3& v) const override
+  {
+    v = valueAsReal3(param);
+  }
+  void value(Integer param, Real& v) const override
+  {
+    v = valueAsReal(param);
+  }
+  void value(Integer param, Integer& v) const override
+  {
+    v = valueAsInteger(param);
+  }
+  void value(Integer param, bool& v) const override
+  {
+    v = valueAsBool(param);
+  }
+  void value(Integer param, String& v) const override
+  {
+    v = valueAsString(param);
+  }
+  void value(Integer param, Real3& v) const override
+  {
+    v = valueAsReal3(param);
+  }
+
+ public:
+
+  virtual Real valueAsReal(Real param) const = 0;
+  virtual Integer valueAsInteger(Real param) const = 0;
+  virtual bool valueAsBool(Real param) const = 0;
+  virtual String valueAsString(Real param) const = 0;
+  virtual Real3 valueAsReal3(Real param) const = 0;
+
+  virtual Real valueAsReal(Integer param) const = 0;
+  virtual Integer valueAsInteger(Integer param) const = 0;
+  virtual bool valueAsBool(Integer param) const = 0;
+  virtual String valueAsString(Integer param) const = 0;
+  virtual Real3 valueAsReal3(Integer param) const = 0;
+};
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
+} // namespace Arcane
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
+#endif

arcane/src/arcane/core/InterfaceImpl.cc

@@ -93,6 +93,7 @@
 #include "arcane/core/IPhysicalUnitConverter.h"
 #include "arcane/core/IPhysicalUnit.h"
 #include "arcane/core/IStandardFunction.h"
+#include "arcane/core/CaseFunction2.h"
 #include "arcane/core/IServiceAndModuleFactoryMng.h"
 #include "arcane/core/IGhostLayerMng.h"
 #include "arcane/core/IMeshUniqueIdMng.h"

arcane/src/arcane/core/srcs.cmake

@@ -393,6 +393,7 @@ set(ARCANE_ORIGINAL_SOURCES
   CaseDatasetSource.h
   CaseFunction.cc
   CaseFunction.h
+  CaseFunction2.h
   CaseOptions.h
   CaseOptionServiceImpl.h
   CaseOptionTypes.h

arcane/src/arcane/tests/CMakeLists.txt

@@ -695,6 +695,7 @@ if (ARCANE_HAS_DOTNET_TESTS)
   if (ARCANE_HAS_TASKS)
     arcane_add_csharp_test_sequential(hydro_cs_task testSimpleHydroCS-1.arc -m 15 -K 4)
   endif()
+  arcane_add_csharp_test_sequential(casefunction_cs testCaseFunctionModule-1.arc)
 endif()
 
 arcane_add_test_parallel(loadbalance_test1 testLoadBalanceHydro-MeshPartitionerTester.arc 4 -m 30)

arcane/src/arcane/tests/CaseFunctionTester.axl

@@ -0,0 +1,19 @@
+<?xml version="1.0" ?><!-- -*- SGML -*- -->
+
+<module name="CaseFunctionTester" version="1.0" namespace-name="ArcaneTest"> 
+  <description>
+    Module de test des 'ICaseFunction'.
+  </description>
+
+  <options>
+    <simple name="real-time-multiply-2" type="real">
+      <description>Fonction f(x) -> x * 2.0</description>
+    </simple>
+    <simple name="int-iter-multiply-3" type="int32">
+      <description>Fonction f(x) -> x * 3.0</description>
+    </simple>
+    <simple name="real-norm-l2" type="real">
+      <description>Fonction f(x,position) -> x * normL2(position)</description>
+    </simple>
+  </options>
+</module>

arcane/src/arcane/tests/CaseFunctionTesterModule.cc

@@ -0,0 +1,196 @@
+// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
+//-----------------------------------------------------------------------------
+// Copyright 2000-2023 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
+// See the top-level COPYRIGHT file for details.
+// SPDX-License-Identifier: Apache-2.0
+//-----------------------------------------------------------------------------
+/*---------------------------------------------------------------------------*/
+/* CaseFunctionTesterModule.cc                                 (C) 2000-2023 */
+/*                                                                           */
+/* Module de test des 'CaseFunction'.                                        */
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
+#include "arcane/core/StandardCaseFunction.h"
+#include "arcane/core/ITimeLoopMng.h"
+#include "arcane/core/TimeLoopEntryPointInfo.h"
+#include "arcane/core/TimeLoop.h"
+#include "arcane/core/IMesh.h"
+
+#include "arcane/tests/CaseFunctionTester_axl.h"
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
+namespace ArcaneTest
+{
+using namespace Arcane;
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+/*!
+ * \brief Module de test des 'ICaseFunction'.
+ */
+class CaseFunctionTesterModule
+: public ArcaneCaseFunctionTesterObject
+{
+ public:
+
+  explicit CaseFunctionTesterModule(const ModuleBuildInfo& mbi);
+
+ public:
+
+  static void staticInitialize(ISubDomain* sd);
+
+ public:
+
+  VersionInfo versionInfo() const override { return Arcane::VersionInfo(0, 1, 0); }
+
+ public:
+
+  void init();
+  void loop();
+
+ private:
+};
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
+ARCANE_DEFINE_STANDARD_MODULE(CaseFunctionTesterModule, CaseFunctionTester);
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
+namespace
+{
+  class StandardFuncTest
+  : public StandardCaseFunction
+  , public IBinaryMathFunctor<Real, Real3, Real>
+  {
+   public:
+
+    StandardFuncTest(const CaseFunctionBuildInfo& bi)
+    : StandardCaseFunction(bi)
+    {}
+
+   public:
+
+    virtual IBinaryMathFunctor<Real, Real3, Real>* getFunctorRealReal3ToReal()
+    {
+      return this;
+    }
+    virtual Real apply(Real r, Real3 r3)
+    {
+      return r + r3.normL2();
+    }
+  };
+
+} // namespace
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
+CaseFunctionTesterModule::
+CaseFunctionTesterModule(const ModuleBuildInfo& mbi)
+: ArcaneCaseFunctionTesterObject(mbi)
+{
+  addEntryPoint(this, "Init",
+                &CaseFunctionTesterModule::init, IEntryPoint::WInit);
+  addEntryPoint(this, "Loop",
+                &CaseFunctionTesterModule::loop);
+}
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
+void CaseFunctionTesterModule::
+staticInitialize(ISubDomain* sd)
+{
+  ITimeLoopMng* tlm = sd->timeLoopMng();
+  ITimeLoop* time_loop = tlm->createTimeLoop("CaseFunctionTester");
+
+  {
+    List<TimeLoopEntryPointInfo> clist;
+    clist.add(TimeLoopEntryPointInfo("CaseFunctionTester.Init"));
+    time_loop->setEntryPoints(ITimeLoop::WInit, clist);
+  }
+
+  {
+    List<TimeLoopEntryPointInfo> clist;
+    clist.add(TimeLoopEntryPointInfo("CaseFunctionTester.Loop"));
+    time_loop->setEntryPoints(ITimeLoop::WComputeLoop, clist);
+  }
+
+  {
+    StringList clist;
+    clist.add("CaseFunctionTester");
+    time_loop->setRequiredModulesName(clist);
+  }
+
+  tlm->registerTimeLoop(time_loop);
+}
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
+void CaseFunctionTesterModule::
+loop()
+{
+  if (m_global_iteration() > 10)
+    subDomain()->timeLoopMng()->stopComputeLoop(true);
+
+  // Temps de début d'itération auquel sont calculées les valeurs des fonctions
+  Real global_time = m_global_old_time();
+  Int32 global_iter = m_global_iteration();
+
+  {
+    Real v1 = options()->realTimeMultiply2.value();
+    Real expected_v1 = global_time * 2.0;
+    info() << "Function: real-time-multiply-2: " << v1;
+    if (!math::isNearlyEqual(v1, expected_v1))
+      ARCANE_FATAL("Bad (1) value v={0} expected={1}", v1, expected_v1);
+  }
+  {
+    int v1 = options()->intIterMultiply3.value();
+    int expected_v1 = global_iter * 3;
+    info() << "Function: int-iter-multiply-3: " << v1;
+    if (v1 != expected_v1)
+      ARCANE_FATAL("Bad (2) value v={0} expected={1}", v1, expected_v1);
+  }
+  {
+    ICaseFunction* opt_function = options()->realNormL2.function();
+    IStandardFunction* scf = options()->realNormL2.standardFunction();
+    if (!scf)
+      ARCANE_FATAL("No standard case function for option 'real-norml2'");
+    auto* functor = scf->getFunctorRealReal3ToReal();
+    if (!functor)
+      ARCANE_FATAL("Standard function '{0}' is not convertible to f(Real,Real3) -> Real", opt_function->name());
+
+    VariableNodeReal3& node_coord = defaultMesh()->nodesCoordinates();
+    ENUMERATE_ (Node, inode, allNodes()) {
+      Real3 coord = node_coord[inode];
+      Real v1 = functor->apply(global_time, coord);
+      Real expected_v1 = global_time * coord.normL2();
+      info() << "Function: real-norml2: " << v1;
+      if (!math::isNearlyEqual(v1, expected_v1))
+        ARCANE_FATAL("Bad (3) value v={0} expected={1}", v1, expected_v1);
+    }
+  }
+}
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
+void CaseFunctionTesterModule::
+init()
+{
+  m_global_deltat.assign(1.5);
+}
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/
+
+} // End namespace ArcaneTest
+
+/*---------------------------------------------------------------------------*/
+/*---------------------------------------------------------------------------*/