main.h

Go to the documentation of this file.

#ifndef _MAIN_H_
#define _MAIN_H_

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <ostream>
#include <fstream>
#include <string>
#include <time.h>
#include <getopt.h>
#include <vector>
#include <limits>

#include "file.h"
#include "fileselect.h"
#include "metric.h"
#include "interpolation.h"
#include "datatypedef.h"
#include "util.h"

#include "BoundingBox.hpp"

using std::string;
using std::ofstream;
using std::ifstream;

using namespace std;



class ComSwitch {

    public:

        ComSwitch();

        ComSwitch(int rArgc, char *rpArgv[]);

        ~ComSwitch();

        bool parseOptions();

        void setArguments(int rArgc, char *rpArgv[]);

        bool requiredArgsSet();

        int getFileDimensions(int rFile);

        std::vector<adj_map> getConvFactor(int rFile);

        std::vector<adj_map> getNormVal(int rFile);

        bool getVerbosity();

        ifstream & getInputFile(int rFile);

        string getFileName(int rFile);

        ofstream & getLogFile();

        string getOutPrefix();

        inline bool isRangeSpecified( )
        {
                return this ->restrictToRange;
        };

        inline BoundingBox getRange( )
        {
                return this ->mRange;
        }
        std::vector<cmp_map> getComparisonList();

        std::vector< std::vector<int> > getFieldMappings(int rFile);

        std::vector<index_order> getIndexOrder(int rFile);

    private:

        void setDefaultVars();

        bool readOptions();

        bool parseValuesFromArguments(string rOptString,
                                      const struct option *rLongOpts);

        bool initializeFileStreams();

        bool writeLogHeader();

        bool mHelp;

        int mArgc;                                       
        char **mpArgv;                                   
        bool mBadSwitch;                         
        int mInfile1Dimensions;  
        int mInfile2Dimensions;  
        bool restrictToRange;            
        BoundingBox mRange;              
        std::vector<adj_map> mFile1ConversionFactor;
        std::vector<adj_map> mFile2ConversionFactor;

        std::vector<adj_map> mFile1Norm;
        std::vector<adj_map> mFile2Norm;

        ofstream mLog;
        string mOutPrefix;

        string mInfileName1;
        string mInfileName2;

        ifstream mInfile1;
        ifstream mInfile2;

        std::vector<cmp_map> mComparisonList;

        std::vector< std::vector<int> > mFieldMappingsFile1;
        std::vector< std::vector<int> > mFieldMappingsFile2;

        std::vector<index_order> mIndexOrderFile1;
        std::vector<index_order> mIndexOrderFile2;

        bool mLoud;

};


string gUsage("Usage:  [--outfile | -o]      <output file prefix>\n\t"
                      "[--infile1 | -1]      <intput file 1 name>:<dimensions>\n\t"
                      "[--infile2 | -2]      <intput file 2 name>:<dimensions>\n\t"
                      "[--fieldmap | -f]     <File (1,2)>:<File Dimension>/<Mapped Dimension or \"null\">\n\t"
                      "[--index-order | -i]  <File (1,2)>:<Partition>:<Dimension 1>,<Dimension 2>,...\n\t"
                      "[--conv | -c]         <File (1,2)>:<Variable>:<Conversion Factor> \n\t"
                      "[--norm | -n]         <File (1,2)>:<Variable>:<Normalization Factor> \n\t"
                      "[--range | -r]        <xmin>,<ymin>,<zmin>,<xmax>,<ymax>,<zmax> \n\t"
                      "[--metric | -m]       <metric number>=<file 1 partition 1>,<file 1 partition 2>,...:<file 1 variable>/\n\t"
                      "                                      <file 2 partition>:<file 2 variable>\n\t"
                      "[--verbose | -v]\n" );

void printUsage(string rErrorMessage);

vector<datafile*> openAndParseFiles();

void compareFiles(vector<datafile*> pFiles);

std::vector<points*> retrievePoints(datafile* pFile, vector<int> rPartitions);

void printPointValues(points* pPoints);

long double calcAverageValue(points *pPoints, int rVar);


long double minPoint(points *pPoints, int rVar);


long double maxPoint(points *pPoints, int rVar);


#endif