Skip to content
Snippets Groups Projects
Select Git revision
  • 3013af52babced9c914cff711b36bf112fba736e
  • master default protected
  • dof-renumbering
  • gdemesy-master-patch-30528
  • eval-space-time
  • oscillating_multiharm
  • MH_movement
  • axisqu
  • write_vtu_and_ensight_formats
  • movingband
  • CP_1972_add_vtu_file_writing
  • mortar
  • fast_freq_sweep_Resolution
  • applyresolvent_again
  • marteaua-master-patch-54323
  • patch-1
  • binde-master-patch-08072
  • binde-master-patch-52461
  • BCGSL
  • resolvent
  • TreeElementsOf
  • getdp_3_5_0
  • getdp_3_4_0
  • getdp_3_3_0
  • getdp_3_2_0
  • getdp_3_1_0
  • getdp_3_0_4
  • getdp_3_0_3
  • getdp_3_0_2
  • getdp_3_0_1
  • getdp_3_0_0
  • onelab_mobile_2.1.0
  • getdp_2_11_3 protected
  • getdp_2_11_2 protected
  • getdp_2_11_1 protected
  • getdp_2_11_0 protected
  • getdp_2_10_0 protected
  • getdp_2_9_2 protected
  • getdp_2_9_1 protected
  • getdp_2_9_0 protected
  • getdp_2_8_0 protected
41 results

ProParser.tab.cpp

Blame
  • PViewDataIO.cpp 9.28 KiB
    // Gmsh - Copyright (C) 1997-2019 C. Geuzaine, J.-F. Remacle
    //
    // See the LICENSE.txt file for license information. Please report all
    // issues on https://gitlab.onelab.info/gmsh/gmsh/issues.
    
    #include <stdio.h>
    #include <string.h>
    #include "GmshMessage.h"
    #include "GmshDefines.h"
    #include "Numeric.h"
    #include "PViewData.h"
    #include "adaptiveData.h"
    #include "OS.h"
    
    bool PViewData::writeSTL(const std::string &fileName)
    {
      FILE *fp = Fopen(fileName.c_str(), "w");
      if(!fp) {
        Msg::Error("Unable to open file '%s'", fileName.c_str());
        return false;
      }
    
      if(!getNumTriangles() && !getNumQuadrangles()) {
        Msg::Error("No surface elements to save");
        fclose(fp);
        return false;
      }
    
      int step = getFirstNonEmptyTimeStep();
    
      fprintf(fp, "solid Created by Gmsh\n");
      for(int ent = 0; ent < getNumEntities(step); ent++) {
        for(int ele = 0; ele < getNumElements(step, ent); ele++) {
          if(getDimension(step, ent, ele) != 2) continue;
          if(skipElement(step, ent, ele)) continue;
          int N = getNumNodes(step, ent, ele);
          if(N != 3 && N != 4) continue;
          double x[4], y[4], z[4], n[3];
          for(int i = 0; i < N; i++) getNode(step, ent, ele, i, x[i], y[i], z[i]);
          normal3points(x[0], y[0], z[0], x[1], y[1], z[1], x[2], y[2], z[2], n);
          if(N == 3) {
            fprintf(fp, "facet normal %g %g %g\n", n[0], n[1], n[2]);
            fprintf(fp, "  outer loop\n");
            fprintf(fp, "    vertex %g %g %g\n", x[0], y[0], z[0]);
            fprintf(fp, "    vertex %g %g %g\n", x[1], y[1], z[1]);
            fprintf(fp, "    vertex %g %g %g\n", x[2], y[2], z[2]);
            fprintf(fp, "  endloop\n");
            fprintf(fp, "endfacet\n");
          }
          else {
            fprintf(fp, "facet normal %g %g %g\n", n[0], n[1], n[2]);
            fprintf(fp, "  outer loop\n");
            fprintf(fp, "    vertex %g %g %g\n", x[0], y[0], z[0]);
            fprintf(fp, "    vertex %g %g %g\n", x[1], y[1], z[1]);
            fprintf(fp, "    vertex %g %g %g\n", x[2], y[2], z[2]);
            fprintf(fp, "  endloop\n");
            fprintf(fp, "endfacet\n");
            fprintf(fp, "facet normal %g %g %g\n", n[0], n[1], n[2]);
            fprintf(fp, "  outer loop\n");
            fprintf(fp, "    vertex %g %g %g\n", x[0], y[0], z[0]);
            fprintf(fp, "    vertex %g %g %g\n", x[2], y[2], z[2]);
            fprintf(fp, "    vertex %g %g %g\n", x[3], y[3], z[3]);
            fprintf(fp, "  endloop\n");
            fprintf(fp, "endfacet\n");
          }
        }
      }
      fprintf(fp, "endsolid Created by Gmsh\n");
    
      fclose(fp);
      return true;
    }
    
    bool PViewData::writeTXT(const std::string &fileName)
    {
      FILE *fp = Fopen(fileName.c_str(), "w");
      if(!fp) {
        Msg::Error("Unable to open file '%s'", fileName.c_str());
        return false;
      }
    
      for(int step = 0; step < getNumTimeSteps(); step++) {
        for(int ent = 0; ent < getNumEntities(step); ent++) {
          for(int ele = 0; ele < getNumElements(step, ent); ele++) {
            if(skipElement(step, ent, ele)) continue;
            for(int nod = 0; nod < getNumNodes(step, ent, ele); nod++) {
              double x, y, z;
              getNode(step, ent, ele, nod, x, y, z);
              fprintf(fp, "%d %.16g %d %d %.16g %.16g %.16g ", step, getTime(step),
                      ent, ele, x, y, z);
              for(int comp = 0; comp < getNumComponents(step, ent, ele); comp++) {
                double val;
                getValue(step, ent, ele, nod, comp, val);
                fprintf(fp, "%.16g ", val);
              }
            }
            fprintf(fp, "\n");
          }
        }
      }
    
      fclose(fp);
      return true;
    }
    
    bool PViewData::writePOS(const std::string &fileName, bool binary, bool parsed,
                             bool append)
    {
      if(_adaptive) {
        Msg::Warning(
          "Writing adapted dataset (will only export current time step)");
        return _adaptive->getData()->writePOS(fileName, binary, parsed, append);
      }
      if(hasMultipleMeshes()) {
        Msg::Error("Cannot export multi-mesh datasets in .pos format");
        return false;
      }
      if(haveInterpolationMatrices())
        Msg::Warning(
          "Discarding interpolation matrices when saving in .pos format");
      if(binary || !parsed)
        Msg::Warning("Only parsed .pos files can be exported for this view type");
    
      FILE *fp = Fopen(fileName.c_str(), append ? "a" : "w");
      if(!fp) {
        Msg::Error("Unable to open file '%s'", fileName.c_str());
        return false;
      }
    
      fprintf(fp, "View \"%s\" {\n", getName().c_str());
    
      int firstNonEmptyStep = getFirstNonEmptyTimeStep();
      for(int ent = 0; ent < getNumEntities(firstNonEmptyStep); ent++) {
        for(int ele = 0; ele < getNumElements(firstNonEmptyStep, ent); ele++) {
          if(skipElement(firstNonEmptyStep, ent, ele)) continue;
          int type = getType(firstNonEmptyStep, ent, ele);
          int numComp = getNumComponents(firstNonEmptyStep, ent, ele);
          const char *s = 0;
          switch(type) {
          case TYPE_PNT:
            s = (numComp == 9) ? "TP" : (numComp == 3) ? "VP" : "SP";
            break;
          case TYPE_LIN:
            s = (numComp == 9) ? "TL" : (numComp == 3) ? "VL" : "SL";
            break;
          case TYPE_TRI:
            s = (numComp == 9) ? "TT" : (numComp == 3) ? "VT" : "ST";
            break;
          case TYPE_QUA:
            s = (numComp == 9) ? "TQ" : (numComp == 3) ? "VQ" : "SQ";
            break;
          case TYPE_TET:
            s = (numComp == 9) ? "TS" : (numComp == 3) ? "VS" : "SS";
            break;
          case TYPE_HEX:
            s = (numComp == 9) ? "TH" : (numComp == 3) ? "VH" : "SH";
            break;
          case TYPE_PRI:
            s = (numComp == 9) ? "TI" : (numComp == 3) ? "VI" : "SI";
            break;
          case TYPE_PYR:
            s = (numComp == 9) ? "TY" : (numComp == 3) ? "VY" : "SY";
            break;
          }
          if(s) {
            fprintf(fp, "%s(", s);
            int numNod = getNumNodes(firstNonEmptyStep, ent, ele);
            for(int nod = 0; nod < numNod; nod++) {
              double x, y, z;
              getNode(firstNonEmptyStep, ent, ele, nod, x, y, z);
              fprintf(fp, "%.16g,%.16g,%.16g", x, y, z);
              if(nod != numNod - 1) fprintf(fp, ",");
            }
            bool first = true;
            for(int step = 0; step < getNumTimeSteps(); step++) {
              if(hasTimeStep(step)) {
                for(int nod = 0; nod < numNod; nod++) {
                  for(int comp = 0; comp < numComp; comp++) {
                    double val;
                    getValue(step, ent, ele, nod, comp, val);
                    if(first) {
                      fprintf(fp, "){%.16g", val);
                      first = false;
                    }
                    else
                      fprintf(fp, ",%.16g", val);
                  }
                }
              }
            }
            fprintf(fp, "};\n");
          }
        }
      }
    
      fprintf(fp, "};\n");
      fclose(fp);
    
      return true;
    }
    
    bool PViewData::writeMSH(const std::string &fileName, double version,
                             bool binary, bool saveMesh, bool multipleView,
                             int partitionNum, bool saveInterpolationMatrices,
                             bool forceNodeData, bool forceElementData)
    {
      Msg::Error("MSH export not implemented for this view type");
      return false;
    }
    
    bool PViewData::writeMED(const std::string &fileName)
    {
      Msg::Error("MED export only available for mesh-based post-processing views");
      return false;
    }
    
    bool PViewData::toVector(std::vector<std::vector<double> > &vec)
    {
      vec.resize(getNumTimeSteps());
      for(int step = 0; step < getNumTimeSteps(); step++) {
        vec[step].clear();
        for(int ent = 0; ent < getNumEntities(step); ent++) {
          for(int ele = 0; ele < getNumElements(step, ent); ele++) {
            if(skipElement(step, ent, ele)) continue;
            for(int nod = 0; nod < getNumNodes(step, ent, ele); nod++) {
              for(int comp = 0; comp < getNumComponents(step, ent, ele); comp++) {
                double val;
                getValue(step, ent, ele, nod, comp, val);
                vec[step].push_back(val);
              }
            }
          }
        }
      }
      return true;
    }
    
    bool PViewData::fromVector(const std::vector<std::vector<double> > &vec)
    {
      if(empty() || !getNumTimeSteps()) {
        Msg::Warning("Cannot import vector in an empty view; skipping");
        return false;
      }
    
      if((int)vec.size() != getNumTimeSteps()) {
        Msg::Error(
          "Incompatible number of steps in vector for view import (%d!=%d)",
          (int)vec.size(), getNumTimeSteps());
        return false;
      }
    
      for(int step = 0; step < getNumTimeSteps(); step++) {
        int i = 0;
        for(int ent = 0; ent < getNumEntities(step); ent++) {
          for(int ele = 0; ele < getNumElements(step, ent); ele++) {
            if(skipElement(step, ent, ele)) continue;
            for(int nod = 0; nod < getNumNodes(step, ent, ele); nod++) {
              double x, y, z;
              getNode(step, ent, ele, nod, x, y, z);
              for(int comp = 0; comp < getNumComponents(step, ent, ele); comp++) {
                if(i < (int)vec[step].size()) {
                  setValue(step, ent, ele, nod, comp, vec[step][i++]);
                }
                else {
                  Msg::Error("Bad index (%d) in vector (%d) for view import", i,
                             (int)vec[step].size());
                  return false;
                }
              }
            }
          }
        }
      }
      return true;
    }
    
    void PViewData::importLists(int N[24], std::vector<double> *V[24])
    {
      Msg::Error("importLists not available for this view data type");
    }
    
    void PViewData::getListPointers(int N[24], std::vector<double> *V[24])
    {
      Msg::Error("getListPointers not avalailable for this view data type");
    }
    
    void PViewData::sendToServer(const std::string &name)
    {
      Msg::Error("sendToServer not avalailable for this view data type");
    }