integration_structure.hpp

Go to the documentation of this file.

#pragma once

#include "../../Common/include/mpi_structure.hpp"

#include <cmath>
#include <iostream>
#include <cstdlib>

#include "solver_structure.hpp"
#include "../../Common/include/geometry_structure.hpp"
#include "../../Common/include/config_structure.hpp"

using namespace std;

class CIntegration {
protected:
  su2double Cauchy_Value,  
  Cauchy_Func;      
  unsigned short Cauchy_Counter;  
  su2double *Cauchy_Serie;      
  su2double Old_Func,  
  New_Func;      
  bool Convergence,    
  Convergence_FSI,    
  Convergence_FullMG;    
  su2double InitResidual;  
public:
  
  CIntegration(CConfig *config);
  
  virtual ~CIntegration(void);
  
  void Space_Integration(CGeometry *geometry, CSolver **solver_container, CNumerics **numerics, CConfig *config, 
               unsigned short iMesh, unsigned short iRKStep, unsigned short RunTime_EqSystem);

  void Space_Integration_FEM(CGeometry *geometry, CSolver **solver_container, CNumerics **numerics, CConfig *config,
               unsigned short RunTime_EqSystem, unsigned long Iteration);

  void Time_Integration(CGeometry *geometry, CSolver **solver_container, CConfig *config, 
              unsigned short iRKStep, unsigned short RunTime_EqSystem, unsigned long Iteration);
  
  void Time_Integration_FEM(CGeometry *geometry, CSolver **solver_container, CNumerics **numerics, CConfig *config,
                  unsigned short RunTime_EqSystem, unsigned long Iteration);

  void Adjoint_Setup(CGeometry ***geometry, CSolver ****solver_container, CConfig **config,
                     unsigned short RunTime_EqSystem, unsigned long Iteration, unsigned short iZone);

  void Convergence_Monitoring(CGeometry *geometry, CConfig *config, 
                unsigned long Iteration, su2double monitor, unsigned short iMesh);
  
  void Convergence_Monitoring_FEM(CGeometry *geometry, CConfig *config, CSolver *solver, unsigned long iFSIIter);


  void Convergence_Monitoring_FSI(CGeometry *fea_geometry, CConfig *fea_config, CSolver *fea_solver, unsigned long iFSIIter);


  su2double GetCauchy_Value(void);
  
  bool GetConvergence(void);
  
  bool GetConvergence_FSI(void);

  void SetConvergence(bool value);
  

  void SetConvergence_FSI(bool valueFSI);


  bool GetConvergence_FullMG(void);
  
  void SetDualTime_Solver(CGeometry *geometry, CSolver *solver, CConfig *config, unsigned short iMesh);
  
  void SetStructural_Solver(CGeometry *geometry, CSolver *solver, CConfig *config, unsigned short iMesh);

  void SetFEM_StructuralSolver(CGeometry *geometry, CSolver **solver_container, CConfig *config, unsigned short iMesh);

  virtual void MultiGrid_Iteration(CGeometry ***geometry, CSolver ****solver_container, CNumerics *****numerics_container,
                  CConfig **config, unsigned short RunTime_EqSystem, unsigned long Iteration, unsigned short iZone);
  
  virtual void MultiGrid_Cycle(CGeometry ***geometry, CSolver ****solver_container, CNumerics *****numerics_container,
                 CConfig **config, unsigned short iMesh, unsigned short mu, unsigned short RunTime_EqSystem,
                 unsigned long Iteration, unsigned short iZone);
  
  virtual void NonDimensional_Parameters(CGeometry **geometry, CSolver ***solver_container, CNumerics ****numerics_container, 
                                         CConfig *config, unsigned short FinestMesh, unsigned short RunTime_EqSystem, unsigned long Iteration, 
                                         su2double *monitor);
  
  virtual void SetProlongated_Correction(CSolver *sol_fine, CGeometry *geo_fine, CConfig *config, unsigned short iMesh);

  virtual void SetProlongated_Solution(unsigned short RunTime_EqSystem, CSolver *sol_fine, CSolver *sol_coarse, 
                     CGeometry *geo_fine, CGeometry *geo_coarse, CConfig *config);
  
  virtual void SetRestricted_Residual(CSolver *sol_fine, CSolver *sol_coarse, CGeometry *geo_fine, 
                    CGeometry *geo_coarse, CConfig *config);
  
  virtual void SetRestricted_Solution(unsigned short RunTime_EqSystem, CSolver *sol_fine, CSolver *sol_coarse, CGeometry *geo_fine, CGeometry *geo_coarse, CConfig *config);
  
  virtual void SetRestricted_EddyVisc(unsigned short RunTime_EqSystem, CSolver *sol_fine, CSolver *sol_coarse, CGeometry *geo_fine, CGeometry *geo_coarse, CConfig *config);

  virtual void SetRestricted_Gradient(unsigned short RunTime_EqSystem, CSolver *sol_fine, CSolver *sol_coarse,
                    CGeometry *geo_fine, CGeometry *geo_coarse, CConfig *config);
  
  virtual void SetResidual_Term(CGeometry *geometry, CSolver *flow);
  
  virtual void SetForcing_Term(CSolver *sol_fine, CSolver *sol_coarse, CGeometry *geo_fine, CGeometry *geo_coarse, 
                 CConfig *config, unsigned short iMesh);
  
  virtual void SingleGrid_Iteration(CGeometry ***geometry, CSolver ****solver_container, CNumerics *****numerics_container,
                  CConfig **config, unsigned short RunTime_EqSystem, unsigned long Iteration, unsigned short iZone);


  virtual void Structural_Iteration(CGeometry ***geometry, CSolver ****solver_container, CNumerics *****numerics_container,
                  CConfig **config, unsigned short RunTime_EqSystem, unsigned long Iteration, unsigned short iZone);

  
  virtual void SetPotential_Solver(CGeometry ***geometry, CSolver ****solver_container, CNumerics *****numerics_container,
                                   CConfig **config, unsigned short RunTime_EqSystem, unsigned short iMesh, unsigned short iZone);
  
  virtual void Smooth_Solution(unsigned short RunTime_EqSystem, CSolver *solver, CGeometry *geometry,
                       unsigned short val_nSmooth, su2double val_smooth_coeff, CConfig *config);

};

class CMultiGridIntegration : public CIntegration {
protected:
    
public:
  
  CMultiGridIntegration(CConfig *config);
  
  ~CMultiGridIntegration(void);
  
  void MultiGrid_Iteration(CGeometry ***geometry, CSolver ****solver_container, CNumerics *****numerics_container,
               CConfig **config, unsigned short RunTime_EqSystem, unsigned long Iteration, unsigned short iZone);
  
  void MultiGrid_Cycle(CGeometry ***geometry, CSolver ****solver_container, CNumerics *****numerics_container,
                     CConfig **config, unsigned short iMesh, unsigned short mu, unsigned short RunTime_EqSystem,
                     unsigned long Iteration, unsigned short iZone);
  
  void NonDimensional_Parameters(CGeometry **geometry, CSolver ***solver_container, CNumerics ****numerics_container, 
                                 CConfig *config, unsigned short FinestMesh, unsigned short RunTime_EqSystem, unsigned long Iteration, 
                                 su2double *monitor);

  void SetProlongated_Solution(unsigned short RunTime_EqSystem, CSolver *sol_fine, CSolver *sol_coarse, 
                 CGeometry *geo_fine, CGeometry *geo_coarse, CConfig *config);
  
  void GetProlongated_Correction(unsigned short RunTime_EqSystem, CSolver *sol_fine, CSolver *sol_coarse, CGeometry *geo_fine, 
                                 CGeometry *geo_coarse, CConfig *config);
  
  void SmoothProlongated_Correction(unsigned short RunTime_EqSystem, CSolver *solver, CGeometry *geometry,
                                     unsigned short val_nSmooth, su2double val_smooth_coeff, CConfig *config);
  
  void Smooth_Solution(unsigned short RunTime_EqSystem, CSolver *solver, CGeometry *geometry,
                                    unsigned short val_nSmooth, su2double val_smooth_coeff, CConfig *config);

  void SetProlongated_Correction(CSolver *sol_fine, CGeometry *geo_fine, CConfig *config, unsigned short iMesh);

  void SetRestricted_Residual(CSolver *sol_fine, CSolver *sol_coarse, CGeometry *geo_fine, 
                CGeometry *geo_coarse, CConfig *config);

  void SetRestricted_Solution(unsigned short RunTime_EqSystem, CSolver *sol_fine, CSolver *sol_coarse, CGeometry *geo_fine, CGeometry *geo_coarse, CConfig *config);
  
  void SetRestricted_Gradient(unsigned short RunTime_EqSystem, CSolver *sol_fine, CSolver *sol_coarse, 
                CGeometry *geo_fine, CGeometry *geo_coarse, CConfig *config);

  void SetResidual_Term(CGeometry *geometry, CSolver *flow);
  
  void SetForcing_Term(CSolver *sol_fine, CSolver *sol_coarse, CGeometry *geo_fine, CGeometry *geo_coarse, 
             CConfig *config, unsigned short iMesh);
};

class CSingleGridIntegration : public CIntegration {
public:
  
  CSingleGridIntegration(CConfig *config);
  
  ~CSingleGridIntegration(void);
  
  void SingleGrid_Iteration(CGeometry ***geometry, CSolver ****solver_container, CNumerics *****numerics_container,
               CConfig **config, unsigned short RunTime_EqSystem, unsigned long Iteration, unsigned short iZone);
  
  void SetRestricted_Solution(unsigned short RunTime_EqSystem, CSolver *sol_fine, CSolver *sol_coarse, CGeometry *geo_fine, CGeometry *geo_coarse, CConfig *config);
  
  void SetRestricted_EddyVisc(unsigned short RunTime_EqSystem, CSolver *sol_fine, CSolver *sol_coarse, CGeometry *geo_fine, CGeometry *geo_coarse, CConfig *config);
 
};


class CStructuralIntegration : public CIntegration {
public:

  CStructuralIntegration(CConfig *config);

  ~CStructuralIntegration(void);

  void Structural_Iteration(CGeometry ***geometry, CSolver ****solver_container, CNumerics *****numerics_container,
               CConfig **config, unsigned short RunTime_EqSystem, unsigned long Iteration, unsigned short iZone);

};

#include "integration_structure.inl"