Diploma Thesis Percolation Simulation C++ Sourcecode Documentation

www.AndreasKrueger.de/thesis/code

                 

---

cluster.h

Go to the documentation of this file.

// cluster.h
// storage containers for clusters
// (c) 2000 Andreas Krueger
// Version 1.0
// last change: 28.6.2000

class cluson {
private:
        LONGBITS spanning_dirs; 
public:
        NUMLIST sphlist;
public:
        cluson();
        void add_spanning(int direction);
        void set_spanning_dirs(LONGBITS direction);

        bool spanning();
        bool spanning(int direction);
        bool sp_lr();
        bool sp_tb();
        bool sp_alldirs(int dim);
};

cluson::cluson(){ spanning_dirs=(LONGBITS)0; }

void cluson::add_spanning(int direction){ 
        spanning_dirs|=(LONGBITS)pow(2,direction-1);
}
void cluson::set_spanning_dirs(LONGBITS sp_dirs){ 
        spanning_dirs=sp_dirs;
}

bool cluson::spanning(){  return (spanning_dirs!=(LONGBITS)0 ); }

bool cluson::spanning(int direction){
        return ( spanning_dirs&(LONGBITS)pow(2,direction-1) )!=0 ;
}
bool cluson::sp_lr(){   return spanning(1); }
bool cluson::sp_tb(){   return spanning(2); }

bool cluson::sp_alldirs(int dim){       
        return spanning_dirs==(LONGBITS)pow(2,dim)-1 ;
}

void add_spanning_dir_to_clusters(cluson* clusters, NUMLIST clnos, int direction){
        NUMLIST::iterator clno;
        for (clno=clnos.begin();clno!=clnos.end();clno++){
                clusters[*clno].add_spanning(direction);
        }
}

void swapcluson (cluson &c1, cluson &c2) {
                cluson temp=c1;
                c1=c2; c2=temp;
}

void reset_clusters(cluson* array, NUMBER N) {
        for (NUMBER i=0;i<=N;i++){
                array[i].sphlist.clear();
                array[i].set_spanning_dirs((LONGBITS)0);
        }
}

void nonspanning_clusters(cluson* array, NUMBER N) {
        for (NUMBER i=0;i<=N;i++){
                array[i].set_spanning_dirs((LONGBITS)0);
        }
}

void make_clusterlist_array ( sphere* spheres, 
                                                          NUMLIST &sphlist, 
                                                          cluson* clst){
        NUMLIST::iterator iter;
        NUMBER clusno, sphno;
        for (iter=sphlist.begin(); iter!=sphlist.end();iter++){
                sphno=*iter;
                clusno=spheres[sphno].clno;
                clst[clusno].sphlist.push_back(sphno);
        }
}

struct clusterneighbours {
                NUMLIST clusno;
        public:
                clusterneighbours(){};
};

void set_clusternumber(sphere *array, NUMLIST &sphlist, NUMBER clno) {
        NUMLIST::iterator iter;

        // first run for error detection
        // for (iter =  sphlist.begin(); iter != sphlist.end(); ++iter){
        //      array[*iter].clno=0;
        // }//error detection end

        for (iter =  sphlist.begin(); iter != sphlist.end(); ++iter){
                // this is error detection
                // if (array[*iter].clno != 0) {
                //         errorout ("sphere twice mentioned in cluster");
                //         cout <<" clno="<<clno<<" sphere #"<<*iter<<" sphlist.size()="<<sphlist.size()<<endl;
                //      exit(1);
                // }// error detection end
                array[*iter].clno=clno;
        }
}

void set_clustersize(sphere *array, 
                                         NUMLIST &sphlist, 
                                         NUMBER clsz) {                 // one clustersize for all spheres
        NUMLIST::iterator iter;
        for (iter =  sphlist.begin(); iter != sphlist.end(); ++iter){
                array[*iter].clsz=clsz;
        }
}

void set_clustersizes(sphere *array, 
                                          NUMLIST &sphlist, 
                                          cluson *cluster) {    // get the size of cluster[clno]
                                                                                        // and assign to each sphere in that cluster
        NUMLIST::iterator iter;
        for (iter =  sphlist.begin(); iter != sphlist.end(); ++iter){
                array[*iter].clsz=cluster[array[*iter].clno].sphlist.size();
        }
}



void copy_array(sphere *array1,sphere *array2, NUMBER first, NUMBER last) {
        for (NUMBER i=first;i<=last;i++) {
                array2[i]=array1[i];
        }
}

void compare_clustersizes(sphere *array1, sphere *array2, NUMBER first, NUMBER last) {
        for (NUMBER i=first;i<=last;i++) {
                if (array1[i].clsz != array2[i].clsz){
                        cout<<"\n"<<array1[i].c;
                        cout<<" clsz1="<<array1[i].clsz;
                        cout<<" clsz2="<<array2[i].clsz;
                }
        }
        cout<<endl;
}



void throw_spheres(sphere *array, NUMBER start, NUMBER end) {
        for ( NUMBER i=start; i<=end; i++) {
                array[i].c.randomvect(GRIDSIZE);  // random coordinate
        }
}

void throw_spheres(sphere *array, NUMLIST L_sph) {
        NUMLIST::iterator sph;
        for (sph=L_sph.begin();sph!=L_sph.end(); sph++) {
                array[*sph].c.randomvect(GRIDSIZE);  // random coordinate
        }
}

void set_dim(sphere *array, NUMBER first, NUMBER last, int setdim){
        for (NUMBER i=first;i<=last;i++) {
                array[i].c.set_dim(setdim);
        }
}

void set_clusternumber(sphere *array, NUMBER first, NUMBER last, NUMBER clno) {
        for (NUMBER i=first;i<=last;i++) {
                array[i].clno=clno;
        }
}
void set_radius(sphere *array, NUMBER first, NUMBER last, REAL radius ) {
        for (NUMBER i=first;i<=last;i++) {
                array[i].r=radius;
        }
}
void set_clustersize(sphere *array, NUMBER first, NUMBER last, NUMBER clsz) {
        for (NUMBER i=first;i<=last;i++) {
                array[i].clsz=clsz;
        }
}


bool same_array (sphere *array1, sphere *array2, NUMBER first, NUMBER last) {
        for (NUMBER i=first;i<=last;i++){
                if (array1[i]!=array2[i]) return 0;
        }
        return 1;
}


        
void set_clusternumber_l(sphere *array, NUMLIST &sphlist, NUMBER clno) {
        NUMLIST::iterator iter;
        for (iter =  sphlist.begin(); iter != sphlist.end(); ++iter){
                array[*iter].clno=clno;
        }
}



void increasing_integers (NUMLIST &sphlist, NUMBER N){
        for (NUMBER i=1;i<=N;i++){
                sphlist.insert(sphlist.end(), i);
        }
}

void increasing_integers (std::vector<NUMBER> &sphnumbers, NUMBER N){
        for (NUMBER i=0;i<=N;i++){
                sphnumbers[i]=i;
        }
}


REAL set_clustersize_to_each_sphere (NUMBER *tableofclusters, 
                                                                         sphere *spherearray, 
                                                                         NUMBER first, NUMBER last){
        NUMBER size;
        REAL sum=0;

        for (NUMBER i=first;i<=last;i++){
                size=tableofclusters[spherearray[i].clno];
                spherearray[i].clsz=size;
                sum+=size;
        }
        return sum/(last-first+1);    //returns the average clustersize
}


REAL set_clustersize_to_each_sphere_l (NUMBER *tableofclusters, 
                                                                           sphere *spherearray, 
                                                                           NUMLIST &sphlist){
        NUMBER size;
        REAL sum=0;

        NUMLIST::iterator k;
    for (k =  sphlist.begin(); k != sphlist.end(); k++){

                size=tableofclusters[spherearray[*k].clno];
                spherearray[*k].clsz=size;
                sum+=size;
        }
        return sum/(sphlist.size());    //returns the average clustersize
}

Diploma Thesis Sourcecode Documentation check out the text and the executable binaries

www.AndreasKrueger.de/thesis/code