Ubuntu-fr

template<class T>
class FEM_BASE
{
protected :
    GModel *gm;
public :
    FEM_BASE (GModel *_gm) :  gm(_gm) {};
    void numbering(int physical,
                   int dimOfPhysical,
                   int icomp,
                   int iField,
                   Assembler<T> &assem,
                   bool isEnriched = false);
    void solve(linearSystem<T> &lsys);
    PView* getSolution(Assembler<T> &assem,std::string name, int icomp,int ifield,double time);
    virtual void setParameters(std::vector<T> par) = 0;
    virtual void build(Assembler<T> &lsys, int icomp, int ifield) = 0;
};

#include "FEM_BASE.h"

template<class T> void FEM_BASE<T>::numbering (int dimOfPhysical, 
                          int physical, 
                          int iComp, 
                          int iField, 
                          Assembler<T> &assem,
                          bool enriched)
{
    
    std::vector<MVertex *> v;
    gm->getMeshVerticesForPhysicalGroup(dimOfPhysical,physical,v);
    for (unsigned int i=0;i<v.size();i++){
        assem.numberVertex (v[i], iComp, iField);    
    }  
}

template<class T> void FEM_BASE<T>::solve (linearSystem<T> &lsys)
{
    lsys->systemSolve(); 
}

template<class T> PView* FEM_BASE<T>::getSolution(Assembler<T> &assem, 
                                                  std::string name,
                                                  int icomp, 
                                                  int ifield,
                                                  double time)
{
    std::vector<GEntity*> entities;
    gm->getEntities(entities);
    std::map<int, std::vector<double> > d;
    for(unsigned int i = 0; i < entities.size(); i++){
        for(unsigned int j = 0; j < entities[i]->getNumMeshVertices(); j++){
            MVertex *v = entities[i]->getMeshVertex(j);
            d[v->getNum()].push_back(assem.getDofValue(v,icomp,ifield));
        }
    }
    PView *p = new PView(name,"NodeData",gm,d,time,ifield);
    return p;
}

template<class T>
class BS_European : public FEM_BASE<T>
{
protected :
    GModel *gm;
    double vol;
    double r;
    double dt;
public :
    BS_European (GModel *_gm) : FEM_BASE<T>(_gm) , gm(_gm) {};    
    void setParameters(std::vector<T> par);
    void build(Assembler<T> &lsys, int icomp, int ifield);
};

template<class T> void BS_European<T>::setParameters(std::vector<T> par)
{
    vol(par[0]);
    r(par[1]);
    dt(par[2]);
};

template<class T> void BS_European<T>::build(Assembler<T> &lsys, int icomp, int ifield)
{
    // create matrix blocks
    Mass_Block<T>       mass(gm);
    Stiffness_Block<T>  stiff(gm);
    Mixed_Block<T>      mixed(gm);
    Source_Block<T>     source(gm);

    std::vector<GEntity*> entities;
    gm->getEntities(entities);

    for(unsigned int i = 0; i < entities.size(); i++){
        for(unsigned int j = 0; j < entities[i]->getNumMeshVertices(); j++){
            MVertex *v = entities[i]->getMeshVertex(j);
            double val = 1.0/dt - r;
            lsys.parVertex(v,icomp,ifield,val);
        }
    }
    
    mass.build(lsys,icomp,ifield);

    for(unsigned int i = 0; i < entities.size(); i++){
        for(unsigned int j = 0; j < entities[i]->getNumMeshVertices(); j++){
            MVertex *v = entities[i]->getMeshVertex(j);
            double val = -0.5 * vol * vol * v->x() * v->x();
            lsys.parVertex(v,icomp,ifield,val);
        }
    }
    
    stiff.build(lsys,icomp,ifield);

    for(unsigned int i = 0; i < entities.size(); i++){
        for(unsigned int j = 0; j < entities[i]->getNumMeshVertices(); j++){
            MVertex *v = entities[i]->getMeshVertex(j);
            double val = r * v->x() ;
            lsys.parVertex(v,icomp,ifield,val);
        }
    }
    mixed.build(lsys,icomp,ifield);

    for(unsigned int i = 0; i < entities.size(); i++){
        for(unsigned int j = 0; j < entities[i]->getNumMeshVertices(); j++){
            MVertex *v = entities[i]->getMeshVertex(j);
            double val = 1.0 / dt;
            lsys.parVertex(v,icomp,ifield,val);
        }
    }
    source.build(lsys,icomp,ifield);
};

"FEM_BASE<double>::numbering(int, int, int, int, Assembler<double>&, bool)", referenced from:
      _main in main.o
  "BS_European<double>::build(Assembler<double>&, int, int)", referenced from:
      _main in main.o
      vtable for BS_European<double>in main.o
  "BS_European<double>::setParameters(std::vector<double, std::allocator<double> >)", referenced from:
      _main in main.o
      vtable for BS_European<double>in main.o
ld: symbol(s) not found
collect2: ld returned 1 exit status