statsanalyzer.cpp

用data miming技术进行false prediction

#include "StatsAnalyzer.h"


bool statsLesser(Stats* s1, Stats* s2) {
    return *s1 < *s2;
}

void StatsAnalyzer::initializeStatsList(const char* fileName) throw (AppException) {
    int mTBF;
    float mProbability;
    int count = 0;

    try {
        ifstream inFile(fileName, ios::in);

        if (inFile.is_open()) {
            //cout << "opened file" << endl;

            while (!inFile.eof()) {
                if (inFile >> mTBF) {
                    inFile >> mProbability;

                    Stats* stats = new Stats(mTBF, mProbability);
                    statsList->push_back(stats);
                    ++count;
                }
            }

            inFile.close();

        } else {
            throw AppException(9, "unable to open Input file", __FILE__, __LINE__);
        }

        sort(statsList->begin(), statsList->end(), statsLesser);
        //cout << "Total Stats Records: " << count << endl;

    } catch (exception &e) {
        throw AppException(9, string("abnormal error in processing Input file - ") + string(e.what()), __FILE__, __LINE__);
    }
};

StatsAnalyzer::StatsAnalyzer() {
    //const char* dataFileName = "..\\logs\\anl_compress5\\timeSeries.dat";
    const char* dataFileName = "..\\logs\\anl_compress5\\timeSeries.dat";
    this->statsList = new vector<Stats*>;
    this->initializeStatsList(dataFileName);
    //this->printStatsList();
    //float prob = this->getProbabilityForTBF(2500000);
    //cout << prob << endl;
};

StatsAnalyzer::~StatsAnalyzer() {
    if (statsList != 0) {
        vector<Stats*>::iterator itr;
        for (itr = statsList->begin(); itr != statsList->end(); itr++) {
            delete *itr;
        }
        delete statsList;
    }
};

vector<Stats*>* StatsAnalyzer::getStatsList() const {
    return statsList;
};

float StatsAnalyzer::getProbabilityForTBF(int mTBF) const {
    if (statsList != 0) {
        vector<Stats*>::iterator itr;
        int lowerTBF, higherTBF;
        float lowerProb, higherProb;

        for (itr = statsList->begin(); itr != statsList->end(); itr++) {
            Stats* stats = *itr;
            if (stats->getTBF() == mTBF) {
                return stats->getProbability();
            } else if (stats->getTBF() < mTBF) {
                lowerTBF = stats->getTBF();
                lowerProb = stats->getProbability();
            } else {
                higherTBF = stats->getTBF();
                higherProb = stats->getProbability();
                float prob = lowerProb + (((higherProb - lowerProb)/(higherTBF - lowerTBF)) * (mTBF - lowerTBF));
                return prob;
            }
        }
        return 0.0;
    } else {
        return 0.0;
    }
};

void StatsAnalyzer::printStatsList() {
    if (statsList != 0) {
        vector<Stats*>::iterator itr;
        for (itr = statsList->begin(); itr != statsList->end(); itr++) {
            cout << *(*itr) << endl;
        }
    }
}

bool StatsAnalyzer::predictFailure(int lastFailTime, int secondLastFailTime, int maxPredictTime) const {
    if ( (secondLastFailTime > 0) && ((maxPredictTime - secondLastFailTime) <= 310) ) {
        //cout << "predicted from rule 1" << endl;
        //char ch; cin.get(ch);
        return true;
    } else {
        int tslf = maxPredictTime - lastFailTime;
        float prob = getProbabilityForTBF(tslf);
        float thresholdProb = Config::getInstance()->getProbability();
        if (prob >= thresholdProb) {
            //cout << "tslf: " << tslf << "  maxPredictTime: " << maxPredictTime << "  lastFailTime: " << lastFailTime << endl;
            //char ch; cin.get(ch);
            return true;
        }

        return false;
    }
}