EclRegressionTest.hpp

Go to the documentation of this file.

/*
   Copyright 2019 Equinor ASA.
 
   This file is part of the Open Porous Media project (OPM).
 
   OPM 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 3 of the License, or
   (at your option) any later version.
 
   OPM 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.
 
   You should have received a copy of the GNU General Public License
   along with OPM.  If not, see <http://www.gnu.org/licenses/>.
   */
 
#ifndef ECLREGRESSIONTEST_HPP
#define ECLREGRESSIONTEST_HPP
 
#include "EclFilesComparator.hpp"
 
#include <opm/io/eclipse/EclIOdata.hpp>
 
namespace Opm { namespace EclIO {
    class EGrid;
}}
 
namespace EIOD = Opm::EclIO;
 
 
class ECLRegressionTest: public ECLFilesComparator {
public:
    ECLRegressionTest(const std::string& basename1, const std::string& basename2,
                      double absToleranceArg, double relToleranceArg):
        ECLFilesComparator(basename1, basename2, absToleranceArg, relToleranceArg) {}
 
    ~ECLRegressionTest();
 
    void setOnlyLastReportNumber(bool onlyLastSequenceArg) {
        this->onlyLastSequence = onlyLastSequenceArg;
    }
 
    int countDev() { return  deviations.size(); }
 
    // Accept extra keywords: If this switch is set to true the comparison
    // will ignore extra keywords which are only present
    // in the new simulation.
 
    void setReportStepOnly(bool reportStepOnlyArg) {
        this->reportStepOnly = reportStepOnlyArg;
    }
 
    void setAcceptExtraKeywords(bool acceptExtraKeywordsArg) {
        this->acceptExtraKeywords = acceptExtraKeywordsArg;
    }
 
    void setIntegrationTest(bool inregrationTestArg) {
        this->integrationTest = inregrationTestArg;
    }
 
    void setPrintKeywordOnly(bool printArg) {
        this->printKeywordOnly = printArg;
    }
 
    void compareSpesificKeyword(std::string keyword) {
        this->spesificKeyword = std::move(keyword);
    }
    void compareSpesificRstReportStepNumber(int seqn) {
        this->spesificSequence = seqn;
    }
 
    void setLoadBaseRunData(bool loadArg) {
        this->loadBaseRunData = loadArg;
    }
 
    void loadGrids();
    void printDeviationReport();
 
    void gridCompare();
 
    void results_rst();
    void results_init();
    void results_smry();
    void results_rft();
 
private:
    bool checkFileName(const std::string& rootName, const std::string& extension, std::string& filename);
 
    // Prints results stored in absDeviation and relDeviation.
    void printResultsForKeyword(const std::string& keyword) const;
    void printComparisonForKeywordLists(const std::vector<std::string>& arrayList1,
                                        const std::vector<std::string>& arrayList2) const;
 
    void printComparisonForKeywordLists(const std::vector<std::string>& arrayList1,
                                        const std::vector<std::string>& arrayList2,
                                        const std::vector<EIOD::eclArrType>& arrayType1,
                                        const std::vector<EIOD::eclArrType>& arrayType2) const;
 
    void printMissingKeywords(const std::vector<std::string>& arrayList1,
                              const std::vector<std::string>& arrayList2) const;
 
    void compareKeywords(const std::vector<std::string>& keywords1,
                         const std::vector<std::string>& keywords2,
                         const std::string& reference);
 
    void checkSpesificKeyword(std::vector<std::string>& keywords1,
                              std::vector<std::string>& keywords2,
                              std::vector<EIOD::eclArrType>& arrayType1,
                              std::vector<EIOD::eclArrType>& arrayType2,
                              const std::string& reference);
 
    template <typename T>
    void compareVectors(const std::vector<T>& t1, const std::vector<T>& t2,
                        const std::string& keyword, const std::string& reference);
 
    template <typename T>
    void compareFloatingPointVectors(const std::vector<T>& t1, const std::vector<T> &t2,
                                     const std::string& keyword, const std::string& reference);
 
    // deviationsForCell throws an exception if both the absolute deviation AND the relative deviation
    // are larger than absTolerance and relTolerance, respectively. In addition,
    // if allowNegativeValues is passed as false, an exception will be thrown when the absolute value
    // of a negative value exceeds absTolerance. If no exceptions are thrown, the absolute and relative deviations are added to absDeviation and relDeviation.
    // void deviationsForCell(double val1, double val2, const std::string& keyword, const std::string reference, size_t kw_size, size_t cell, bool allowNegativeValues = true);
 
    void deviationsForCell(double val1, double val2, const std::string& keyword,
                           const std::string& reference, size_t kw_size, size_t cell,
                           bool allowNegativeValues, bool useStrictTol);
 
    template <typename T>
    void deviationsForNonFloatingPoints(T val1, T val2, const std::string& keyword,
                                        const std::string& reference,
                                        size_t kw_size, size_t cell);
 
    // These vectors store absolute and relative deviations, respecively. Note that they are whiped clean for every new keyword comparison.
    std::vector<double> absDeviation, relDeviation;
 
    // Keywords which should not contain negative values, i.e. uses allowNegativeValues = false in deviationsForCell():
    const std::vector<std::string> keywordDisallowNegatives = {"SGAS", "SWAT", "PRESSURE"};
 
    double strictAbsTol = 1e-6;
    double strictRelTol = 1e-6;
 
    // keywords that triggers strict tolerances
    const std::vector<std::string> keywordsStrictTol = {"COORD", "ZCORN", "PORV", "DEPTH", "DX", "DY", "DZ", "PERMX", "PERMY", "PERMZ", "NTG",
                                                        "TRANX", "TRANY", "TRANZ", "TRANNNC", "SGRP", "SCON", "DOUBHEAD"
                                                       };
    // keywords that should not be compared
    const std::vector<std::string> keywordsBlackList = {"TCPU"};
 
    bool reportStepOnly = false;
 
    // Only compare last occurrence
    bool onlyLastSequence = false;
 
    bool integrationTest = false;
 
    bool printKeywordOnly = false;
 
    bool loadBaseRunData = false;
 
    // spesific keyword to be compared
    std::string spesificKeyword;
 
    // spesific restart sequence to be compared
    int spesificSequence = -1;
 
    // Accept extra keywords in the restart file of the 'new' simulation.
    bool acceptExtraKeywords = false;
 
    Opm::EclIO::EGrid* grid1 = nullptr;
    Opm::EclIO::EGrid* grid2 = nullptr;
};
 
#endif