CAD4FE/src/main.cpp

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       main.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2025
//####//  Derniere modification par francois
//####//  mer 14 mai 2025 17:54:47 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include "gestionversion.h"
#include <sstream>  
#include <fstream>
#include <string>   
#include <time.h>    
#include <float.h>


#include "main.h"  

#include "mg_file.h"
#include "fct_taille.h"
#include "occ_import.h"
#include "CAD4FE_mailleur0d.h"
#include "CAD4FE_mailleur1d.h"
#include "CAD4FE_mailleur2d.h"
#include "CAD4FE_MeshQualityReport.h"
#include "fct_generateur_3d.h"
#include "fct_generateur_constante.h"

#include "CAD4FE_MCAA.h"    
#include "CAD4FE_FileUtils.h"
#include "CAD4FE_MCAAHtmlReport.h"
#include "mg_gestionnaire.h"
#include "CAD4FE_MCBody.h"    
#include "CAD4FE_MCVertex.h"
#include "CAD4FE_MCEdge.h"
#include "CAD4FE_MCFace.h"   
#include "CAD4FE_PolyCurve.h"
#include "CAD4FE_PolySurface.h"
#include "CAD4FE_InventorText_MCAA.h"    
#include "CAD4FE_InventorText_MG_MAILLAGE.h"
#include "CAD4FE_InventorText_MCMesh.h"
#ifndef GCC
#include "CAD4FE_SW_FeatureSimplification.h"
#endif
#include "CAD4FE_construire_fem_maillage_quadratique.h"
#include "CAD4FE_MCMesh_SetSaveFormat.h"
#include "fct_generateur_3d.h"
#include "fct_generateur_constante.h"
#include <fct_generateur_fichier.h>
#include "ot_fonctions.h"
#include "mailleur_fem.h"


void affiche(const char* message)
{
std::cout << message << std::endl;
}

#define MSG_HELP "Feature Simplifications parameters (Windows Only):\n\
-fillet -hole -extrusion -fastener -implicitholes -ribs\n\
Mesher parameters:\n\
-niveau <n>: =3 for volumic mesh generation =2 for surfacic mesh generation =1 for edge mesh generation\n\
-prioritemetrique <f>: float number in [0 ; 1] interval (0=mesh respecting shape quality only, 1=size map quality only)\n\ -console \n\
  -femmaillagedegre <n>: n=2 for quadratic mesh elements generation, n=1 for linear mesh elements generation\n\
-femmaillageexportcosmos : export to COSMOS/M file\n\
  -typecarte <n>: type of size map definition 1=constant value (requires option \"-eng <f>\"),\n 2 = ctt file (requires option \"-carte <f>\"),\n 3 = pog file (requires option \"-carte <f>\"),\n\
-carte <file>: size map file with .ctt extension\n\
-sld <file>: (Windows only) name of the SW file\n\
-step <file>: (Linux only) name of the STEP file\n\
  MCAA parameters:\n\
  -epsilonmax <f>: ratio between the sag tolerance and the local mesh size \n\ -betamax minimal dihedral angle defining a real edge between 2 triangles<f>\n\ -jmax <f> maximal mesh overdensity tolerated \n\
\n\
"

#define FLOAT_UNDEF -504333333341.5


double RefinementFile_GetEng(const char * __filename)

{
    FILE* in=fopen(__filename,"rt");
    char chaine[500];
    double eng;
    fgets(chaine,500,in);
    fgets(chaine,500,in);
    int nb=sscanf(chaine,"%lf",&eng);
    char cmdline[10000];
    fclose(in);
    return eng;
}

int ReadSizeMapRefinementFile(const char * __filename)
{
    double eng =  RefinementFile_GetEng(__filename);
    FCT_GENERATEUR_FICHIER * sizeMap = new FCT_GENERATEUR_FICHIER((char*)__filename, eng);
    //_sizeMap = sizeMap;
    sizeMap->construit(20,20);
    char outfilename[10000]="";
    sprintf(outfilename,"%s.ctt",__filename);
    sizeMap->enregistrer(outfilename);
    return 1;
}                

int main(int argc,char **argv)
{

    int debug = 0;
    int res=0;

    /// internal parameters
    MG_VOLUME * refBody=NULL, *mcBody=NULL;
    MG_MAILLAGE * refTessellation;
    MG_MAILLAGE * mgmai; 
    MG_GESTIONNAIRE * gest=NULL;    
    MG_GEOMETRIE * mggeo=NULL;
    FCT_TAILLE *metrique;

    ///  general parameters
    char CTT_filename[5000];
    char MAGIC_filename[5000];       
    char TEMP_SLD_filename[5000];
    char SLD_filename[5000];
    char STEP_filename[5000]; // for GCC
    int typecarte;
    double eng;

    double qual_couleurs[100],qual_intervalles[100];
    int qual_nb;
    double qual_forme_couleurs[100],qual_forme_intervalles[100];
    int qual_forme_nb;

    //// Feature Simplification parameters       
    bool bNothing;
    bool bFillet=false, bHole=false, bExtrusion=false;
    bool bFastener=false, bImplicitHoles=false, bRibs=false;
    int stopetape1 = 0;

    /// MCT parameters
    double epsilon_max=FLOAT_UNDEF, beta_max=FLOAT_UNDEF, J_max=FLOAT_UNDEF;
                             
    /// CAD4FE Mesher parameters
    int niveau=2;
    double prioritemetrique=0.65;
    int formatmaillage = 0;

    /// FEM Maillage and Export COSMOS/M parameters    
    FEM_MAILLAGE * femMesh = NULL;
    int fem_maillage_degre=-1;
    char * fem_maillage_export_cosmos=0;

    /* default quality colors */
    /* -formatmaillage 0   -couleurqualite 4     1 0 0    1 1 0          0 0.0 0.92           0.02 0.9 0.05  .25 .5 .75 */
    int qual_nb_default = 4;
    double qual_couleurs_default[] = { 1, 0, 0 ,   1, 1, 0,          0, 0.0, 0.92,           0.02, 0.9, 0.05};
    double qual_intervalles_default[]={0, .25, .5, .75, 1};
    qual_nb = qual_nb_default;
    qual_couleurs[0]=qual_couleurs[1]=qual_couleurs[2]=0;
    for (int i=3; i<(qual_nb_default+1)*3; i++) qual_couleurs[i] = qual_couleurs_default[i-3];
    for (int i=0; i<qual_nb_default+1; i++) qual_intervalles[i] = qual_intervalles_default[i];

    /// Reading the command line parameters :
    for (int i=0;i<argc;i++)
    {                
      
        if (strcmp(argv[i],"-help")==0 || strcmp(argv[i],"--help")==0)
          {
            printf(MSG_HELP);
            exit(0);
          }
        if (strcmp(argv[i],"-debug")==0)
            debug=1;
        //// Example : -fillet -hole -extrusion -fastener -niveau 2 -prioritemetrique 0.65 -console -carte c:/gilles/doctorat/CAD_FEA_models/Plots_fixation/plots_fixationMAGiC.txt.ctt -sld c:/gilles/doctorat/CAD_FEA_models/Plots_fixation/plots_fixation2MAGIC.Sldprt
        /// general parameters
        if (strcmp(argv[i],"-carte")==0)
            sprintf(CTT_filename,"%s",argv[i+1]);
        if (strcmp(argv[i],"-magic")==0)
            strcpy(MAGIC_filename,argv[i+1]);
        if (strcmp(argv[i],"-step")==0)  // Input geometry file For GCC
        {
            strcpy(STEP_filename,argv[i+1]);
            strcpy(MAGIC_filename,argv[i+1]);
            strcat(MAGIC_filename,".magic");
        }
        if (strcmp(argv[i],"-sld")==0) // Input geometry file For Win32 + SW only
        {
            strcpy(SLD_filename,argv[i+1]);
            strcpy(MAGIC_filename,argv[i+1]);
            strcat(SLD_filename,".magic");
        }
        if (strcmp(argv[i],"-typecarte")==0)
            typecarte=atoi(argv[i+1]);
        if (strcmp(argv[i],"-eng")==0)
            eng=atof(argv[i+1]);      
        if (strcmp(argv[i],"-stopetape1")==0)
            stopetape1=1;
        if (strcmp(argv[i],"-formatmaillage")==0)
        // 0=save as MCNode, MCSegment, MCTriangle                    
        // 1=save as MG_NOEUD, MG_SEGMENT, MG_TRIANGLE
        // 2=no MCT adaptation, generate mesh on the CAD topology
            formatmaillage=atoi(argv[i+1]);
        if (strcmp(argv[i],"-couleurqualite")==0)
        {
            int j=i+1;
            qual_nb = atoi(argv[j++]);
            qual_couleurs[0]=qual_couleurs[1]=qual_couleurs[2]=0;
            for (int k=1;k<qual_nb+1; k++)
            {
                qual_couleurs[3*k+0]=atof(argv[j++]);
                qual_couleurs[3*k+1]=atof(argv[j++]);
                qual_couleurs[3*k+2]=atof(argv[j++]);
            }
            qual_intervalles[0]=0;
            qual_intervalles[qual_nb]=1;
            for (int k=1;k<qual_nb; k++)
            {
                qual_intervalles[k]=atof(argv[j++]);
            }
        }
        //// Feature Simplification parameters
        if (strcmp(argv[i],"-fillet")==0)bFillet=true;
        if (strcmp(argv[i],"-hole")==0)bHole=true;
        if (strcmp(argv[i],"-extrusion")==0)bExtrusion=true;
        if (strcmp(argv[i],"-fastener")==0)bFastener=true;
        if (strcmp(argv[i],"-implicitholes")==0)bImplicitHoles=true;
        if (strcmp(argv[i],"-ribs")==0)bRibs=true;
        bNothing = (!bFillet&&!bHole&&!bExtrusion&&!bFastener&&!bImplicitHoles&&!bRibs);

        /// MCAA parameters
        if (strcmp(argv[i],"-epsilonmax")==0) epsilon_max=atof(argv[i+1]);
        if (strcmp(argv[i],"-betamax")==0) beta_max=atof(argv[i+1]);
        if (strcmp(argv[i],"-jmax")==0) J_max=atof(argv[i+1]);


        /// CAD4FE Mesher parameters
        if (strcmp(argv[i],"-niveau")==0)
            niveau=atoi(argv[i+1]);
        if (strcmp(argv[i],"-prioritemetrique")==0)
            prioritemetrique=atof(argv[i+1]);

        /// FEM Maillage and Export COSMOS/M parameters
        if (strcmp(argv[i],"-femmaillagedegre")==0)
            fem_maillage_degre = atoi(argv[i+1]);
        if (strcmp(argv[i],"-femmaillageexportcosmos")==0)
            fem_maillage_export_cosmos = argv[i+1];
    }
                      
    //// Basename of reports
#ifdef GCC
    if (getenv("TEMP") == NULL)
        setenv("TEMP","/tmp",0);
    std::string basename (getenv("TEMP"));
    std::cout << "Temporary folder is set to " << basename << std::endl;
#endif
    basename += std::string("/CAD4FE");

    if (strlen(SLD_filename) > 0) { // For Windows Solidworks
        // Copy file to temporary file
        strncpy(TEMP_SLD_filename,SLD_filename,strlen(SLD_filename)-strlen(".SLDPRT"));
        TEMP_SLD_filename[strlen(SLD_filename)-strlen(".SLDPRT")]='\0';
        strcat(TEMP_SLD_filename,"TEMP.SLDPRT");
        res=CAD4FE::FileUtils::Copy(SLD_filename,TEMP_SLD_filename);
        if (res == 0)
        {
                affiche( "Error occured while reading SolidWorks file" );
                return 0;
        }
    }

    /// Generate HTML Report file
    CAD4FE::HtmlText_Page out;
    out.Add("<h2>MCAA Mesher Report</h2>");

    // Generate size map object
    if (typecarte == 1)
    {
        affiche("Type of size map : constant value");
        double bbox[6];
        // featureSimplification.GetPartBoundaryBox(bbox);
        MG_GESTIONNAIRE gesttmp;
        metrique = new FCT_GENERATEUR_CONSTANTE ( gesttmp, eng );
        ((FCT_GENERATEUR_CONSTANTE*)metrique)->construit(-1E6, -1E6, -1E6, +1E6, +1E6, +1E6, 2,2);
        ((FCT_GENERATEUR_CONSTANTE*)metrique)->enregistrer((char*)(basename+std::string("_MCBody.magic.ctt")).c_str());
    }
    if (typecarte == 2)
    {
        affiche("Type of size map : ctt file");
        FCT_GENERATEUR_3D<4> * sizeMap = new FCT_GENERATEUR_3D<4>();
        sizeMap->lire(CTT_filename);
        metrique=sizeMap;
    }
    if (typecarte == 3)
    {                
            affiche("Type of size map : pog file");
            ReadSizeMapRefinementFile(CTT_filename);
            FCT_GENERATEUR_3D<4> * sizeMap = new FCT_GENERATEUR_3D<4>();
            strcat(CTT_filename,".ctt");
            sizeMap->lire(CTT_filename);
            metrique=sizeMap;                
    }
                                      

#ifndef GCC
    // Open SolidWorks part 
    affiche ("Starting SolidWorks ATL/COM server");
    CAD4FE::SW_FeatureSimplification featureSimplification;
    featureSimplification.OpenPart(TEMP_SLD_filename);
    if (typecarte == 1) // constant size (requires -eng <Double> option)
    {
        featureSimplification.SetSizeMap(metrique);
    }
    if (typecarte == 2) // ctt file
    {
        featureSimplification.SetSizeMap(metrique);
    }
    if (typecarte == 3) // pog file
    {                                
        affiche("Type of size map : pog file");
        featureSimplification.ReadSizeMapRefinementFile(CTT_filename);  
        metrique = featureSimplification.GetSizeMap();
    }
                                      
    affiche("*** Adapting the SolidWorks Feature-Tree for Meshing***");                                                          
    if (bNothing == false)
    {
        featureSimplification.DeleteAllConstraintsInSketches();
        int nbThickenFeature = featureSimplification.ThickenFeature_GetCount();
        //int nbThickenFeature = 0;
        for (int i=0;i<=nbThickenFeature;i++)
        {
            if (i==nbThickenFeature)
                featureSimplification.EndEditRollback();
            else                    
                featureSimplification.ThickenFeature_EditRollback(i);

            char tempMessage[5000];
            sprintf(tempMessage,"Pass %d of %d",i+1,nbThickenFeature+1);
            affiche (tempMessage);

            if (bFastener) {
                affiche("Simplifying fastener features");
                featureSimplification.SimplifyFeature_PlotFixation();
            }
            if (bHole) {
                affiche("Simplifying 'hole wizard' and 'revolution cut' features");
                featureSimplification.SimplifyFeature_HoleWzd();
            }
            if (bExtrusion) {
                affiche("Simplifying 'Cut' 'Boss' 'BossThin' 'CutThin' features");
                featureSimplification.SimplifyFeature_GlobalCutBoss();
            }  
            if (bFillet) {
                affiche("Simplifying constant-radius fillets");
                featureSimplification.SimplifyFeature_Fillet();
                affiche("Simplifying chamfers");      
                featureSimplification.SimplifyFeature_Chamfers();
            }
            if (bExtrusion)
                featureSimplification.SimplifyFeature_GlobalCutBoss();

            if (bRibs)
            {
                affiche("Simplifying ribs");
                featureSimplification.SimplifyFeature_Rib();
            }
        }
        // Features that are recognized on the final B-Rep

        if (bImplicitHoles)
        {
            affiche("Deleting small revolved holes/bosses that are implicit (skecth holes)");
            featureSimplification.SimplifyFeature_Body();
        }
    }
    
    affiche("*** End of the SolidWorks Feature-Tree adaptation ***");
    affiche("MAGiC: Generating MAGiC file with SolidWorks part...");            
    featureSimplification.SaveAsMagicFile(MAGIC_filename, &gest);
    if( remove( TEMP_SLD_filename ) != 0)
        affiche ("Error deleting SolidWorks temp file : (SolidWorks still open?)");
    out.Add(featureSimplification.HtmlReport());
    out.WriteFile(basename+".html");
    if (stopetape1)
    {
        affiche("Exit with success!");
        return 0;
    }
#else // For linux : open the STEP file directly
    // Example : -niveau 2 -prioritemetrique 0.65 -console -typecarte 1 -eng .01 -step /home/gilles/doctorat/CAD_FEA_models/Plots_fixation/plots_fixation2.STEP 

    gest = new MG_GESTIONNAIRE();
    OCC_IMPORT occimport;
    occimport.importer(*gest, STEP_filename, FICHIERSTEP);
    gest->enregistrer(MAGIC_filename);
#endif


    /// initialize MAGIC data-structure
    mggeo=gest->get_mg_geometrie(0);
    refBody = mggeo->get_mg_volume(0);
#ifdef GCC
    affiche ("Generation of the tessellation");
    //class MG_MAILLAGE* importer(class MG_GESTIONNAIRE& gest,MG_GEOMETRIE* mggeo,double epsilon=1.,int mode=1);
    refTessellation=occimport.importer(*gest, mggeo, 0.01, 2);
#endif //GCC

    /// MCAA : generation of the MCT (Meshing Constraints Topology)
    affiche ("Generation of the MCT (Meshing Constraints Topology)");
    affiche ("Initializing the Meshing Constraints Automatic Adaptation with the B-Rep");
    CAD4FE::MCAA * mcaa = new CAD4FE::MCAA(refBody,refTessellation,gest,mggeo);
    gest->enregistrer((char*)(basename+std::string("_MCBody.magic")).c_str());
    double default_J_max = 2;
    if (J_max != FLOAT_UNDEF) {
      mcaa->SetMaxOverdensity(default_J_max);
    }
    else
      {
        printf("Jmax is not specified : setting maximum overdensity to defaults %f \n", default_J_max);
        mcaa->SetMaxOverdensity(2);     
      }
    if (beta_max != FLOAT_UNDEF) mcaa->SetLimitAngle(beta_max*M_PI/180);
    if (epsilon_max != FLOAT_UNDEF) mcaa->SetRelativeSag(epsilon_max);
    if (beta_max == FLOAT_UNDEF && epsilon_max == FLOAT_UNDEF) {
        double default_beta_max = 30*M_PI/180;
        printf("Neither Beta max nor Relative Sag are specified : setting Beta max to defaults %f \n", default_beta_max);
        mcaa->SetLimitAngle(default_beta_max);
    }

    CAD4FE::MCAAHtmlReport mcaaReport (mcaa, basename);
    mcaa->SetSizeMap(metrique);
    mcaaReport.WriteInitialCriteriaFile();   
    if (formatmaillage != 2)
    {
        affiche ("Adapting the MCT for Meshing");
        mcaa->Simplify();
        char tmpMessage[5000];
        sprintf(tmpMessage,"Deleted %d MC Edges",mcaa->GetEdgeDeletionCount()); affiche(tmpMessage);
        sprintf(tmpMessage,"Deleted %d MC Vertices",mcaa->GetVertexDeletionCount()); affiche(tmpMessage);
        sprintf(tmpMessage,"Contracted %d MC Edges on MC Vertices",mcaa->GetEdgeCollapseCount()); affiche(tmpMessage);
        sprintf(tmpMessage,"Collapsed %d constricted sections",mcaa->GetConstrictedSectionCollapseCount()); affiche(tmpMessage);
        sprintf(tmpMessage,"Deleted %d small loops",mcaa->GetLoopDeletionCount()); affiche(tmpMessage);
    }
    mcaaReport.WriteFinalFEMeshFile();
        mcaaReport.WriteFinalMCTFile();
    affiche ("Converting MCT hypergraphs to B-Rep model");
    mcBody = mcaa->GetMCBody()->ExportBRep(); 
    mcaaReport.Build();
    out.Add(mcaaReport);
    if (formatmaillage != 2)
    {
        delete mcaa;
    }        
    out.WriteFile(basename+".html");

    gest->enregistrer((char*)(basename+std::string("_MCBody.magic")).c_str());
    /// Meshing the MCT
    std::set < CAD4FE::MCFace * > lst_mc_faces;
    std::set < CAD4FE::MCEdge * > lst_mc_edges;
    std::set < CAD4FE::MCVertex * > lst_mc_vertices;
    std::set < MG_COQUILLE * > lst_mc_shell;
    std::set < MG_BOUCLE * > lst_mc_loop;

    // initialize MC face, MC edge, MC loop, MC shell, and MC vertices lists
    unsigned nb_shells = mcBody->get_nb_mg_coquille ();
    for (unsigned it_shells = 0; it_shells < nb_shells; it_shells++)
    {
            MG_COQUILLE * shell = mcBody->get_mg_coquille(it_shells);
            lst_mc_shell.insert(shell);
            unsigned nb_coface = shell->get_nb_mg_coface();
            for (unsigned it_coface = 0; it_coface < nb_coface; it_coface++)
            {
                    CAD4FE::MCFace * face = (CAD4FE::MCFace *)shell->get_mg_coface(it_coface)->get_face();
                    lst_mc_faces.insert(face);

                    unsigned nb_loop = face->get_nb_mg_boucle();
                    for (unsigned it_loop = 0; it_loop < nb_loop; it_loop++)
                    {
                            MG_BOUCLE * loop = face->get_mg_boucle(it_loop);
                            lst_mc_loop.insert(loop);
                            unsigned nb_edge = loop->get_nb_mg_coarete();

                            for (unsigned it_edge = 0; it_edge < nb_edge; it_edge++)
                            {
                                    CAD4FE::MCEdge * edge = (CAD4FE::MCEdge*)loop->get_mg_coarete(it_edge)->get_arete();
                                    lst_mc_edges.insert(edge);

                                    lst_mc_vertices.insert ((CAD4FE::MCVertex*)edge->get_cosommet1()->get_sommet());
                                    lst_mc_vertices.insert ((CAD4FE::MCVertex*)edge->get_cosommet2()->get_sommet());
                            }
                    }
            }
    }
        
mgmai=new MG_MAILLAGE(mggeo);  
gest->ajouter_mg_maillage(mgmai);
    
if (niveau>-1)
        {       
        affiche("MAILLAGE 0D");
        for (std::set<CAD4FE::MCVertex *>::iterator itVertex = lst_mc_vertices.begin(); itVertex != lst_mc_vertices.end(); itVertex++)
        {
            double coo[3];
            CAD4FE::MCVertex * mcVertex = *itVertex;
            mcVertex->get_point()->evaluer(coo);
            CAD4FE::MCNode * n = new CAD4FE::MCNode(mcVertex,mcVertex->GetRefVertex(),coo[0],coo[1],coo[2]);
            n->incrementer();
            mcVertex->get_lien_maillage()->ajouter(n);
            mgmai->ajouter_mg_noeud(n);
        }
        }
if (niveau>0)
        {
        affiche("MAILLAGE 1D");
        for (std::set<CAD4FE::MCEdge *>::iterator itEdge = lst_mc_edges.begin(); itEdge != lst_mc_edges.end(); itEdge++)
                {
                CAD4FE::MCEdge* mcEdge=*itEdge;
                printf("Arete %lx\n", mcEdge->get_id());
                CAD4FE::MAILLEUR1D m1d(mgmai,mggeo,mcEdge,metrique);
                m1d.maille();
                }
        }              
if (niveau>1)
{
        affiche("MAILLAGE 2D");   
        CAD4FE::MAILLEUR2D::priorite_metrique=prioritemetrique;
        int iFace=0;
        for (std::set<CAD4FE::MCFace *>::iterator itFace = lst_mc_faces.begin(); itFace != lst_mc_faces.end(); itFace++)
        {
                char mess[100];
                CAD4FE::MCFace* face=*itFace;
                sprintf(mess,"  face %d / %lu  ",++iFace,lst_mc_faces.size());
                affiche(mess);
                affiche("");                
                CAD4FE::MAILLEUR2D m2d(mgmai,mggeo,face,metrique);
                m2d.debug=debug;
                m2d.maille();
                m2d.optimise_bascule_segment(face);
                m2d.optimise(face);
        }
}
         
    CAD4FE::MeshQualityReport meshQualReport(mgmai, metrique, basename);
    meshQualReport.SetQualityColorMap(qual_nb, qual_intervalles, qual_couleurs);
    meshQualReport.Build();
    out.Add(meshQualReport);                         
    out.Add("<h3>FEM_MAILLAGE and COSMOS/M output</h3>");
    if ((fem_maillage_degre==1||fem_maillage_degre==2) && (niveau == 3))
    {
        std::ostringstream tmp;tmp<<"Degree of elements = "<<(fem_maillage_degre)<<"<br>";
        tmp<<"The session file is located <a href=\"file:///"<<fem_maillage_export_cosmos<<".ses\">here</a>, Use the following command in COSMOS/M";
            tmp<<"<pre>FILE,"<<fem_maillage_export_cosmos<<".ses,0,0,0</pre><br>";    
        out.Add(tmp.str());
    }             
    if (niveau == 1)
    {
        std::ostringstream tmp;tmp<<"The \"FEM_MAILLAGE\" and COSMOS meshes were not generated because only the mesh of curves was generated<br>";
        out.Add(tmp.str());
    }

    if (niveau == 2)
    {
        std::ostringstream tmp;tmp<<"The \"FEM_MAILLAGE\" and COSMOS meshes were not generated because only the surfacic mesh was generated<br>";
        out.Add(tmp.str());
    }
    out.WriteFile(basename+".html");

                                
        CAD4FE::MCMesh_SetSaveFormat(mgmai,formatmaillage);           
        if (formatmaillage==2)
        {                                      
            mcaa->GetMCBody()->DeleteBRep(gest,mggeo);
        }
        /*
        if (niveau==3)
        {                        
            affiche("MAILLAGE 3D");
            if (formatmaillage == 2)
            {
                ::MAILLEUR3D_DIA m3d(mgmai,mggeo,refBody);
                m3d.maille(refBody);
            }
            else
            {
                ::MAILLEUR3D_DIA m3d(mgmai,mggeo,mcBody);
                m3d.maille(mcBody);
            }
            }*/

    /// FEM Maillage
    if (fem_maillage_degre==1 && niveau == 3)
    {
        affiche("Generating \"FEM maillage\" with linear mesh elements");
        femMesh = new FEM_MAILLAGE (mggeo, mgmai, 1);
        gest->ajouter_fem_maillage(femMesh);
        MAILLEUR_FEM m;
        m.maille(femMesh,0);
    }
    if (fem_maillage_degre==2 && niveau == 3)
    {                                                                    
        affiche("Generating \"FEM maillage\" with quadratic mesh elements");
        femMesh = new FEM_MAILLAGE (mggeo, mgmai, 2);
        gest->ajouter_fem_maillage(femMesh);
        CAD4FE::construire_fem_maillage_quadratique(femMesh);
    }
    if (fem_maillage_export_cosmos && femMesh)
    {
        affiche ("Exporting to COSMOS/M session file");
        std::string tmpFilename(fem_maillage_export_cosmos);
        femMesh->exporter_cosmos(tmpFilename);
    }                             

    affiche("Enregistrement");
    gest->enregistrer(MAGIC_filename);
                  
    affiche("Finished successfully");
    
    delete metrique;
    delete gest;

return 0;
}


#pragma package(smart_init)
Revision:	1193
Committed:	Fri May 23 20:09:25 2025 UTC (3 months ago) by francois
File size:	25522 byte(s)
Log Message:	dans les polycristaux les bornes sont calculés dans le programme pour chaque echantillon