Fixing tnl-quickstart.

src/TNL/Problems/HeatEquationProblem_impl.h

@@ -227,11 +227,11 @@ getExplicitRHS( const RealType& time,
       this->rightHandSidePointer,
       this->uPointer,
       fuPointer );
-   /*BoundaryConditionsSetter< MeshFunctionType, BoundaryCondition > boundaryConditionsSetter;
+   Solvers::PDE::BoundaryConditionsSetter< MeshFunctionType, BoundaryCondition > boundaryConditionsSetter;
    boundaryConditionsSetter.template apply< typename Mesh::Cell >(
-      this->boundaryCondition,
+      this->boundaryConditionPointer,
       time + tau,
-      this->u );*/
+      this->uPointer );
    
    //fu.write( "fu.txt", "gnuplot" );
    //this->u.write( "u.txt", "gnuplot");

src/TNL/Solvers/PDE/BoundaryConditionsSetter.h

@@ -13,6 +13,7 @@
 
 #include <TNL/Devices/Cuda.h>
 #include <TNL/Functions/FunctionAdapter.h>
+#include <TNL/SharedPointer.h>
 
 namespace TNL {
 namespace Solvers {
@@ -55,11 +56,14 @@ class BoundaryConditionsSetter
          RealType,
          MeshFunction,
          BoundaryConditions > TraverserUserData;
+      typedef SharedPointer< MeshType, DeviceType > MeshPointer;
+      typedef SharedPointer< BoundaryConditions, DeviceType > BoundaryConditionsPointer;
+      typedef SharedPointer< MeshFunction, DeviceType > MeshFunctionPointer;
 
       template< typename EntityType = typename MeshType::Cell >
-      static void apply( const BoundaryConditions& boundaryConditions,
+      static void apply( const BoundaryConditionsPointer& boundaryConditions,
                          const RealType& time,
-                         MeshFunction& u );
+                         MeshFunctionPointer& u );
  
       class TraverserBoundaryEntitiesProcessor
       {

src/TNL/Solvers/PDE/BoundaryConditionsSetter_impl.h

@@ -22,20 +22,22 @@ template< typename MeshFunction,
    template< typename EntityType >
 void
 BoundaryConditionsSetter< MeshFunction, BoundaryConditions >::
-apply( const BoundaryConditions& boundaryConditions,
+apply( const BoundaryConditionsPointer& boundaryConditions,
        const RealType& time,
-       MeshFunction& u )
+       MeshFunctionPointer& u )
 {
-   if( std::is_same< DeviceType, Devices::Host >::value )
+   //if( std::is_same< DeviceType, Devices::Host >::value )
    {
-      TraverserUserData userData( time, boundaryConditions, u );
+      TraverserUserData userData( time,
+                                  boundaryConditions.template getData< DeviceType >(),
+                                  u.template modifyData< DeviceType >() );
       Meshes::Traverser< MeshType, EntityType > meshTraverser;
       meshTraverser.template processBoundaryEntities< TraverserUserData,
                                                       TraverserBoundaryEntitiesProcessor >
-                                                    ( u.getMeshPointer(),
+                                                    ( u->getMeshPointer(),
                                                       userData );
    }
-   if( std::is_same< DeviceType, Devices::Cuda >::value )
+   /*if( std::is_same< DeviceType, Devices::Cuda >::value )
    {
       RealType* kernelTime = Devices::Cuda::passToDevice( time );
       BoundaryConditions* kernelBoundaryConditions = Devices::Cuda::passToDevice( boundaryConditions );
@@ -51,7 +53,7 @@ apply( const BoundaryConditions& boundaryConditions,
       Devices::Cuda::freeFromDevice( kernelBoundaryConditions );
       Devices::Cuda::freeFromDevice( kernelU );
       checkCudaDevice;
-   }
+   }*/
 }
 
 } // namespace PDE

src/Tools/tnl-quickstart/operator-grid-specialization.h.in

@@ -30,14 +30,14 @@ class {operatorName}< TNL::Meshes::Grid< {meshDimensions}, MeshReal, Device, Mes
 
       template< typename MeshEntity, typename Vector, typename MatrixRow >
       __cuda_callable__
-      void updateLinearSystem( const RealType& time,
-                               const RealType& tau,
-                               const MeshType& mesh,
-                               const IndexType& index,
-                               const MeshEntity& entity,
-                               const MeshFunctionType& u,
-                               Vector& b,
-                               MatrixRow& matrixRow ) const;
+      void setMatrixElements( const RealType& time,
+                              const RealType& tau,
+                              const MeshType& mesh,
+                              const IndexType& index,
+                              const MeshEntity& entity,
+                              const MeshFunctionType& u,
+                              Vector& b,
+                              MatrixRow& matrixRow ) const;
 }};
     
 

src/Tools/tnl-quickstart/operator-grid-specialization_impl.h.in

@@ -73,14 +73,14 @@ template< typename MeshReal,
 __cuda_callable__        
 void
 {operatorName}< TNL::Meshes::Grid< {meshDimensions}, MeshReal, Device, MeshIndex >, Real, Index >::
-updateLinearSystem( const RealType& time,
-                    const RealType& tau,
-                    const MeshType& mesh,
-                    const IndexType& index,
-                    const MeshEntity& entity,
-                    const MeshFunctionType& u,
-                    Vector& b,
-                    MatrixRow& matrixRow ) const
+setMatrixElements( const RealType& time,
+                   const RealType& tau,
+                   const MeshType& mesh,
+                   const IndexType& index,
+                   const MeshEntity& entity,
+                   const MeshFunctionType& u,
+                   Vector& b,
+                   MatrixRow& matrixRow ) const
 {{
    /****
     * Setup the non-zero elements of the linear system here.

src/Tools/tnl-quickstart/problem_impl.h.in

@@ -53,8 +53,8 @@ setup( const MeshPointer& meshPointer,
        const TNL::Config::ParameterContainer& parameters,
        const TNL::String& prefix )
 {{
-   if( ! this->boundaryCondition.setup( meshPointer, parameters, "boundary-conditions-" ) ||
-       ! this->rightHandSide.setup( parameters, "right-hand-side-" ) )
+   if( ! this->boundaryCondition->setup( meshPointer, parameters, "boundary-conditions-" ) ||
+       ! this->rightHandSide->setup( parameters, "right-hand-side-" ) )
       return false;
    return true;
 }}
@@ -179,8 +179,8 @@ getExplicitRHS( const RealType& time,
 
    this->bindDofs( mesh, _u );
    TNL::Solvers::PDE::ExplicitUpdater< Mesh, MeshFunctionType, DifferentialOperator, BoundaryCondition, RightHandSide > explicitUpdater;
-   MeshFunctionType u( mesh, _u ); 
-   MeshFunctionType fu( mesh, _fu ); 
+   TNL::SharedPointer< MeshFunctionType > u( mesh, _u ); 
+   TNL::SharedPointer< MeshFunctionType > fu( mesh, _fu ); 
    explicitUpdater.template update< typename Mesh::Cell >( time,
                                                            mesh,
                                                            this->differentialOperator,
@@ -219,7 +219,7 @@ assemblyLinearSystem( const RealType& time,
                              typename MatrixPointer::ObjectType,
                              DofVectorType > systemAssembler;
 
-   TNL::Functions::MeshFunction< Mesh > u( mesh, _u );
+   TNL::SharedPointer< TNL::Functions::MeshFunction< Mesh > > u( mesh, _u );
    systemAssembler.template assembly< typename Mesh::Cell >( time,
                                                              tau,
                                                              mesh,