print_problemstructure.c

cfd求解器使用与gmsh网格的求解

	Msg(CHECK, "      /* Inventaire des DQ (%d) [%d] :",
	    FE->Case.LocalTerm.Term.NbrQuantityIndex,
	    FE->Case.LocalTerm.Term.QuantityIndexPost) ;
	for (k = 0 ; k < FE->Case.LocalTerm.Term.NbrQuantityIndex ; k++)
	  Msg(CHECK, " {%s}",
	      ((struct DefineQuantity *)
	       List_Pointer
	       (DQ_L, FE->Case.LocalTerm.Term.QuantityIndexTable[k]))->Name) ;
	Msg(CHECK, " */\n") ;

	Msg(CHECK, "      /* WholeQuantity (%d) :",
	    List_Nbr(FE->Case.LocalTerm.Term.WholeQuantity)) ;
	Print_WholeQuantity(Problem, FE->Case.LocalTerm.Term.WholeQuantity, DQ_L) ;
	Msg(CHECK, " */\n") ;

      }
      else if (FE->Type == GLOBALTERM     ) {
	Msg(CHECK, "      GlobalTerm { [ ... ] ;\n") ;
	Msg(CHECK, "                 In %s ;\n",
	    ((struct Group *)
	     List_Pointer(Problem->Group, FE->Case.GlobalTerm.InIndex))->Name ) ;
	
	Msg(CHECK, "      /* Inventaire des DQ (%d) [%d,%d] :",
	    FE->Case.GlobalTerm.Term.NbrQuantityIndex,
	    FE->Case.GlobalTerm.Term.DefineQuantityIndexDof,
	    FE->Case.GlobalTerm.Term.DefineQuantityIndexEqu) ;
	for (k = 0 ; k < FE->Case.GlobalTerm.Term.NbrQuantityIndex ; k++)
	  Msg(CHECK, " {%s}",
	      ((struct DefineQuantity *)
	       List_Pointer
	       (DQ_L, FE->Case.GlobalTerm.Term.QuantityIndexTable[k]))->Name) ;
	Msg(CHECK, " */\n") ;
	
	Msg(CHECK, "      /* WholeQuantity (%d) :",
	    List_Nbr(FE->Case.GlobalTerm.Term.WholeQuantity)) ;
	Print_WholeQuantity(Problem, FE->Case.GlobalTerm.Term.WholeQuantity, DQ_L) ;
	Msg(CHECK, " */\n") ;
	
      }
      else if (FE->Type == GLOBALEQUATION) {
	Msg(CHECK, "      GlobalEquation { Type %s ; UsingConstraint %s ;\n",
	    Get_StringForDefine(Constraint_Type, FE->Case.GlobalEquation.Type),
	    ((struct Constraint *)
	     List_Pointer(Problem->Constraint,
			  FE->Case.GlobalEquation.ConstraintIndex))->Name) ;

	Nbrk = List_Nbr(FE->Case.GlobalEquation.GlobalEquationTerm) ;
	for (k = 0 ; k < Nbrk ; k++) {
	  GET = (struct GlobalEquationTerm*)
	    List_Pointer(FE->Case.GlobalEquation.GlobalEquationTerm, k) ;
	  Msg(CHECK, "        { Node {%s} ; Loop {%s} ; Equation {%s} ;",
	      ((struct DefineQuantity *)
	       List_Pointer(DQ_L, GET->DefineQuantityIndexNode))->Name,
	      ((struct DefineQuantity *)
	       List_Pointer(DQ_L, GET->DefineQuantityIndexLoop))->Name,
	      ((struct DefineQuantity *)
	       List_Pointer(DQ_L, GET->DefineQuantityIndexEqu))->Name) ;
	  Msg(CHECK, " In %s ; }\n",
	      ((struct Group *)
	       List_Pointer(Problem->Group, GET->InIndex))->Name) ;
	}
      }
    }
    Msg(CHECK, "    }\n") ;
    Msg(CHECK, "  }\n") ;
  }
  Msg(CHECK, "\n");
  Msg(CHECK, "}\n") ;

  GetDP_End ;
}


/* ------------------------------------------------------- */
/*  -->  P r i n t _ R e s o l u t i o n                   */
/* ------------------------------------------------------- */

void  Print_Operation(struct Resolution * RE, List_T * Operation_L,
		      struct Problem * Problem) {
  struct Operation *OPE ;
  int    i, j, Nbrj ;

  GetDP_Begin("Print_Operation");

  NbrBlk++;

  Nbrj = List_Nbr(Operation_L) ;


  for (j=0 ; j<Nbrj ; j++) {
    OPE = (struct Operation*)List_Pointer(Operation_L, j) ;

    switch (OPE->Type) {

    case OPERATION_GENERATE :
    case OPERATION_GENERATEONLY :
    case OPERATION_GENERATEFMMGROUPS :
    case OPERATION_SOLVE :
    case OPERATION_GENERATEJAC :
    case OPERATION_SOLVEJAC :
    case OPERATION_GENERATESEPARATE :
    case OPERATION_UPDATECONSTRAINT :
    case OPERATION_INITSOLUTION :
    case OPERATION_SAVESOLUTION :
    case OPERATION_SAVESOLUTIONS :
    case OPERATION_READSOLUTION :
    case OPERATION_TRANSFERSOLUTION :
    case OPERATION_TRANSFERINITSOLUTION :
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      %s [%s] ;\n",
	  Get_StringForDefine(Operation_Type, OPE->Type),
	  ((struct DefineSystem *)
	   List_Pointer(RE->DefineSystem, OPE->DefineSystemIndex))->Name) ;
      break ;

   case OPERATION_UPDATE :
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      Update [ %s, Exp[%s] ] ;\n",
	  ((struct DefineSystem *)
	   List_Pointer(RE->DefineSystem, OPE->DefineSystemIndex))->Name,
	  Get_ExpressionName(Problem,
			     OPE->Case.Update.ExpressionIndex)) ;
      break ;

   case OPERATION_FOURIERTRANSFORM :
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      FourierTransform [ %s, %s, {...} ] ;\n",
	  ((struct DefineSystem *)
	   List_Pointer(RE->DefineSystem, OPE->Case.FourierTransform.DefineSystemIndex[0]))->Name,
	  ((struct DefineSystem *)
	   List_Pointer(RE->DefineSystem, OPE->Case.FourierTransform.DefineSystemIndex[1]))->Name);
      break ;

    case OPERATION_TIMELOOPTHETA :
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      TimeLoopTheta [ %.10g, %.10g, Exp[%s], Exp[%s] ] {\n",
	  OPE->Case.TimeLoopTheta.Time0, OPE->Case.TimeLoopTheta.TimeMax,
	  Get_ExpressionName(Problem,
			     OPE->Case.TimeLoopTheta.DTimeIndex),
	  Get_ExpressionName(Problem,
			     OPE->Case.TimeLoopTheta.ThetaIndex)) ;
      Print_Operation(RE, OPE->Case.TimeLoopTheta.Operation, Problem) ;
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      }\n") ;
      break ;

    case OPERATION_TIMELOOPNEWMARK :
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      TimeLoopNewmark [ %.10g, %.10g, Exp[%s], %.10g, %.10g ] {\n",
	  OPE->Case.TimeLoopNewmark.Time0, OPE->Case.TimeLoopNewmark.TimeMax,
	  Get_ExpressionName(Problem,
			     OPE->Case.TimeLoopNewmark.DTimeIndex),
	  OPE->Case.TimeLoopNewmark.Beta, OPE->Case.TimeLoopNewmark.Gamma);
      Print_Operation(RE, OPE->Case.TimeLoopNewmark.Operation, Problem) ;
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      }\n") ;
      break ;

    case OPERATION_ITERATIVELOOP :
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      IterativeLoop [ %d, %.10g, Exp[%s] ] {\n",
	  OPE->Case.IterativeLoop.NbrMaxIteration, 
	  OPE->Case.IterativeLoop.Criterion,
	  Get_ExpressionName(Problem, OPE->Case.IterativeLoop.RelaxationFactorIndex)) ;
      Print_Operation(RE, OPE->Case.IterativeLoop.Operation, Problem) ;
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      }\n") ;
      break ;

    case OPERATION_LANCZOS :
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      Lanczos [ %s, %d, { ... } , %.10g ] ;\n",
	  ((struct DefineSystem *)
	   List_Pointer(RE->DefineSystem, OPE->DefineSystemIndex))->Name,
	  OPE->Case.Lanczos.Size,
	  OPE->Case.Lanczos.Shift);
      break ;

    case OPERATION_EIGENSOLVE :
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      EigenSolve [ %s, %d, %.10g , %.10g ] ;\n",
	  ((struct DefineSystem *)
	   List_Pointer(RE->DefineSystem, OPE->DefineSystemIndex))->Name,
	  OPE->Case.EigenSolve.NumEigenvalues,
	  OPE->Case.EigenSolve.Shift_r, OPE->Case.EigenSolve.Shift_i);
      break ;

    case OPERATION_POSTOPERATION :
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      PostOperation [ ... ] ;\n");
      break ;

    case OPERATION_EVALUATE :
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      Evaluate [ Exp[%s] ] ;\n",
	  Get_ExpressionName(Problem,
			     OPE->Case.Evaluate.ExpressionIndex)) ;
      break ;

    case OPERATION_SETTIME :
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      SetTime [ Exp[%s] ] ;\n",
	  Get_ExpressionName(Problem,
			     OPE->Case.SetTime.ExpressionIndex)) ;
      break ;

    case OPERATION_SETFREQUENCY :
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      SetFrequency [ %s, Exp[%s] ] ;\n",
	  ((struct DefineSystem *)
	   List_Pointer(RE->DefineSystem, OPE->DefineSystemIndex))->Name,
	  Get_ExpressionName(Problem,
			     OPE->Case.SetFrequency.ExpressionIndex)) ;
      break ;

    case OPERATION_BREAK :
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      Break ;\n");
      break ;

    case OPERATION_SYSTEMCOMMAND :
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      SystemCommand \" %s \" ;\n",
	  OPE->Case.SystemCommand.String);
      break ;

    case OPERATION_TEST :
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      If [ Exp[%s] ] {\n",
	  Get_ExpressionName(Problem,
			     OPE->Case.Test.ExpressionIndex)) ;
      Print_Operation(RE, OPE->Case.Test.Operation_True, Problem) ;
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      }\n") ;
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      if(OPE->Case.Test.Operation_False){
	Msg(CHECK, "      Else {\n");
	Print_Operation(RE, OPE->Case.Test.Operation_False, Problem) ;
	Msg(CHECK, "      }\n") ;
      }
      break ;

    case OPERATION_CHANGEOFCOORDINATES :
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      ChangeOfCoordinates [ %s, Exp[%s] ] ;\n",
	  ((struct Group *)
	   List_Pointer(Problem->Group,
			OPE->Case.ChangeOfCoordinates.GroupIndex))->Name,
	  Get_ExpressionName(Problem,
			     OPE->Case.ChangeOfCoordinates.ExpressionIndex)) ;
      break ;

    case OPERATION_INIT_MOVINGBAND2D :
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      Init_MovingBand2D [ %s ] ;\n",
	  ((struct Group *)
	   List_Pointer(Problem->Group,
			OPE->Case.Init_MovingBand2D.GroupIndex))->Name) ;
      break ;

    case OPERATION_MESH_MOVINGBAND2D :
      for (i=0 ; i<2*NbrBlk ; i++) Msg(CHECK, " ") ;
      Msg(CHECK, "      Mesh_MovingBand2D [ %s ] ;\n",
	  ((struct Group *)
	   List_Pointer(Problem->Group,
			OPE->Case.Mesh_MovingBand2D.GroupIndex))->Name) ;
      break ;

    case OPERATION_DEFORMEMESH :
      Msg(CHECK, "      DeformeMesh [%s, %s,  '%s'] ; \n",
	  ((struct DefineSystem *)
	   List_Pointer(RE->DefineSystem, OPE->DefineSystemIndex))->Name, OPE->Case.DeformeMesh.Quantity,
	  OPE->Case.DeformeMesh.Name_MshFile) ;
      break ;

    default :
      Msg(CHECK, "      ??? ;\n") ;
      break ;
    }
  }

  NbrBlk--;
  GetDP_End ;
}


void  Print_Resolution(struct Problem  * Problem) {
  struct Resolution *RE ;
  struct DefineSystem *DS ;
  List_T *DS_L ;  
  int    i, Nbr, j, Nbrj, k ;

  GetDP_Begin("Print_Resolution");

  Nbr = List_Nbr(Problem->Resolution) ;

  Msg(CHECK, "Resolution {  /* nbr = %d */\n", Nbr) ;
  Msg(CHECK, "\n") ;

  for (i = 0 ; i < Nbr ; i++) {
    Msg(CHECK, " /* Num : %d */\n", i) ;

    RE = (struct Resolution*)List_Pointer(Problem->Resolution, i) ;

    Msg(CHECK, "  { Name %s\n", RE->Name) ;

    DS_L = RE->DefineSystem ;

    Msg(CHECK, "    System {\n") ;
    Nbrj = List_Nbr(DS_L) ;
    for (j=0 ; j<Nbrj ; j++) {
      DS = (struct DefineSystem*)List_Pointer(DS_L, j) ;

      Msg(CHECK, "      { Name %s ; Type %s ; ",
	  DS->Name,
	  Get_StringForDefine(DefineSystem_Type, DS->Type)) ;

      Msg(CHECK, "NameOfFormulation {") ;
      for (k = 0 ; k < List_Nbr(DS->FormulationIndex) ; k++)
	Msg(CHECK, " %s",
	    ((struct Formulation *)
	     List_Pointer(Problem->Formulation,
			  *((int *)List_Pointer(DS->FormulationIndex, k)))) ->Name) ;
      Msg(CHECK, " } ; ") ;

      if(DS->MeshName)
	Msg(CHECK, "NameOfMesh %s ;", DS->MeshName) ;

      if (DS->Type == VAL_COMPLEX) {
	Msg(CHECK, "Frequency {") ;

	for (k = 0 ; k < List_Nbr(DS->FrequencyValue) ; k++) {
	  if (k)  Msg(CHECK, ",") ;
	  Msg(CHECK, " %.10g", *((double *)List_Pointer(DS->FrequencyValue, k))) ;
	}
	Msg(CHECK, " } ;") ;
      }

      Msg(CHECK, " }\n") ;
    }
    Msg(CHECK, "    }\n") ;

    Msg(CHECK, "    Operation {\n") ;
    Print_Operation(RE, RE->Operation, Problem) ;
    Msg(CHECK, "    }\n") ;
    Msg(CHECK, "  }\n") ;
  }
  Msg(CHECK, "\n"); 
  Msg(CHECK, "}\n") ;

  GetDP_End ;
}


/* ------------------------------------------------------- */
/*  -->  P r i n t _ P o s t P r o c e s s i n g           */
/* ------------------------------------------------------- */

void  Print_PostProcessing(struct Problem  * Problem) {

  struct PostProcessing    * PP ;  
  struct PostQuantity      * PQ ;
  struct PostQuantityTerm  * PQT ;
  int   i, Nbr, j, Nbrj, k, Nbrk ;

  GetDP_Begin("Print_PostProcessing");

  Nbr = List_Nbr(Problem->PostProcessing) ;

  Msg(CHECK, "PostProcessing {  /* nbr = %d */\n", Nbr) ;
  Msg(CHECK, "\n") ;

  for (i = 0 ; i < Nbr ; i++) {
    Msg(CHECK, " /* Num : %d */\n", i) ;

    PP = (struct PostProcessing*)List_Pointer(Problem->PostProcessing, i) ;

    Msg(CHECK, "  { Name %s ; NameOfFormulation %s ; \n", PP->Name,
	((struct Formulation *)
	 List_Pointer(Problem->Formulation, PP->FormulationIndex))->Name) ;

    if(PP->NameOfSystem)
      Msg(CHECK, "NameOfSystem %s ;", PP->NameOfSystem);
    
    Nbrj = List_Nbr(PP->PostQuantity) ;
    if (Nbrj > 0) {
      Msg(CHECK, "    Quantity {\n") ;
      for (j = 0 ; j < Nbrj ; j++) {
	PQ = (struct PostQuantity*)List_Pointer(PP->PostQuantity, j) ;
	Msg(CHECK, "      { Name %s ;\n", PQ->Name) ;
	Msg(CHECK, "        Value {\n") ;
	Nbrk = List_Nbr(PQ->PostQuantityTerm) ;
	for (k = 0 ; k < Nbrk ; k++) {
	  PQT = (struct PostQuantityTerm*)List_Pointer(PQ->PostQuantityTerm, k) ;
	  Msg(CHECK, "          { %s { ['", 
	      Get_StringForDefine(PostQuantityTerm_EvaluationType, 
				  PQT->EvaluationType)) ;
	  Print_WholeQuantity
	    (Problem, PQT->WholeQuantity,
	     ((struct Formulation *)
	      List_Pointer(Problem->Formulation, PP->FormulationIndex))
	     ->DefineQuantity) ;
	  Msg(CHECK, " '] ; /* DefineQuantityType %s */\n",
	      Get_StringForDefine(DefineQuantity_Type, PQT->Type)) ;

	  if(PQT->InIndex > 0)
	    Msg(CHECK, "                    In %s ;\n", 
		((struct Group *)List_Pointer(Problem->Group, PQT->InIndex))->Name);
	  if(PQT->IntegrationMethodIndex > 0)
	    Msg(CHECK, "                    Integration %s ;\n",