Refactoring the invsicid flow solver.

examples/inviscid-flow/CompressibleConservativeVariables.h

@@ -38,7 +38,7 @@ class CompressibleConservativeVariables
       : density( meshPointer ),
         momentum( meshPointer ),
         //pressure( meshPointer ),
-        energy( meshPointer ) {};
+        energy( meshPointer ){};
         
       void setMesh( const MeshPointer& meshPointer )
       {
@@ -46,9 +46,6 @@ class CompressibleConservativeVariables
          this->momentum->setMesh( meshPointer );
          //this->pressure.setMesh( meshPointer );
          this->energy->setMesh( meshPointer );
-         this->dofs = this->density->getDofs() + 
-            this->momentum->getDofs() +
-            this->energy->getDofs();
       }
       
       template< typename Vector >
@@ -58,18 +55,20 @@ class CompressibleConservativeVariables
       {
          IndexType currentOffset( offset );
          this->density->bind( meshPointer, data, currentOffset );
-         currentOffset += this->density->getDofs();
+         currentOffset += this->density->getDofs( meshPointer );
          for( IndexType i = 0; i < Dimensions; i++ )
          {
             ( *this->momentum )[ i ]->bind( meshPointer, data, currentOffset );
-            currentOffset += ( *this->momentum )[ i ]->getDofs();
+            currentOffset += ( *this->momentum )[ i ]->getDofs( meshPointer );
          }
          this->energy->bind( meshPointer, data, currentOffset );
       }
       
-      void IndexType getDofs() const
+      IndexType getDofs( const MeshPointer& meshPointer ) const
       {
-         return this->dofs;
+         return this->density->getDofs( meshPointer ) + 
+            this->momentum->getDofs( meshPointer ) +
+            this->energy->getDofs( meshPointer );
       }
       
       MeshFunctionPointer& getDensity()
@@ -139,8 +138,6 @@ class CompressibleConservativeVariables
 
    protected:
       
-      IndexType dofs;
-      
       MeshFunctionPointer density;
       MomentumFieldPointer momentum;
       //MeshFunctionPointer pressure;

examples/inviscid-flow/PhysicalVariablesGetter.h

@@ -27,18 +27,21 @@ class PhysicalVariablesGetter
       typedef typename MeshType::RealType RealType;
       typedef typename MeshType::DeviceType DeviceType;
       typedef typename MeshType::IndexType IndexType;
+      static const int Dimensions = MeshType::getMeshDimensions();
+      
       typedef Functions::MeshFunction< MeshType > MeshFunctionType;
       typedef SharedPointer< MeshFunctionType > MeshFunctionPointer;
       typedef CompressibleConservativeVariables< MeshType > ConservativeVariablesType;
       typedef SharedPointer< ConservativeVariablesType > ConservativeVariablesPointer;
-      typedef Functions::VectorField< MeshType > VelocityFieldType;
+      typedef Functions::VectorField< Dimensions, MeshFunctionType > VelocityFieldType;
       typedef SharedPointer< VelocityFieldType > VelocityFieldPointer;
       
-      static const int Dimensions = MeshType::getMeshDimensions();
+      
       
       class VelocityGetter : public Functions::Domain< Dimensions, Functions::MeshDomain >
       {
          public:
+            typedef typename MeshType::RealType RealType;
             
             VelocityGetter( MeshFunctionPointer density, 
                             MeshFunctionPointer momentum )
@@ -46,26 +49,26 @@ class PhysicalVariablesGetter
             
             template< typename EntityType >
             __cuda_callable__
-            const RealType& operator()( const EntityType& meshEntity,
+            RealType operator()( const EntityType& meshEntity,
                                         const RealType& time = 0.0 ) const
             {
-               return momentum.template getData< DeviceType >( meshEntity ) / 
-                      density.template getData< DeviceType >( meshEntity );
+               return momentum.template getData< DeviceType >()( meshEntity ) / 
+                      density.template getData< DeviceType >()( meshEntity );
             }
             
          protected:
             const MeshFunctionPointer density, momentum;
       };
       
-      void getVelocity( const ConservativeVariablesType& conservativeVariables,
+      void getVelocity( const ConservativeVariablesPointer& conservativeVariables,
                         VelocityFieldPointer& velocity )
       {
          Functions::MeshFunctionEvaluator< MeshFunctionType, VelocityGetter > evaluator;
          for( int i = 0; i < Dimensions; i++ )
          {
-            SharedPointer< VelocityGetter, DeviceType > velocityGetter( conservativeVariables.getDensity(),
-                                                                        conservativeVariables.getMomentum()[ i ] );
-            evaluator.evaluate( velocity[ i ], velocityGetter );
+            SharedPointer< VelocityGetter, DeviceType > velocityGetter( conservativeVariables->getDensity(),
+                                                                        ( *conservativeVariables->getMomentum() )[ i ] );
+            evaluator.evaluate( ( *velocity )[ i ], velocityGetter );
          }
       }
       

examples/inviscid-flow/eulerProblem.h

@@ -130,9 +130,10 @@ class eulerProblem:
       VelocityFieldPointer velocity;
       MeshFunctionPointer pressure, energy;
       
+      RealType gamma;
       
       //definition
-	   Containers::Vector< RealType, DeviceType, IndexType > _uRho;
+	   /*Containers::Vector< RealType, DeviceType, IndexType > _uRho;
 	   Containers::Vector< RealType, DeviceType, IndexType > _uRhoVelocityX;
 	   Containers::Vector< RealType, DeviceType, IndexType > _uRhoVelocityY;
 	   Containers::Vector< RealType, DeviceType, IndexType > _uEnergy;
@@ -150,8 +151,8 @@ class eulerProblem:
       Containers::Vector< RealType, DeviceType, IndexType > pressure;
       Containers::Vector< RealType, DeviceType, IndexType > velocity;
       Containers::Vector< RealType, DeviceType, IndexType > velocityX;
-      Containers::Vector< RealType, DeviceType, IndexType > velocityY;
-      double gamma;
+      Containers::Vector< RealType, DeviceType, IndexType > velocityY;*/
+      
 };
 
 } // namespace TNL

examples/inviscid-flow/eulerProblem_impl.h

@@ -100,7 +100,7 @@ getDofs( const MeshPointer& mesh ) const
     * Return number of  DOFs (degrees of freedom) i.e. number
     * of unknowns to be resolved by the main solver.
     */
-   return this->conservativeVariables->getDofs();
+   return this->conservativeVariables->getDofs( mesh );
 }
 
 template< typename Mesh,
@@ -112,7 +112,7 @@ eulerProblem< Mesh, BoundaryCondition, RightHandSide, DifferentialOperator >::
 bindDofs( const MeshPointer& mesh,
           DofVectorPointer& dofVector )
 {
-   this->conservativeVariables.bind( mesh, dofVector );
+   this->conservativeVariables->bind( mesh, dofVector );
 }
 
 template< typename Mesh,
@@ -182,8 +182,8 @@ makeSnapshot( const RealType& time,
   this->bindDofs( mesh, dofs );
   PhysicalVariablesGetter< MeshType > physicalVariablesGetter;
   physicalVariablesGetter.getVelocity( this->conservativeVariables, this->velocity );
-  physicalVariablesGetter.getPressure( this->conservativeVariables, this->pressure );
-  physicalVariablesGetter.getEnergy( this->conservativeVariables, this->energy );
+  //physicalVariablesGetter.getPressure( this->conservativeVariables, this->pressure );
+  //physicalVariablesGetter.getEnergy( this->conservativeVariables, this->energy );
   
    FileName fileName;
    fileName.setExtension( "tnl" );
@@ -220,7 +220,7 @@ getExplicitRHS( const RealType& time,
                 DofVectorPointer& _fu,
                 MeshDependentDataPointer& meshDependentData )
 {
-    typedef typename MeshType::Cell Cell;
+    /*typedef typename MeshType::Cell Cell;
     int count = mesh->template getEntitiesCount< Cell >()/4;
 	//bind _u
     this->_uRho.bind( *_u,0,count);
@@ -307,6 +307,7 @@ getExplicitRHS( const RealType& time,
                                                            this->rightHandSidePointer,
                                                            uEnergy,
                                                            fuEnergy );
+     */
 
 /*
    BoundaryConditionsSetter< MeshFunctionType, BoundaryCondition > boundaryConditionsSetter; 
@@ -364,6 +365,7 @@ postIterate( const RealType& time,
              DofVectorPointer& dofs,
              MeshDependentDataPointer& meshDependentData )
 {
+   /*
     typedef typename MeshType::Cell Cell;
     int count = mesh->template getEntitiesCount< Cell >()/4;
 	//bind _u
@@ -411,6 +413,7 @@ postIterate( const RealType& time,
    euler2DPressure.setRho(uRho);
 //   OperatorFunction< euler2DPressure, MeshFunction, void, time > OFPressure;
 //   pressure = OFPressure;
+    */
    return true;
 }
 

src/TNL/Functions/MeshFunction.h

@@ -92,7 +92,7 @@ class MeshFunction :
       
       const MeshPointer& getMeshPointer() const;
       
-      __cuda_callable__ IndexType getDofs() const;
+      __cuda_callable__ IndexType getDofs( const MeshPointer& meshPointer ) const;
       
       __cuda_callable__ const VectorType& getData() const;      
       

src/TNL/Functions/MeshFunction_impl.h

@@ -257,7 +257,7 @@ template< typename Mesh,
 __cuda_callable__
 typename MeshFunction< Mesh, MeshEntityDimensions, Real >::IndexType
 MeshFunction< Mesh, MeshEntityDimensions, Real >::
-getDofs() const
+getDofs( const MeshPointer& meshPointer ) const
 {
    return meshPointer->template getEntitiesCount< MeshEntityDimensions >();
 }

src/TNL/Functions/VectorField.h

@@ -74,6 +74,9 @@ template< int Size,
           int MeshEntityDimensions,
           typename Real >
 class VectorField< Size, MeshFunction< Mesh, MeshEntityDimensions, Real > >
+: public Functions::Domain< MeshFunction< Mesh, MeshEntityDimensions, Real >::getDomainDimensions(), 
+                            MeshFunction< Mesh, MeshEntityDimensions, Real >::getDomainType() >,
+   public Object
 {
    public:
       
@@ -99,6 +102,33 @@ class VectorField< Size, MeshFunction< Mesh, MeshEntityDimensions, Real > >
             this->vectorField[ i ]->setMesh( meshPointer );
       };
       
+      static String getType()
+      {
+         return String( "Functions::VectorField< " ) +
+                  String( Size) + ", " +
+                 FunctionType::getType() +
+                  " >";
+      }
+ 
+      String getTypeVirtual() const
+      {
+         return this->getType();
+      }
+ 
+      static String getSerializationType()
+      {
+         return String( "Functions::VectorField< " ) +
+                  String( Size) + ", " +
+                 FunctionType::getSerializationType() +
+                  " >";         
+      }
+
+      virtual String getSerializationTypeVirtual() const
+      {
+         return this->getSerializationType();
+      }
+      
+      
       void setMesh( const MeshPointer& meshPointer )
       {
          for( int i = 0; i < Size; i++ )
@@ -118,9 +148,9 @@ class VectorField< Size, MeshFunction< Mesh, MeshEntityDimensions, Real > >
          return true;
       }
       
-      IndexType getDofs() const
+      IndexType getDofs( const MeshPointer& meshPointer ) const
       {
-         return Size * this->vectorField[ 0 ]->getDofs();
+         return Size * this->vectorField[ 0 ]->getDofs( meshPointer );
       }
 
       __cuda_callable__ 
@@ -134,6 +164,42 @@ class VectorField< Size, MeshFunction< Mesh, MeshEntityDimensions, Real > >
       {
          return this->vectorField[ i ];
       }
+      
+      bool save( File& file ) const
+      {
+         if( ! Object::save( file ) )
+            return false;
+         for( int i = 0; i < Size; i++ )
+            if( ! vectorField[ i ]->save( file ) )
+               return false;
+         return true;
+      }
+
+      bool load( File& file )
+      {
+         if( ! Object::load( file ) )
+            return false;
+         for( int i = 0; i < Size; i++ )
+            if( ! vectorField[ i ]->load( file ) )
+               return false;
+         return true;
+      }
+ 
+      bool boundLoad( File& file )
+      {
+         if( ! Object::load( file ) )
+            return false;
+         for( int i = 0; i < Size; i++ )
+            if( ! vectorField[ i ]->boundLoad( file ) )
+               return false;
+         return true;         
+      }
+      
+      using Object::save;
+ 
+      using Object::load;
+ 
+      using Object::boundLoad;      
 
    protected: