clusterGroups.cpp

Go to the documentation of this file.

#include <vector>
#include <iostream>
#include "clusterGroups.h"
#include "structures.h"
#include "input.h"
#include "mathFunctions.h"

/*  This code goes through all the polygons accepted into the domain and returns the indexes to those polygons
    which match the users boundary faces option. 
    Isoloated fractures and Polygons with no intersections are removed

groupData structure:
***********************
    groupData keeps information as to how many polygons are in the group or cluster. It also keeps
    track of the boundary faces which the cluster is in contact with. There is also a valid variable (0 or 1).
    If a polygon connects two different groups, one of the groups is merged together with the other. The one which
    nolonger exists has it's valid variable set to 0. 

    The groupData structure array, or vector, is aligned with the group numbers. If you want to know about group 3 for
    example, you will look at groupData[ (3-1) ], minus 1 because the array starts at 0 while groups start at 1. 
    If valid = 1 in the structure, that group still exists and has not been merged

fractGroups structure:
*************************
    fractGroups[] holds the actual pointers/index numbers to the polygon array along with the group number. Unlike
    groupData[] described above, fractGroups does not stay aligned to group numbers. To keep from copying, deleteing, and 
    re-allocating memory when groups merge together, we simply change the variable groupNum to the new group number. 

    Because of this, there will be multiples of the same group numbers, but with differnt polygons listed. To get all the 
    polygons from a group we must search the fractGroups array for all matching groups
*/

/***********************************************************************************/
/*********************  Get Matching Fracture Clusters  ****************************/
std::vector<unsigned int> getCluster(Stats &pstats){
    // The max number of groups is pstats.nextGroupNum - 1
    std::vector<unsigned int> matchingGroups;
    std::vector<unsigned int> finalPolyList;
    
    
// NOTE: (groupNumber-1) = corresponding groupData structures' index of the arary
//       similarly, the index of groupData + 1 = groupNumber (due to groupNumber starting at 1, array starting at 0)
    
        // Find all matching groups:
        // Get matching groups from pstats.groupData[]
        for (unsigned int i = 0; i < pstats.groupData.size(); i++) {
            // If the data is valid, meaning that group still exists (hasn't been merged to a new group) and
            // if the group has more than 1 fracture meaning there are intersections and
            // the cluster matches the reqirements of the user's boundaryFaces option
            if (ignoreBoundaryFaces == 0) {
                if (pstats.groupData[i].valid == 1 && pstats.groupData[i].size > 1  && facesMatch(boundaryFaces, pstats.groupData[i].faces)) {
                    matchingGroups.push_back(i+1);//save matching group number
                }
            }
            else { // Get all cluster groups
                if (pstats.groupData[i].valid == 1 && pstats.groupData[i].size > 1) {
                    matchingGroups.push_back(i+1); // Save matching group number
                }
            }
        }

        if (keepOnlyLargestCluster == 1 && matchingGroups.size() > 1) { 
            // If only keeping the largest cluster, find group with largest size
            
            // Initialize largestGroup
            unsigned int largestGroup = matchingGroups[0];
            for (unsigned int i = 0; i < matchingGroups.size(); i++) {
                // If largest group < current group, the current group is the new largest group 
                if (largestGroup < pstats.groupData[matchingGroups[i]-1].size){
                    largestGroup = matchingGroups[i];
                }
            }

            matchingGroups.clear(); // Clear group numbers
            matchingGroups.push_back(largestGroup); // Save only the largest group 
        }

        // Gather the final polygon numbers/indecies.
        for (unsigned int i = 0; i < matchingGroups.size(); i++){
            for (unsigned int k = 0; k < pstats.fractGroup.size(); k++){
                if (matchingGroups[i] == pstats.fractGroup[k].groupNum) { 
                    // If the groupNumbers match
                    // copy all poly indecies of matching group
                    for (unsigned int j = 0; j < pstats.fractGroup[k].polyList.size(); j++){
                        finalPolyList.push_back(pstats.fractGroup[k].polyList[j]);
                    }
                }
            }
        }
    return finalPolyList;
}


/***********************************************************************************/
/*******  Test if Boundary Faces Option Match User's Desired Boundary Faces ********/
bool facesMatch(bool *facesOption, bool *faces){
    for (int i = 0; i < 6; i++) {
        // If the user specified the face, check if faces match
        if (facesOption[i] == 1){
            if ((facesOption[i] & faces[i]) == 0) {
                return 0;
            }
        }
    }
    return 1;
}


/********************  Assign New Polygon to a Cluster  ****************************/
/***********************************************************************************/
void assignGroup(Poly &newPoly, Stats &pstats, int newPolyIndex) {  

    newPoly.groupNum = pstats.nextGroupNum;
    GroupData newGroupData; // Keeps fracture cluster data
    // Copy newPoly faces info to groupData
    OR(newGroupData.faces, newPoly.faces);
    // Incriment groupData's poly count
    newGroupData.size++;
    pstats.groupData.push_back(newGroupData); // Save boundary face information to permanent location
    FractureGroups newGroup; // 'newPoly' had no intersections, put it in a new group
    newGroup.groupNum = pstats.nextGroupNum; // Assign new group # to newGroup
    pstats.nextGroupNum++;
    newGroup.polyList.push_back(newPolyIndex); // Save index (number) of newPoly
    pstats.fractGroup.push_back(newGroup);


}




/**************************  Update Cluster Groups  ********************************/
/***********************************************************************************/
void updateGroups(Poly &newPoly, std::vector<Poly> &acceptedPoly, std::vector<unsigned int> &encounteredGroups, Stats &pstats, int newPolyIndex) { 

    if (encounteredGroups.size() == 0) {
        // 'newPoly' didn't encounter more than 1 other group of fractures 
        // Save newPoly to the group structure

        unsigned int i = 0;
        // Update boundary face info

        OR(pstats.groupData[newPoly.groupNum-1].faces, newPoly.faces);
        // NOTE: Groups start at 1, but array starts at zero hence the groupNum-1 for index

        // Incriment the groups size for the new polygon
        pstats.groupData[newPoly.groupNum-1].size++;

        // Search for group newPoly belongs to and add newPoly to it's list, add to first matching group found
        while (pstats.fractGroup[i].groupNum != newPoly.groupNum && i != pstats.fractGroup.size()) {
        i++;
        }
        // Error check
        if (i == pstats.fractGroup.size() && pstats.fractGroup[i].groupNum != newPoly.groupNum ) {
            std::cout<<"ERROR: Group not found (computationalGeometry.cpp)\n";
        }

        // Add newPoly to fracture/cluster group
        pstats.fractGroup[i].polyList.push_back(newPolyIndex);
    }
    else{
        // Multiple cluter groups were encountered. 
        // Merge the groups (change/update the group numbers)
        // Search for encountered groups and make them all have the same group numbers
        // First, add newpoly to correct group

        int k = 0;
        while (newPoly.groupNum != pstats.fractGroup[k].groupNum) {
            k++;
        }

        // Add new poly to the group
        pstats.fractGroup[k].polyList.push_back(newPolyIndex);
        // Incriment size of group by one for newPoly
        pstats.groupData[newPoly.groupNum-1].size++;
        // Add any boundary face data to group fro newPoly
        OR(pstats.groupData[newPoly.groupNum-1].faces, newPoly.faces);

        // Need merge groups in encounteredGroups list to newPoly.groupNum
        for (unsigned int i = 0; i < encounteredGroups.size(); i++) {
            // Add merging groups size to new group's size
            if (pstats.groupData[encounteredGroups[i]-1].valid == 1) {
                pstats.groupData[newPoly.groupNum-1].size += pstats.groupData[encounteredGroups[i]-1].size;
                // Merge any boundary faces data
                OR(pstats.groupData[newPoly.groupNum-1].faces, pstats.groupData[encounteredGroups[i]-1].faces);
                // Mark merged groups group data as invalid
                pstats.groupData[encounteredGroups[i]-1].valid = 0;
            }

            for (unsigned int jj = 0; jj < pstats.fractGroup.size(); jj++) {
                if (pstats.fractGroup[jj].groupNum == encounteredGroups[i]) {
                    // Change group number to the new group number
                    pstats.fractGroup[jj].groupNum = newPoly.groupNum;
                    // Change polys group number inside the group to the new group num
                    for (unsigned int z = 0; z < pstats.fractGroup[jj].polyList.size(); z++) {
                        acceptedPoly[pstats.fractGroup[jj].polyList[z]].groupNum = newPoly.groupNum;
                    }
                }
            }
        }
    }
}