void IntegrationTest::getIntegrationTest(const char* keyword){ if(stringlist_contains(keysShort,keyword) && stringlist_contains(keysLong, keyword)){ std::vector<double> timeVec1, timeVec2; setTimeVecs(timeVec1, timeVec2); // Sets the time vectors, they are equal for all keywords (WPOR:PROD01 etc) setDataSets(timeVec1, timeVec2); if(printSpecificKeyword){ printDataOfSpecificKeyword(timeVec1, timeVec2, keyword); } if(findVolumeError){ WellProductionVolume volume = getSpecificWellVolume(timeVec1, timeVec2, keyword); if(volume.error == 0){ std::cout << "For keyword " << keyword << " the total production volume is 0" << std::endl; } else{ std::cout << "For keyword " << keyword << " the total production volume is "<< volume.total; std::cout << ", the error volume is " << volume.error << " the error ratio is " << volume.error/volume.total << std::endl; } } checkForKeyword(timeVec1, timeVec2, keyword); return; } OPM_THROW(std::invalid_argument, "The keyword used is not common for the two files."); }
tokenInfo getNextToken(FILE *fp, buffer B) { // Read the input from the buffer. // Check if the buffer has enough space. Else change the buffer. if(B->fwdPointer >= BUFFERSIZE) { // Change buffers. getStream(fp, B->nextBuffer, BUFFERSIZE); // Set current buffer to next buffer if(B->nextBuffer == NULL) { return NULL; } B = B->nextBuffer; // Return next token from the next buffer. return getNextToken(fp, B); } char a = B->buff[B->fwdPointer]; // Check first for the one character tokens. if(a == '(') { tokenInfo token = makeSingleToken(B); token->token_name = OP; token->token_value = "("; return token; } else if(a == ')') { tokenInfo token = makeSingleToken(B); token->token_name = CL; token->token_value = ")"; return token; } else if(a == '[') { tokenInfo token = makeSingleToken(B); token->token_name = SQO; token->token_value = "["; return token; } else if(a == ']') { tokenInfo token = makeSingleToken(B); token->token_name = SQC; token->token_value = "]"; return token; } else if(a == ';') { tokenInfo token = makeSingleToken(B); token->token_name = SEMICOLON; token->token_value = ";"; return token; } else if(a == ',') { tokenInfo token = makeSingleToken(B); token->token_name = COMMA; token->token_value = ","; return token; } else if(a == '+') { tokenInfo token = makeSingleToken(B); token->token_name = PLUS; token->token_value = "+"; return token; } else if(a == '-') { tokenInfo token = makeSingleToken(B); token->token_name = MINUS; token->token_value = "-"; return token; } else if(a == '*') { tokenInfo token = makeSingleToken(B); token->token_name = MUL; token->token_value = "*"; return token; } else if(a == '/') { tokenInfo token = makeSingleToken(B); token->token_name = DIV; token->token_value = "/"; return token; } else if(a == '@') { tokenInfo token = makeSingleToken(B); token->token_name = SIZE; token->token_value = "@"; return token; } // Check for comments token and safely ignore else if(a == '#') { ++B->fwdPointer; while(B->fwdPointer < BUFFERSIZE && (B->buff[B->fwdPointer]!= '\n' && B->buff[B->fwdPointer]!= EOF)) { ++B->fwdPointer; } // Any of the above cases means we have reached the end of the current buffer. Check if exceeded buffer length if(B->buff[B->fwdPointer] == '\n' || B->buff[B->fwdPointer] == EOF) { // The comment has ended. Get the next token and return it. ++B->lineNumber; getStream(fp, B->nextBuffer, BUFFERSIZE); // Set current buffer to next buffer if(B->nextBuffer == NULL) { return NULL; } B = B->nextBuffer; // Keep checking for how long comments go and return next token. return getNextToken(fp, B); } if(B->fwdPointer >= BUFFERSIZE) { // The comment has overflowed to next buffer. Finish reading comment and return the next token. getStream(fp, B->nextBuffer, BUFFERSIZE); // Set current buffer to next buffer if(B->nextBuffer == NULL) { return NULL; } B = B->nextBuffer; // Keep checking for how long comments go and return next token. return getEndCommentAndNextToken(fp, B); } } else if(a == '>' || a == '<') { // Check next token. ++B->fwdPointer; tokenInfo token = malloc(sizeof(tokenStruct)); token->charNumber = B->charNumber; token->lineNumber = B->lineNumber; int curPointer = B->curPointer; // Store the current value temporarily. tokenInfo nextToken = getNextToken(fp, B); if(nextToken->token_name == ASSIGNOP) { // Assign the correct value to this token. if(a == '>') { token->token_name = GE; B->curPointer = ++B->fwdPointer; B->charNumber = B->fwdPointer; token->token_value = ">="; free(nextToken); return token; } else { token->token_name = LE; B->curPointer = ++B->fwdPointer; B->charNumber = B->fwdPointer; token->token_value = "<="; free(nextToken); return token; } } else { // Something else. Return LT or GT. // TODO: Is an error possible in this case? if(a == '>') { token->token_name = GT; // Lost the next token. Need to generate that one again. B->curPointer = curPointer + 1; B->fwdPointer = B->curPointer; B->charNumber = B->fwdPointer; token->token_value = ">"; free(nextToken); return token; } else if(a == '<') { token->token_name = LT; // Lost the next token. Need to generate that one again. B->curPointer = curPointer + 1; B->fwdPointer = B->curPointer; B->charNumber = B->fwdPointer; token->token_value = "<"; free(nextToken); return token; } } } else if(a == '=') { ++B->fwdPointer; tokenInfo token = malloc(sizeof(tokenStruct)); token->charNumber = B->charNumber; token->lineNumber = B->lineNumber; int curPointer = B->curPointer; // Temporary store. tokenInfo nextToken = getNextToken(fp, B); if(nextToken->token_name == ASSIGNOP) { // EQ token. token->token_name = EQ; token->token_value = "=="; B->charNumber = ++B->fwdPointer; free(nextToken); return token; } else if(nextToken->token_name == DIV) { // This should become a NE token if(B->buff[B->fwdPointer] == '=') { // It is the NE token. token->token_name = NE; token->token_value = "=/="; ++B->fwdPointer; ++B->curPointer; ++B->charNumber; free(nextToken); return token; } else { // Not NE token. An error // TODO: Decide error functions char *err = "Bad token. Possible Token: NE ."; showError(err, B->lineNumber); ++B->fwdPointer; ++B->curPointer; ++B->charNumber; free(nextToken); free(token); return NULL; } } else { // Something else. This is the ASSIGNOP token token->token_name = ASSIGNOP; // Lost the next token. Need to generate again. B->curPointer = ++curPointer; token->token_value = "="; B->fwdPointer = B->curPointer; B->charNumber = B->fwdPointer; free(nextToken); return token; } } else if(a == '.') { // One of the logical operators, possibly ++B->fwdPointer; tokenInfo token = malloc(sizeof(tokenStruct)); token->charNumber = B->charNumber; token->lineNumber = B->lineNumber; int curPointer = B->curPointer; tokenInfo nextToken = getNextToken(fp, B); if(nextToken->token_name == ID) { // Check which of the logical operators if(!strcmp(nextToken->token_value,"and")) { // Maybe the and operator. if(B->buff[B->fwdPointer] == '.') { // AND token. token->token_name = AND; token->token_value = ".and."; // Increment current and fwd pointer. ++B->fwdPointer; ++B->curPointer; ++B->charNumber; free(nextToken); return token; } else { // Something else. A Lexical error; char *err = "Lexical error. Possible Token: AND ."; showError(err, B->lineNumber); ++B->fwdPointer; ++B->curPointer; ++B->charNumber; free(nextToken); free(token); return NULL; } } else if(!strcmp(nextToken->token_value,"or")) { // Maybe the or operator if(B->buff[B->fwdPointer] == '.') { // OR token. token->token_name = OR; token->token_value = ".or."; ++B->fwdPointer; ++B->curPointer; ++B->charNumber; free(nextToken); return token; } else{ // Lexical error. char *err = "Lexical error. Possible token: OR ."; showError(err, B->lineNumber); ++B->fwdPointer; ++B->curPointer; ++B->charNumber; free(nextToken); free(token); return NULL; } } else if(!strcmp(nextToken->token_value,"not")) { // Maybe the not operator if(B->buff[B->fwdPointer] == '.') { // NOT token. token->token_name = NOT; token->token_value = ".not."; ++B->fwdPointer; ++B->curPointer; ++B->charNumber; free(nextToken); return token; } else{ // Lexical error. char *err = "Lexical error. Possible Token: NOT ."; showError(err, B->lineNumber); ++B->fwdPointer; ++B->curPointer; ++B->charNumber; free(nextToken); free(token); return NULL; } } else { // Some other identifier. A Lexical error; char *err = "Lexical error after ."; showError(err, B->lineNumber); B->curPointer = ++curPointer; B->fwdPointer = B->curPointer; B->charNumber = B->fwdPointer; free(nextToken); free(token); return NULL; } } else { // A Lexical error; char *err = "Lexical Error after ."; showError(err,B->lineNumber); B->curPointer = ++curPointer; B->fwdPointer = B->curPointer; B->charNumber = B->fwdPointer; free(nextToken); free(token); return NULL; } } else if(a == '_') { // A function identifier ++B->fwdPointer; tokenInfo token = malloc(sizeof(tokenStruct)); token->charNumber = B->charNumber; token->lineNumber = B->lineNumber; token->token_name = FUNID; char* funvalue = (char*)malloc((1+FUNSIZE)*sizeof(char)); funvalue[0] = '_'; if((B->buff[B->fwdPointer] >= 'a' && B->buff[B->fwdPointer] <= 'z') || (B->buff[B->fwdPointer] >= 'A' && B->buff[B->fwdPointer] <= 'Z')) { // Check for the function token. tokenInfo funToken = getFunctionToken(fp, B, FUNSIZE); strcpy(funvalue,funToken->token_value); // No need to store the underscore of the function name. tokenInfo keywordToken = checkForKeyword(funToken->token_value); if(keywordToken != NULL) { // It is a keyword token. Return as keyword. free(token); token = keywordToken; token->charNumber = B->charNumber; token->lineNumber = B->lineNumber; B->curPointer = B->fwdPointer; B->charNumber = B->fwdPointer; free(funvalue); //free(keywordToken); free(funToken); return token; } else { // It is an identifier. Return the identifier itself. token->token_value = funvalue; B->curPointer = B->fwdPointer; B->charNumber = B->fwdPointer; free(funToken); return token; } } else { // Incorrect. Show error. char *err = "Lexical Error. Function names may start only with alphabets."; showError(err, B->lineNumber); B->curPointer = B->fwdPointer; B->charNumber = B->fwdPointer; free(funvalue); free(token); return NULL; } } else if((a >= 'a' && a<= 'z') || (a >= 'A' && a<= 'Z')) { // An alphabet identifier ++B->fwdPointer; tokenInfo token = malloc(sizeof(tokenStruct)); token->charNumber = B->charNumber; token->lineNumber = B->lineNumber; token->token_name = ID; char* idvalue = (char*)malloc((1+IDSIZE)*sizeof(char)); tokenInfo idToken = getIDToken(fp, B, IDSIZE); // Check if it is a token idvalue[0] = a; if(idToken == NULL) { // Check for one alphabet identifier only. token->token_value = idvalue; B->curPointer = B->fwdPointer; B->charNumber = B->fwdPointer; free(idToken); return token; } idvalue = joinStrings(idvalue,idToken->token_value); idToken->token_value = idvalue; tokenInfo keywordToken = checkForKeyword(idToken->token_value); if(keywordToken != NULL) { // It is a keyword token. Return as keyword. free(token); token = keywordToken; token->charNumber = B->charNumber; token->lineNumber = B->lineNumber; B->curPointer = B->fwdPointer; B->charNumber = B->fwdPointer; //free(keywordToken); free(idToken); return token; } else { // It is an identifier. Return the identifier itself. token->token_value = idvalue; //printf("%s",token->token_value); B->curPointer = B->fwdPointer; B->charNumber = B->fwdPointer; free(keywordToken); free(idToken); return token; } } else if(a >= '0' && a<= '9') { // A number identifier ++B->fwdPointer; tokenInfo token = malloc(sizeof(tokenStruct)); token->charNumber = B->charNumber; token->lineNumber = B->lineNumber; char* numvalue = (char*)malloc((1+NUMSIZE)*sizeof(char)); tokenInfo numToken = getNumberToken(fp, B); token->token_name = numToken->token_name; //whether RealNum or IntNum. numvalue[0] = a; token->token_value = joinStrings(numvalue,numToken->token_value); B->curPointer = B->fwdPointer; B->charNumber = B->fwdPointer; free(numToken); return token; } else if(a == '\"') { // String type. ++B->fwdPointer; tokenInfo token = malloc(sizeof(tokenStruct)); token->charNumber = B->charNumber; token->lineNumber = B->lineNumber; token->token_name = STR; char* stringValue = (char*)malloc((IDSIZE)*sizeof(char)); tokenInfo stringToken = getStringToken(fp, B, IDSIZE); // CONSIDER: check if end of string has a '"' if(B->buff[B->fwdPointer] == '"') { // It is a string ending with the '"' strcpy(stringValue,stringToken->token_value); token->token_value = stringValue; ++B->fwdPointer; //printf("%s +++ %s",token->token_value,stringToken->token_value); B->curPointer = B->fwdPointer; B->charNumber = B->fwdPointer; free(stringToken); return token; } else { // It is not a token. Lexical error char *err = "Lexical error after \\"; showError(err,B->lineNumber); ++B->fwdPointer; B->curPointer = B->fwdPointer; B->charNumber = B->fwdPointer; free(stringToken); free(token); free(stringValue); return NULL; } } else { // All other cases. if(a == '\n') { // New line. Change values of line number and char number ++B->lineNumber; B->charNumber = 0; // Change the buffer. FILE* check = getStream(fp, B->nextBuffer, BUFFERSIZE); // Set current buffer to next buffer if(check == NULL) { return NULL; } B = B->nextBuffer; return getNextToken(fp, B); } else if(a == ' ') { ++B->fwdPointer; B->curPointer = B->fwdPointer; ++B->charNumber; return getNextToken(fp, B); } else if(a == EOF) { // End of the input file. Stop here. return NULL; } else if(a == '\t') { ++B->fwdPointer; B->curPointer = B->fwdPointer; ++B->charNumber; return getNextToken(fp, B); } else { // Don't know what type of cases come here. CONSIDER return NULL; } } return NULL; }
void IntegrationTest::getIntegrationTest(){ std::vector<double> timeVec1, timeVec2; setTimeVecs(timeVec1, timeVec2); // Sets the time vectors, they are equal for all keywords (WPOR:PROD01 etc) setDataSets(timeVec1, timeVec2); int ivar = 0; if(!allowDifferentAmountOfKeywords){ if(stringlist_get_size(keysShort) != stringlist_get_size(keysLong)){ OPM_THROW(std::invalid_argument, "Different ammont of keywords in the two summary files."); } } if(printKeyword){ printKeywords(); return; } std::string keywordWithGreatestErrorRatio; double greatestRatio = 0; //Iterates over all keywords from the restricted file, use iterator "ivar". Searches for a match in the file with more keywords, use the itarator "jvar". while(ivar < stringlist_get_size(keysShort)){ const char* keyword = stringlist_iget(keysShort, ivar); if(oneOfTheMainVariables){ std::string keywordString(keyword); std::string substr = keywordString.substr(0,4); if(substr!= mainVariable){ ivar++; continue; } } for (int jvar = 0; jvar < stringlist_get_size(keysLong); jvar++){ if (strcmp(keyword, stringlist_iget(keysLong, jvar)) == 0){ //When the keywords are equal, proceed in comparing summary files. /* if(!checkUnits(keyword)){ OPM_THROW(std::runtime_error, "For keyword " << keyword << " the unit of the two files is not equal. Not possible to compare."); } //Comparing the unit of the two vectors.*/ checkForKeyword(timeVec1, timeVec2, keyword); if(findVectorWithGreatestErrorRatio){ WellProductionVolume volume = getSpecificWellVolume(timeVec1,timeVec2, keyword); findGreatestErrorRatio(volume,greatestRatio, keyword, keywordWithGreatestErrorRatio); } break; } //will only enter here if no keyword match if(jvar == stringlist_get_size(keysLong)-1){ if(!allowDifferentAmountOfKeywords){ OPM_THROW(std::invalid_argument, "No match on keyword"); } } } ivar++; } if(findVectorWithGreatestErrorRatio){ std::cout << "The keyword " << keywordWithGreatestErrorRatio << " had the greatest error ratio, which was " << greatestRatio << std::endl; } if((findVolumeError || oneOfTheMainVariables) && !findVectorWithGreatestErrorRatio){ evaluateWellProductionVolume(); } if(allowSpikes){ std::cout << "checkWithSpikes succeeded." << std::endl; } }