src/expde/domain/d_exam.h

Go to the documentation of this file.

//    expde: expression templates for partial differential equations.
//    Copyright (C) 2001  Christoph Pflaum
//    This program is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    This program is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//                 SEE  Notice1.doc made by 
//                 LAWRENCE LIVERMORE NATIONAL LABORATORY
//

// ------------------------------------------------------------
//
// d_exam.h
//
// ------------------------------------------------------------

#ifndef DEXAM_H_
#define DEXAM_H_
        
// derived class: ball, square

PointtypeD All_interior(D3vector V);

//  SQUARE:      [0,1]^3
// ----------------------------------------------

PointtypeD All_interior(D3vector V);
double dis_Square(D3vector V, dir_3D d);

class Square : public Convex_domains {
 public:
  Square(); 
};


inline Square::Square() : Convex_domains(All_interior,dis_Square,1) {
  A = D3vector(0.0,0.0,0.0);
  H = 1.0;
  VecH = D3vector(1.0,1.0,1.0);
}


//  BALL:         Radius: 0.5,  center: (0.5,0.5,0.5)
// ---------------------------------------------------

double dis_Ball(D3vector V, dir_3D d);
PointtypeD Poi_Ball(D3vector V);

class Ball : public Convex_domains {
 public:
  Ball();
};

inline Ball::Ball() : Convex_domains(Poi_Ball,dis_Ball,1) {
}

//  Cylinder:         Radius: 0.5,  center: (0.5,0.5,0.5)
// ---------------------------------------------------

double dis_Cylinder(D3vector V, dir_3D d);
PointtypeD Poi_Cylinder(D3vector V);

class Cylinder : public Convex_domains {
 public:
  Cylinder();
};

inline Cylinder::Cylinder() : Convex_domains(Poi_Cylinder,dis_Cylinder,1) {
  A = D3vector(0.0,0.0,0.0);
  H = 1.0;
  VecH = D3vector(1.0,1.0,1.0);
}



//  skew cylinder:         radius: r_down...r_top,  center: (0.0,0.0,0.5)
// ----------------------------------------------------------

double dis_Skew_cylinder(D3vector V, dir_3D d, double R_down, double R_top);
PointtypeD Poi_Skew_cylinder(D3vector V, double R_down, double R_top);

class Skew_cylinder : public Convex_domains_2P {
 public:
  Skew_cylinder(double r_down, double r_top);
};

inline Skew_cylinder::Skew_cylinder(double r_down, double r_top) :
  Convex_domains_2P(Poi_Skew_cylinder,dis_Skew_cylinder,1) {
  R_down = r_down;
  R_top  = r_top;
  if(R_down<=0.0 || R_top<=0.0) 
    cout << "\n Mistake in constructor Skew_cylinder!" << endl;
  A = D3vector(-MAX(R_down,R_top),-MAX(R_down,R_top),0.0);
  H = MAX(1.0,2.0*MAX(R_down,R_top));
  VecH = D3vector(1.0,1.0,H);
}

//  double cylinder:    radius: r_interior...r_outside, center: (0.0,0.0,0.5)
// ----------------------------------------------------------

double dis_Double_cylinder(D3vector V, dir_3D d, double R_in, double R_out);
PointtypeD Poi_Double_cylinder(D3vector V, double R_in, double R_out);

class Double_cylinder : public Convex_domains_2P {
 public:
  Double_cylinder(double r_in, double r_out);
};

inline Double_cylinder::Double_cylinder(double r_in, double r_out) :
  Convex_domains_2P(Poi_Double_cylinder,dis_Double_cylinder,1) {
  R_down = r_in;
  R_top  = r_out;
  if(r_in<=0.0 || r_out<=0.0 || r_in > r_out) 
    cout << "\n Mistake in constructor Double_cylinder!" << endl;
  A = D3vector(-r_out,-r_out,0.0);
  H = MAX(1.0,2.0*r_out);
  VecH = D3vector(H,H,1.0);
}

//  SCREW SQUARE:  angles:               alpha_up, alpha_down
// ----------------------------------------------------------

double dis_Skew_square(D3vector V, dir_3D d, double R_down, double R_top);
PointtypeD Poi_Skew_square(D3vector V, double R_down, double R_top);

class Skew_square : public Convex_domains_2P {
 public:
  Skew_square(double r_down, double r_top);
};

inline Skew_square::Skew_square(double alpha_down, double alpha_top) :
  Convex_domains_2P(Poi_Skew_square,dis_Skew_square,1) {
  R_down = alpha_down;
  R_top  = alpha_top;

  A = D3vector(0.0,0.0,MIN(0.0,my_tan(R_down)));
  H = MAX(1.0,MAX(1.0-my_tan(R_down),1.0+my_tan(R_top),1.0+my_tan(R_top)-my_tan(R_down)));
  VecH = D3vector(1.0,1.0,H);
}

//  SCREW SQUARE DTLR:  angles:            alpha_up,   alpha_down
//                                         alpha_left, alpha_right
// ----------------------------------------------------------------

double dis_Skew_squareDTLR(D3vector V, dir_3D d, 
                           double R_down, double R_top, 
                           double R_left, double R_right);
PointtypeD Poi_Skew_squareDTLR(D3vector V, 
                               double R_down, double R_top,
                               double R_left, double R_right);

class Skew_squareDTLR : public Convex_domains_4P {
 public:
  Skew_squareDTLR(double r_down, double r_top, double r_left, double r_right);
};

/* old
inline Skew_squareDTLR::Skew_squareDTLR(double alpha_down,double alpha_top,
                                        double alpha_left,double alpha_right) :
  Convex_domains_4P(Poi_Skew_squareDTLR,dis_Skew_squareDTLR,1) {
  double H_DT, H_LR;
  R_down  = alpha_down;
  R_top   = alpha_top;
  R_left  = alpha_left;
  R_right = alpha_right;

  A = D3vector(0.0,MIN(0.0,my_tan(R_left)),MIN(0.0,my_tan(R_down)));
  H_DT = MAX(1.0-my_tan(R_down),1.0+my_tan(R_top),1.0+my_tan(R_top)-my_tan(R_down));
  H_LR = MAX(1.0-my_tan(R_left),1.0+my_tan(R_right),1.0+my_tan(R_right)-my_tan(R_left));
  H = MAX(1.0,MAX(H_DT,H_LR));
  VecH = D3vector(1.0,H_LR,H_DT);
}
*/


inline Skew_squareDTLR::Skew_squareDTLR(double alpha_down,double alpha_top,
                                        double alpha_left,double alpha_right) :
  Convex_domains_4P(Poi_Skew_squareDTLR,dis_Skew_squareDTLR,1) {
  double H_DT, H_LR;
  R_down  = alpha_down;
  R_top   = alpha_top;
  R_left  = alpha_left;
  R_right = alpha_right;

  A = D3vector(MIN(0.0,my_tan(R_down)),MIN(0.0,my_tan(R_left)),0.0);
  H_DT = MAX(1.0-my_tan(R_down),1.0+my_tan(R_top),1.0+my_tan(R_top)-my_tan(R_down));
  H_LR = MAX(1.0-my_tan(R_left),1.0+my_tan(R_right),1.0+my_tan(R_right)-my_tan(R_left));
  H = MAX(1.0,MAX(H_DT,H_LR));
  VecH = D3vector(H_DT,H_LR,1.0);
}




//  periodic Cylinder:         Radius: 0.5,  center: (0.5,0.5,0.5)
// ---------------------------------------------------

double dis_periodic_Cylinder(D3vector V, dir_3D d);
PointtypeD Poi_periodic_Cylinder(D3vector V);

class Periodic_cylinder : public Convex_domains {
 public:
  Periodic_cylinder();
};

inline Periodic_cylinder::Periodic_cylinder() : Convex_domains(Poi_periodic_Cylinder,
                                                               dis_periodic_Cylinder,1) {
  A = D3vector(0.0,0.0,0.0);
  H = 1.0;
  VecH = D3vector(1.0,1.0,1.0);
  is_periodic = true;
#ifndef PERIODIC
      cout << " Do not use Periodic_cylinder with non periodic data structure!" << endl; 
#endif
}




#endif
           

---