Skip to content
Snippets Groups Projects
Select Git revision
  • master
  • albertpiwonski-master-patch-57409
  • quadspheres
  • fix_Tmatrix_code_epsr_background
  • albertpiwonski-master-patch-12427
  • cavity
  • c1
7 results

infos.xml

Blame
    • Iso.cpp 7.36 KiB 
    // $Id: Iso.cpp,v 1.2 2001-08-09 13:27:41 remacle Exp $

#include "Gmsh.h"
#include "Mesh.h"
#include "Draw.h"
#include "Numeric.h"

void RaiseFill(int i, double Val, double ValMin, double Raise[3][5]);

/* ------------------------------------------------------------------------ */
/*  I n t e r p o l a t e                                                   */
/* ------------------------------------------------------------------------ */

double InterpolateIso(double *X, double *Y, double *Z, 
                 double *Val, double V, int I1, int I2, 
                 double *XI, double *YI ,double *ZI){
  
  if(Val[I1] == Val[I2]){
    *XI = X[I1]; 
    *YI = Y[I1]; 
    *ZI = Z[I1]; 
    return 0;
  }
  else{
    double coef = (V - Val[I1])/(Val[I2]-Val[I1]);
    *XI= coef*(X[I2]-X[I1]) + X[I1];
    *YI= coef*(Y[I2]-Y[I1]) + Y[I1];
    *ZI= coef*(Z[I2]-Z[I1]) + Z[I1];
    return coef;
  }
}

/* ------------------------------------------------------------------------ */
/*  T r i a n g l e                                                         */
/* ------------------------------------------------------------------------ */

void CutTriangle1D(double *X, double *Y, double *Z, double *Val, 
                   double V, double Vmin, double Vmax,
                   double *Xp, double *Yp, double *Zp, int *nb){
  
  if(V != Vmax){
    *nb = 0;
    if((Val[0] > V && Val[1] <= V) || (Val[1] > V && Val[0] <= V)){
      InterpolateIso(X,Y,Z,Val,V,0,1,&Xp[*nb],&Yp[*nb],&Zp[*nb]); (*nb)++;
    }
    if((Val[0] > V && Val[2] <= V) || (Val[2] > V && Val[0] <= V)){
      InterpolateIso(X,Y,Z,Val,V,0,2,&Xp[*nb],&Yp[*nb],&Zp[*nb]); (*nb)++;
    }
    if((Val[1] > V && Val[2] <= V) || (Val[2] > V && Val[1] <= V)){
      InterpolateIso(X,Y,Z,Val,V,1,2,&Xp[*nb],&Yp[*nb],&Zp[*nb]); (*nb)++;
    }
  }
  else{
    *nb = 0;
    if((Val[0] < V && Val[1] >= V) || (Val[1] < V && Val[0] >= V)){
      InterpolateIso(X,Y,Z,Val,V,0,1,&Xp[*nb],&Yp[*nb],&Zp[*nb]); (*nb)++;
    }
    if((Val[0] < V && Val[2] >= V) || (Val[2] < V && Val[0] >= V)){
      InterpolateIso(X,Y,Z,Val,V,0,2,&Xp[*nb],&Yp[*nb],&Zp[*nb]); (*nb)++;
    }       
    if((Val[1] < V && Val[2] >= V) || (Val[2] < V && Val[1] >= V)){
      InterpolateIso(X,Y,Z,Val,V,1,2,&Xp[*nb],&Yp[*nb],&Zp[*nb]); (*nb)++;
    }
  }

}

// Il faut refaire cette routine pour que l'orientation des elements
// soit respectee.

    void CutTriangle2D(double *X, double *Y, double *Z, double *Val, 
                   double V1, double V2, double Vmin, double Vmax,
                   double *Xp2, double *Yp2, double *Zp2, int *Np2, double *Vp2){

  int     i, io[3],j,iot,Np,Fl;
  double  Xp[5],Yp[5],Zp[5],Vp[5];

  *Np2 = 0;

  for(i=0;i<3;i++) io[i] = i;

  for(i=0;i<2;i++){
    for(j=i+1;j<3;j++){
      if(Val[io[i]]>Val[io[j]]){
        iot = io[i];
        io[i] = io[j];
        io[j] = iot;
      }
    }
  }

  /* io[] contient un indexage des noeuds t.q. Val[io[i]] > Val[io[j]] si i > j */

  if(Val[io[0]] > V2) return;
  if(Val[io[2]] < V1) return;

  if(V1 <= Val[io[0]] && Val[io[2]] <= V2){
    memcpy(Vp2,Val,3*sizeof(double));
    memcpy(Xp2,X,3*sizeof(double)); 
    memcpy(Yp2,Y,3*sizeof(double)); 
    memcpy(Zp2,Z,3*sizeof(double)); 
    *Np2 = 3;
    return;
  }

  Np = 0;
  if(V1<=Val[io[0]]){
    Vp[Np] = Val[io[0]];
    Xp[Np] = X[io[0]]; 
    Yp[Np] = Y[io[0]]; 
    Zp[Np] = Z[io[0]]; 
    Np++; Fl = 1;
  }
  else if(Val[io[0]] < V1 && V1 <= Val[io[1]]){
    Vp[Np] = V1;
    InterpolateIso(X,Y,Z,Val,V1,io[0],io[2],&Xp[Np],&Yp[Np],&Zp[Np]); Np++; 
    Vp[Np] = V1;
    InterpolateIso(X,Y,Z,Val,V1,io[0],io[1],&Xp[Np],&Yp[Np],&Zp[Np]); Np++; Fl = 1;
  }
  else {
    Vp[Np] = V1;
    InterpolateIso(X,Y,Z,Val,V1,io[0],io[2],&Xp[Np],&Yp[Np],&Zp[Np]); Np++;
    Vp[Np] = V1;
    InterpolateIso(X,Y,Z,Val,V1,io[1],io[2],&Xp[Np],&Yp[Np],&Zp[Np]); Np++; Fl = 0;
  }    

  if(V2 == Val[io[0]]){
    return;
  }
  else if((Val[io[0]]<V2) && ( V2 < Val[io[1]])){
    Vp[Np] = V2;
    InterpolateIso(X,Y,Z,Val,V2,io[0],io[1],&Xp[Np],&Yp[Np],&Zp[Np]); Np++;
    Vp[Np] = V2;
    InterpolateIso(X,Y,Z,Val,V2,io[0],io[2],&Xp[Np],&Yp[Np],&Zp[Np]); Np++;
  }
  else if(V2 < Val[io[2]]){
    if(Fl){
      Vp[Np] = Val[io[1]];
      Xp[Np] = X[io[1]]; 
      Yp[Np] = Y[io[1]]; 
          Zp[Np] = Z[io[1]];
      Np++;
    }
    Vp[Np] = V2;
    InterpolateIso(X,Y,Z,Val,V2,io[1],io[2],&Xp[Np],&Yp[Np],&Zp[Np]); Np++;
    Vp[Np] = V2;
    InterpolateIso(X,Y,Z,Val,V2,io[0],io[2],&Xp[Np],&Yp[Np],&Zp[Np]); Np++;
  }
  else{
    if(Fl){
      Vp[Np] = Val[io[1]];
      Xp[Np] = X[io[1]];
      Yp[Np] = Y[io[1]]; 
      Zp[Np] = Z[io[1]];
      Np++;
    }
    Vp[Np] = Val[io[2]];
    Xp[Np] = X[io[2]]; 
    Yp[Np] = Y[io[2]]; 
    Zp[Np] = Z[io[2]];
    Np++;
  }

  Vp2[0] = Vp[0];
  Xp2[0] = Xp[0]; 
  Yp2[0] = Yp[0]; 
  Zp2[0] = Zp[0]; 
  *Np2 = 1;

  for(i=1;i<Np;i++){
    if((Xp[i] != Xp2[(*Np2)-1]) ||(Yp[i] != Yp2[(*Np2)-1]) ||(Zp[i] != Zp2[(*Np2)-1])){      
      Vp2[*Np2] = Vp[i];
      Xp2[*Np2] = Xp[i]; 
      Yp2[*Np2] = Yp[i]; 
      Zp2[*Np2] = Zp[i];
      (*Np2)++;
    }
  }

  if(Xp2[0] == Xp2[(*Np2)-1] && Yp2[0] == Yp2[(*Np2)-1] && Zp2[0] == Zp2[(*Np2)-1]){
    (*Np2)-- ;
  }

}

/* ------------------------------------------------------------------------ */
/*  L i n e                                                                 */
/* ------------------------------------------------------------------------ */

void CutLine0D(double *X, double *Y, double *Z, double *Val, 
               double V, double Vmin, double Vmax,
               double *Xp, double *Yp, double *Zp, int *nb){
  
  *nb = 0;

  if(V != Vmax){
    if((Val[0] > V && Val[1] <= V) || (Val[1] > V && Val[0] <= V)){
      InterpolateIso(X,Y,Z,Val,V,0,1,Xp,Yp,Zp); *nb = 1;
    }
  }
  else{
    if((Val[0] < V && Val[1] >= V) || (Val[1] < V && Val[0] >= V)){
      InterpolateIso(X,Y,Z,Val,V,0,1,Xp,Yp,Zp); *nb = 1;
    }
  }
}

void CutLine1D(double *X, double *Y, double *Z, double *Val, 
               double V1, double V2, double Vmin, double Vmax,
               double *Xp2, double *Yp2, double *Zp2, int *Np2, double *Vp2){
    
  int io[2];

  if(Val[0]<Val[1]){
    io[0] = 0;
    io[1] = 1;
  }
  else{
    io[0] = 1;
    io[1] = 0;
  }

  /* io[] contient un indexage des noeuds t.q. Val[io[i]] > Val[io[j]] si i > j */

  *Np2 = 0;

  if(Val[io[0]] > V2) return;
  if(Val[io[1]] < V1) return;

  *Np2 = 2;

  if(V1 <= Val[io[0]] && Val[io[1]] <= V2){
    memcpy(Vp2,Val,2*sizeof(double));
    memcpy(Xp2,X,2*sizeof(double)); 
    memcpy(Yp2,Y,2*sizeof(double)); 
    memcpy(Zp2,Z,2*sizeof(double)); 
    return;
  }

  if(V1<=Val[io[0]]){
    Vp2[0] = Val[io[0]];
    Xp2[0] = X[io[0]]; 
    Yp2[0] = Y[io[0]]; 
    Zp2[0] = Z[io[0]]; 
  }
  else{
    Vp2[0] = V1;
    InterpolateIso(X,Y,Z,Val,V1,io[0],io[1],&Xp2[0],&Yp2[0],&Zp2[0]);
  }

  if(V2>=Val[io[1]]){
    Vp2[1] = Val[io[1]];
    Xp2[1] = X[io[1]]; 
    Yp2[1] = Y[io[1]]; 
    Zp2[1] = Z[io[1]]; 
  }
  else{
    Vp2[1] = V2;
    InterpolateIso(X,Y,Z,Val,V2,io[0],io[1],&Xp2[1],&Yp2[1],&Zp2[1]);
  }

}

void gradSimplex (double *x, double *y, double *z, double *v, double *grad){
  /*
    p = p1 * (1-u-v-w) + p2 u + p3 v + p4 w
   */

  double mat[3][3];
  double det,b[3];
  mat[0][0] = x[1]-x[0];
  mat[1][0] = x[2]-x[0];
  mat[2][0] = x[3]-x[0];
  mat[0][1] = y[1]-y[0];
  mat[1][1] = y[2]-y[0];
  mat[2][1] = y[3]-y[0];
  mat[0][2] = z[1]-z[0];
  mat[1][2] = z[2]-z[0];
  mat[2][2] = z[3]-z[0];
  b[0] = v[1]-v[0];
      b[1] = v[2]-v[0];
  b[2] = v[3]-v[0];
  sys3x3 (mat, b, grad, &det); 
}