src/expde/grid/hash.cc

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
//

// ------------------------------------------------------------
//
// hash.cc
//
// ------------------------------------------------------------


// Include level 0:
#ifdef COMP_GNUOLD
 #include <iostream.h>
 #include <fstream.h>
 #include <time.h>
 #include <math.h>
#else
 #include <iostream>
 #include <fstream>
 #include <ctime>
 #include <cmath>
#endif 


// Include level 0:
#include "../parser.h"

// Include level 1:
#include "../paramete.h"
#include "../abbrevi.h"
#include "../math_lib/math_lib.h"

// Include level 2:
#include "../basic/basic.h"

// Include level 3:
#include "../domain/domain.h"

// Include level 4:
#include "../formulas/boundy.h"
#include "../formulas/loc_sten.h"

// Include level 5:
#include "gpar.h"
#include "parallel.h"
#include "mgcoeff.h"
#include "sto_man.h"
#include "gridbase.h"
#include "grid.h"



// Elementares fuer hashtable0
// ----------------------------
void Grid_base::Initialize_hash0(int lenght) {
  int i;
  hashtable0_leng = Find_next_prime(lenght);
  hashtable0_start = new Point_hashtable0*[hashtable0_leng];
  for(i=0;i<hashtable0_leng;++i)
    hashtable0_start[i] = NULL;
  hashtable0_occ=0;
}

void Grid_base::Info_hashtable0() {
  int max_depth;
  double ave_depth;
  Depth_hashtable0(&max_depth,&ave_depth);
  cout << "  Hashtable0: "  << endl;
  cout << "     Maximal depth: "  << max_depth << endl;
  cout << "     Average depth: "  << ave_depth << endl;
  cout << "     Enties: " << hashtable0_occ  << endl;
  cout << "     Length: " << hashtable0_leng  << endl;
}


void Grid_base::Depth_hashtable0(int* max_depth, 
                                double* ave_depth) {
  static int i, s, anz;
  static Point_hashtable0* point;
  *max_depth=0;
  *ave_depth=0;
  anz=0;
  for(i=0;i<hashtable0_leng;++i) {
    s=0;
    for(point=hashtable0_start[i];point!=NULL;point=point->next) ++s;
    if(*max_depth<s) *max_depth=s;
    if(s!=0) anz++;
    *ave_depth = *ave_depth + s;
  }
  *ave_depth = *ave_depth / anz;
}

void Grid_base::Resize_hash0(int lenght) {
  int i, hashtable0_leng_new, hashtable0_leng_old;
  Index3D I;
  lenght = Find_next_prime(lenght);
  Point_hashtable0* point;
  Point_hashtable0** hashtable0_start_new;
  Point_hashtable0** hashtable0_start_old;
  // Neuer hashtable:
  hashtable0_leng_new = lenght;
  hashtable0_start_new = new Point_hashtable0*[hashtable0_leng_new];
  for(i=0;i<hashtable0_leng_new;++i)
    hashtable0_start_new[i] = NULL;
  // Uebertrag:
  iterate_hash0 {
    I = point0->ind;
    point = hashtable0_start_new
      [hashtable0_function(I.ind_x.index,I.ind_y.index,I.ind_z.index,
                           hashtable0_leng_new)];
    if(point==NULL) {
      hashtable0_start_new
        [hashtable0_function(I.ind_x.index,I.ind_y.index,I.ind_z.index,
                             hashtable0_leng_new)] = 
        new Point_hashtable0(point0);
    }
    else {
      //      while(point->next!=NULL && point->ind!=I) point = point->next;
      while(point->next!=NULL) point = point->next;
        point->next =   new Point_hashtable0(point0);
      }
    }
  //Tausch
  hashtable0_leng_old  = hashtable0_leng;
  hashtable0_start_old = hashtable0_start;
  hashtable0_leng  = hashtable0_leng_new;
  hashtable0_start = hashtable0_start_new;

  //Loeschen des alten hashtables:
  for(i_iter=0;i_iter<hashtable0_leng_old;++i_iter) {
    point0=hashtable0_start_old[i_iter];
    delete point0;
  }
  delete hashtable0_start_old;
}


void Grid_base::Print_hashtable0() {
  static int num;
  cout << "Print hashtable 0:" << endl;
  cout << "Besetzung:" << hashtable0_occ << endl;
  num=0;
  iterate_hash0 {
    num++;
    cout << num << " "; point0->ind.coordinate().Print(); cout << endl;
  }
}



void Grid_base::Remove_edges() {
  Point_hashtable0* point_old; 
  for(i_iter=0;i_iter<hashtable0_leng;++i_iter) {
    point0=hashtable0_start[i_iter];
    if(point0!=NULL) {
      // Anfangspunkt ist Kante
      if(point0->ind.Edge_index()) {
        hashtable0_start[i_iter] = point0->next;
        point0->next = NULL;
        delete(point0);
        --hashtable0_occ;
        point0=hashtable0_start[i_iter];
      }
      point_old = point0;
      if(point_old!=NULL) {
        for(point0=point0->next;point0!=NULL;) {
          // Listenpunkt ist Kante
          if(point0->ind.Edge_index()) {
            point_old->next = point0->next;
            point0->next = NULL;
            delete(point0);
            --hashtable0_occ;
            point0=point_old->next;
          }
          // In Liste weitergehen
          else {
            point_old=point_old->next;
            point0=point0->next;
          }
        }
      }
    }
  }
}

// Elementares fuer hashtable1
// ----------------------------
void Grid_base::Initialize_hash1(int lenght) {
  int i;
  hashtable1_leng = Find_next_prime(lenght);
  hashtable1_start = new Point_hashtable1*[hashtable1_leng];
  for(i=0;i<hashtable1_leng;++i)
    hashtable1_start[i] = NULL;
  hashtable1_occ=0;
}

void Grid_base::Resize_hash1(int lenght) {
  int i, hashtable1_leng_new, hashtable1_leng_old;
  Index3D I;
  lenght = Find_next_prime(lenght);
  Point_hashtable1* point;
  Point_hashtable1** hashtable1_start_new;
  Point_hashtable1** hashtable1_start_old;
  // Neuer hashtable:
  hashtable1_leng_new = lenght;
  hashtable1_start_new = new Point_hashtable1*[hashtable1_leng_new];
  for(i=0;i<hashtable1_leng_new;++i)
    hashtable1_start_new[i] = NULL;
  // Uebertrag:
  iterate_hash1 {
    I = point1->ind;
    point = hashtable1_start_new
      [hashtable1_function(I.ind_x.index,I.ind_y.index,I.ind_z.index,
                           hashtable1_leng_new)];
    if(point==NULL) {
      hashtable1_start_new
        [hashtable1_function(I.ind_x.index,I.ind_y.index,I.ind_z.index,
                             hashtable1_leng_new)] = 
        new Point_hashtable1(point1);
    }
    else {
      //      while(point->next!=NULL && point->ind!=I) point = point->next;
      while(point->next!=NULL) point = point->next;
        point->next =   new Point_hashtable1(point1);
      }
    }
  //Tausch
  hashtable1_leng_old  = hashtable1_leng;
  hashtable1_start_old = hashtable1_start;
  hashtable1_leng  = hashtable1_leng_new;
  hashtable1_start = hashtable1_start_new;

  //Loeschen des alten hashtables:
  for(i_iter=0;i_iter<hashtable1_leng_old;++i_iter) {
    point1=hashtable1_start_old[i_iter];
    delete point1;
  }
  delete hashtable1_start_old;
}


void Grid_base::Info_hashtable1() {
  int max_depth;
  double ave_depth;
  Depth_hashtable1(&max_depth,&ave_depth);
  cout << "  Hashtable1: "  << endl;
  cout << "     Maximal depth: "  << max_depth << endl;
  cout << "     Average depth: "  << ave_depth << endl;
  cout << "     Enties: " << hashtable1_occ  << endl;
  cout << "     Length: " << hashtable1_leng  << endl;
}


void Grid_base::Recursion_Print_cell_info(Index3D I) {
  int i;
  Index3D son;
  for(i=0;i<8;++i) {
    son = I.son((dir_sons)i);
    if(Exists_Point(son))
      Recursion_Print_cell_info(I.son((dir_sons)i));
    else {
      cout << " Punkt: "; son.coordinate().Print();
      cout << " Zellinfo: " << (int)Give_cell_typ(I.son((dir_sons)i)) << endl;
    }
  }
}

void Grid_base::Print_cell_info() {
  static Index3D ind;

  cout << "\n Infortmation ueber Zellen: \n";
  ind = Index3D(2,2,2);

  Recursion_Print_cell_info(ind);
}


void Grid_base::Print_hashtable1() {
  static int num;
  cout << "Print hashtable 1:" << endl;
  cout << "Besetzung:" << hashtable1_occ << endl;
  num=0;
  iterate_hash1 {
    num++;
    cout << num << " "; point1->ind.coordinate().Print(); 
    cout << ", Typ: " << (int)point1->typ << ", level: " << point1->level << endl;
  }
}


void Grid_base::Depth_hashtable1(int* max_depth, 
                                double* ave_depth) {
  static int i, s, anz;
  static Point_hashtable1* point;
  *max_depth=0;
  *ave_depth=0;
  anz=0;
  for(i=0;i<hashtable1_leng;++i) {
    s=0;
    for(point=hashtable1_start[i];point!=NULL;point=point->next) ++s;
    if(*max_depth<s) *max_depth=s;
    if(s!=0) anz++;
    *ave_depth = *ave_depth + s;
  }
  *ave_depth = *ave_depth / anz;
}


void Grid_base::Remove_exterior_points() {
  Point_hashtable1* point_old; 
  Pointtype poi_typ;
  for(i_iter=0;i_iter<hashtable1_leng;++i_iter) {
    point1=hashtable1_start[i_iter];
    // a)
    if(point1!=NULL) poi_typ = point1->typ;
    while(point1!=NULL && poi_typ==exterior) {
      // Anfangspunkt ist exterior
      hashtable1_start[i_iter] = point1->next;
      point1->next = NULL;
      delete(point1);
      --hashtable1_occ;
      point1=hashtable1_start[i_iter];
      if(point1!=NULL) poi_typ = point1->typ;
    }
    // b)
    point_old = point1;
    if(point_old!=NULL) {
      for(point1=point1->next;point1!=NULL;) {
        // Listenpunkt ist exterior
        if(point1->typ==exterior) {
          point_old->next = point1->next;
          point1->next = NULL;
          delete(point1);
          --hashtable1_occ;
          point1=point_old->next;
        }
        // In Liste weitergehen
        else {
          point_old=point_old->next;
          point1=point1->next;
        }
      }
    }
  }
}

// Elementares fuer hashtable2
// ----------------------------
void Grid_base::Initialize_hash2(int lenght) {
  int i;
  hashtable2_leng = Find_next_prime(lenght);
  hashtable2_start = new Point_hashtable2*[hashtable2_leng];
  for(i=0;i<hashtable2_leng;++i)
    hashtable2_start[i] = NULL;
  hashtable2_occ=0;
}


void Grid_base::Info_hashtable2() {
  int max_depth;
  double ave_depth;
  Depth_hashtable2(&max_depth,&ave_depth);
  cout << "  Hashtable2: "  << endl;
  cout << "     Maximal depth: "  << max_depth << endl;
  cout << "     Average depth: "  << ave_depth << endl;
  cout << "     Enties: " << hashtable2_occ  << endl;
  cout << "     Length: " << hashtable2_leng  << endl;
}


void Grid_base::Print_hashtable2() {
  static int num;
  cout << "Print hashtable 2:" << endl;
  cout << "Besetzung:" << hashtable2_occ << endl;
  num=0;
  iterate_hash2 {
    num++;
    cout << num << " "; bocell->ind.coordinate().Print(); cout << endl;
  }
}


void Grid_base::Depth_hashtable2(int* max_depth, 
                                double* ave_depth) {
  static int i, s, anz;
  static Point_hashtable2* point;
  *max_depth=0;
  *ave_depth=0;
  anz=0;
  for(i=0;i<hashtable2_leng;++i) {
    s=0;
    for(point=hashtable2_start[i];point!=NULL;point=point->next) ++s;
    if(*max_depth<s) *max_depth=s;
    if(s!=0) anz++;
    *ave_depth = *ave_depth + s;
  }
  *ave_depth = *ave_depth / anz;
}


// Elementares fuer hashtable3
// ----------------------------
void Grid_base::Initialize_hash3(int lenght) {
  int i;
  hashtable3_leng = Find_next_prime(lenght);
  hashtable3_start = new Point_hashtable3*[hashtable3_leng];
  for(i=0;i<hashtable3_leng;++i)
    hashtable3_start[i] = NULL;
  hashtable3_occ=0;
}



void Grid_base::Info_hashtable3() {
  int max_depth;
  double ave_depth;
  Depth_hashtable3(&max_depth,&ave_depth);
  cout << "  Hashtable3: "  << endl;
  cout << "     Maximal depth: "  << max_depth << endl;
  cout << "     Average depth: "  << ave_depth << endl;
  cout << "     Enties: " << hashtable3_occ  << endl;
  cout << "     Length: " << hashtable3_leng  << endl;
}


void Grid_base::Print_hashtable3() {
  static int num;
  cout << "Print hashtable 3:" << endl;
  cout << "Besetzung:" << hashtable3_occ << endl;
  num=0;
  iterate_hash3 {
    num++;
    cout << num << " Coordinate : "; 
    (bo2point->transform_coord(Give_A(),H_mesh())).Print();
  }
}


void Grid_base::Depth_hashtable3(int* max_depth, 
                                double* ave_depth) {
  static int i, s, anz;
  static Point_hashtable3* point;
  *max_depth=0;
  *ave_depth=0;
  anz=0;
  for(i=0;i<hashtable3_leng;++i) {
    s=0;
    for(point=hashtable3_start[i];point!=NULL;point=point->next) ++s;
    if(*max_depth<s) *max_depth=s;
    if(s!=0) anz++;
    *ave_depth = *ave_depth + s;
  }
  *ave_depth = *ave_depth / anz;
}



// Elementares fuer hashtable4
// ----------------------------

void Grid_base::Initialize_hash4(int lenght) {
  int i;
  hashtable4_leng = Find_next_prime(lenght);
  hashtable4_start = new Point_hashtable4*[hashtable4_leng];
  for(i=0;i<hashtable4_leng;++i)
    hashtable4_start[i] = NULL;
  hashtable4_occ=0;
}

void Grid_base::Info_hashtable4() {
  int max_depth;
  double ave_depth;
  Depth_hashtable4(&max_depth,&ave_depth);
  cout << "  Hashtable4: "  << endl;
  cout << "     Maximal depth: "  << max_depth << endl;
  cout << "     Average depth: "  << ave_depth << endl;
  cout << "     Enties: " << hashtable4_occ  << endl;
  cout << "     Length: " << hashtable4_leng  << endl;
}

void Grid_base::Depth_hashtable4(int* max_depth, 
                                 double* ave_depth) {
  static int i, s, anz;
  static Point_hashtable4* point;
  *max_depth=0;
  *ave_depth=0;
  anz=0;
  for(i=0;i<hashtable4_leng;++i) {
    s=0;
    for(point=hashtable4_start[i];point!=NULL;point=point->next) ++s;
    if(*max_depth<s) *max_depth=s;
    if(s!=0) anz++;
    *ave_depth = *ave_depth + s;
  }
  if(anz==0) anz=1;
  *ave_depth = *ave_depth / anz;
}



void Grid_base::Print_hashtable4() {
  static int num;
  cout << "Print hashtable 4:" << endl;
  cout << "Besetzung:" << hashtable4_occ << endl;
  num=0;
  iterate_hash4 {
    num++;
    cout << num << " level,I: " << varpoint->level;
    varpoint->ind.coordinate().Print(); cout << endl;
  }
}


// Remove all hashtables

void Grid_base::Remove_all_hashtables() {

  //Loeschen des hashtable 0:
  for(i_iter=0;i_iter<hashtable0_leng;++i_iter) {
    point0=hashtable0_start[i_iter];
    delete point0;
  }
  delete hashtable0_start;

  //Loeschen des hashtable 1:
  for(i_iter=0;i_iter<hashtable1_leng;++i_iter) {
    point1=hashtable1_start[i_iter];
    delete point1;
  }
  delete hashtable1_start;

  //Loeschen des hashtable 2:
  for(i_iter=0;i_iter<hashtable2_leng;++i_iter) {
    bocell=hashtable2_start[i_iter];
    delete bocell;
  }
  delete hashtable2_start;

  //Loeschen des hashtable 3:
  for(i_iter=0;i_iter<hashtable3_leng;++i_iter) {
    bo2point=hashtable3_start[i_iter];
    delete bo2point;
  }
  delete hashtable3_start;

  //Loeschen des hashtable 4:
  for(i_iter=0;i_iter<hashtable4_leng;++i_iter) {
    varpoint=hashtable4_start[i_iter];
    delete varpoint;
  }
  delete hashtable4_start;
}

---