app-bholger/gfem/inputHelp.h

Go to the documentation of this file.

#pragma once

#include "basics.hh"
#include "toolbox.hh"
#include "unitcell.h"
#include "hp2D.hh"
#include "graphics.hh"
#include "operator/denseMatrix.hh"
#include <memory>

namespace concepts {
namespace gfem {

class InputUC_filename : public InputParameter 
{
  public:
    InputUC_filename(InOutParameters& input, std::string filename="") 
      : InputParameter(input)
      , filename(filename)
    {}

    virtual std::ostream& letters(std::ostream& os) const {
      return os << "u:";
    }
    virtual std::ostream& arguments(std::ostream& os) const {
      return os << "[-u uc_filename]";
    }
    virtual std::ostream& description(std::ostream& os) const {
      os << "  uc_filename    : filename with a cig configuration "
        " file for the unitcell."
        << std::endl;
      return os;
    }

    virtual int input(int opt, const char* optarg); 

    std::string& getFilename() {
      return filename;
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const {
         os << "InputUC_filename(";
         return arguments(os) << ")";
    }
  private:
    unsigned long long slot_;
    std::string filename;
};

class InputSol_filename : public InputParameter 
{
  public:
    InputSol_filename(InOutParameters& input, std::string filename="") 
      : InputParameter(input)
      , filename(filename)
    {}

    virtual std::ostream& letters(std::ostream& os) const {
      return os << "e:";
    }
    virtual std::ostream& arguments(std::ostream& os) const {
      return os << "[-e EF_filename]";
    }
    virtual std::ostream& description(std::ostream& os) const {
      os << "  EF_filename    : filename with the matlab matrix of"
        " the eigenfunction which will be converted in a format"
        " suitable for simplemesh and stored in 'ef_out.m'. "
        " If specified the functionality of the file changes"
        " and _no_ TE/TM Matrices are stored, but you need to"
        " give the same input parameters."
        << std::endl;
      return os;
    }

    virtual int input(int opt, const char* optarg); 

    std::string& getFilename() {
      return filename;
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const {
         os << "InputSol_filename(";
         return arguments(os) << ")";
    }
  private:
    unsigned long long slot_;
    std::string filename;
};

extern void loadEFs(const Space<Real>& uc_space, Unitcell& uc, std::string ef_filename = "work/efs.dat");

extern bool loadCoeffVector(std::string filename, 
    concepts::Vector<Cmplx>& coeffs);

template<class SpaceType, class SpaceTypeUC>
inline void storeMatlabExt(SpaceType& space, SpaceTypeUC& spaceUC, 
    std::string filename, 
    std::string filenameGrad, 
    concepts::Vector<concepts::Cmplx> sol, 
    std::string additional="", 
    bool restoreQR = true,
    int graphik = 12, 
    std::string quadType_str="trapeze"
    )
{
    concepts::intRule quadType = concepts::GAUSS_JACOBI; 
    if(quadType_str == "trapeze") {
      quadType = concepts::TRAPEZE;
    } else if(quadType_str == "gauss_lobatto") {
      quadType = concepts::GAUSS_LOBATTO;
    } else if(quadType_str == "gauss_jacobi") {
      quadType = concepts::GAUSS_JACOBI;
    } else {
      printf("Error, invalid quadrature type '%s'\n", quadType_str.c_str());
      exit(1);
    }
    printf("(store matlab graphics) using %d graphic points and quad"
        " rule of type %d (%s)\n", 
        graphik, int(quadType), quadType_str.c_str());
    
#if 1
    hp2D::IntegrableQuad::rule().set( quadType, true, graphik);
    spaceUC.recomputeShapefunctions();
    space.recomputeShapefunctions();
#endif

    hp2D::Value<Cmplx> eval_f;
    graphics::MatlabGraphics(space, filename, sol, 2, &eval_f);

    if(filenameGrad != "") {
      hp2D::Grad<Cmplx> eval_f_G;
      graphics::MatlabGraphics(space, filenameGrad, sol, 2, &eval_f_G);
    }

    if(restoreQR) {
      hp2D::IntegrableQuad::rule().set( concepts::GAUSS_JACOBI, true, 2);
      spaceUC.recomputeShapefunctions();
      space.recomputeShapefunctions();
    }

    FILE* f = fopen(filename.c_str(), "a");
    if(f) {
      fprintf(f, "\n %s\n", additional.c_str());
      fclose(f);
    } else {
      fprintf(stderr, "**** Failed to write to '%s'\n ***", filename.c_str());
    }
}

// version without spaceUC
template<class SpaceType>
inline void storeMatlabExt(SpaceType& space, 
    std::string filename, 
    std::string filenameGrad, 
    concepts::Vector<concepts::Cmplx> sol, 
    std::string additional="", 
    bool restoreQR = true,
    int graphik = 12, 
    std::string quadType_str="trapeze",
    bool addPolDegToGraphik = false // false: number of QR points = graphik 
                                    // true:  number of QR points = graphik + pol_deg
    )
{
    concepts::intRule quadType = concepts::GAUSS_JACOBI; 
    if(quadType_str == "trapeze") {
      quadType = concepts::TRAPEZE;
    } else if(quadType_str == "gauss_lobatto") {
      quadType = concepts::GAUSS_LOBATTO;
    } else if(quadType_str == "gauss_jacobi") {
      quadType = concepts::GAUSS_JACOBI;
    } else {
      printf("Error, invalid quadrature type '%s'\n", quadType_str.c_str());
      exit(1);
    }
    printf("using %d graphic points and quad rule of type %d (%s)\n", graphik, int(quadType), 
        quadType_str.c_str());
    
#if 1
    hp2D::IntegrableQuad::rule().set( quadType, !addPolDegToGraphik, graphik);
    space.recomputeShapefunctions();
#endif

    hp2D::Value<Cmplx> eval_f;
    graphics::MatlabGraphics(space, filename, sol, 2, &eval_f);

    hp2D::Grad<Cmplx> eval_f_G;
    graphics::MatlabGraphics(space, filenameGrad, sol, 2, &eval_f_G);

    if(restoreQR) {
      hp2D::IntegrableQuad::rule().set( concepts::GAUSS_JACOBI, true, 2);
      space.recomputeShapefunctions();
    }

    FILE* f = fopen(filename.c_str(), "a");
    if(f) {
      fprintf(f, "\n %s\n", additional.c_str());
      fclose(f);
    } else {
      fprintf(stderr, "**** Failed to write to '%s'\n ***", filename.c_str());
    }
}

std::auto_ptr< DenseMatrix<Real> > loadRawMatrix(std::string filename);

} // namespace
} // namespace