diff --git a/opm/parser/eclipse/CMakeLists.txt b/opm/parser/eclipse/CMakeLists.txt
index 8222e2270..2e4e4cb8a 100644
--- a/opm/parser/eclipse/CMakeLists.txt
+++ b/opm/parser/eclipse/CMakeLists.txt
@@ -8,11 +8,11 @@ set( rawdeck_source
 RawDeck/RawDeck.cpp 
 RawDeck/RawKeyword.cpp 
 RawDeck/RawRecord.cpp 
-RawDeck/RawParserKWs.cpp )
+RawDeck/RawParserKeywords.cpp )
 
 set( deck_source
 Deck/Deck.cpp
-Deck/DeckKW.cpp
+Deck/DeckKeyword.cpp
 Deck/DeckRecord.cpp
 Deck/DeckItem.cpp
 Deck/DeckIntItem.cpp
@@ -23,7 +23,7 @@ Deck/KeywordContainer.cpp
 
 set( parser_source 
 Parser/ParserRecordSize.cpp 
-Parser/ParserKW.cpp 
+Parser/ParserKeyword.cpp 
 Parser/Parser.cpp 
 Parser/ParserRecord.cpp
 Parser/ParserItem.cpp
diff --git a/opm/parser/eclipse/Deck/Deck.cpp b/opm/parser/eclipse/Deck/Deck.cpp
index 964701fe8..985c758cd 100644
--- a/opm/parser/eclipse/Deck/Deck.cpp
+++ b/opm/parser/eclipse/Deck/Deck.cpp
@@ -29,11 +29,11 @@ namespace Opm {
         return m_keywords->hasKeyword(keyword);
     }
     
-    void Deck::addKeyword( DeckKWConstPtr keyword) {
+    void Deck::addKeyword( DeckKeywordConstPtr keyword) {
         m_keywords->addKeyword(keyword);
     }
     
-    DeckKWConstPtr Deck::getKeyword(const std::string& keyword) const {
+    DeckKeywordConstPtr Deck::getKeyword(const std::string& keyword) const {
         return m_keywords->getKeyword(keyword);
     }
 
diff --git a/opm/parser/eclipse/Deck/Deck.hpp b/opm/parser/eclipse/Deck/Deck.hpp
index ccee1e529..bdd78c4d2 100644
--- a/opm/parser/eclipse/Deck/Deck.hpp
+++ b/opm/parser/eclipse/Deck/Deck.hpp
@@ -29,8 +29,8 @@ namespace Opm {
     public:
         Deck();
         bool hasKeyword( const std::string& keyword ) const;
-        void addKeyword( DeckKWConstPtr keyword);
-        DeckKWConstPtr getKeyword(const std::string& keyword) const;
+        void addKeyword( DeckKeywordConstPtr keyword);
+        DeckKeywordConstPtr getKeyword(const std::string& keyword) const;
 
     private:
         KeywordContainerPtr m_keywords;
diff --git a/opm/parser/eclipse/Deck/DeckKW.cpp b/opm/parser/eclipse/Deck/DeckKeyword.cpp
similarity index 76%
rename from opm/parser/eclipse/Deck/DeckKW.cpp
rename to opm/parser/eclipse/Deck/DeckKeyword.cpp
index bc6ccd807..77e55cc2c 100644
--- a/opm/parser/eclipse/Deck/DeckKW.cpp
+++ b/opm/parser/eclipse/Deck/DeckKeyword.cpp
@@ -17,31 +17,30 @@
   along with OPM.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "DeckKW.hpp"
+#include "DeckKeyword.hpp"
 
 namespace Opm {
 
-    DeckKW::DeckKW(const std::string& keywordName) {
+    DeckKeyword::DeckKeyword(const std::string& keywordName) {
         m_keywordName = keywordName;
     }
 
-    std::string DeckKW::name() const {
+    std::string DeckKeyword::name() const {
         return m_keywordName;
     }
 
-    size_t DeckKW::size() const {
+    size_t DeckKeyword::size() const {
         return m_recordList.size();
     }
 
-    void DeckKW::addRecord(DeckRecordConstPtr record) {
+    void DeckKeyword::addRecord(DeckRecordConstPtr record) {
         m_recordList.push_back(record);
     }
-    
-    DeckRecordConstPtr DeckKW::getRecord(size_t index) const {
+
+    DeckRecordConstPtr DeckKeyword::getRecord(size_t index) const {
         if (index < m_recordList.size()) {
             return m_recordList[index];
-        }
-        else
+        } else
             throw std::range_error("Index out of range");
     }
 
diff --git a/opm/parser/eclipse/Deck/DeckKW.hpp b/opm/parser/eclipse/Deck/DeckKeyword.hpp
similarity index 62%
rename from opm/parser/eclipse/Deck/DeckKW.hpp
rename to opm/parser/eclipse/Deck/DeckKeyword.hpp
index d0fa3cbe3..0b932fa20 100644
--- a/opm/parser/eclipse/Deck/DeckKW.hpp
+++ b/opm/parser/eclipse/Deck/DeckKeyword.hpp
@@ -1,12 +1,12 @@
 /* 
- * File:   DeckKW.hpp
+ * File:   DeckKeyword.hpp
  * Author: kflik
  *
  * Created on June 3, 2013, 12:55 PM
  */
 
-#ifndef DECKKW_HPP
-#define	DECKKW_HPP
+#ifndef DECKKEYWORD_HPP
+#define	DECKKEYWORD_HPP
 
 #include <string>
 #include <vector>
@@ -16,9 +16,9 @@
 
 namespace Opm {
 
-    class DeckKW {
+    class DeckKeyword {
     public:
-        DeckKW(const std::string& keywordName);
+        DeckKeyword(const std::string& keywordName);
         std::string name() const;
         size_t size() const;
         void addRecord(DeckRecordConstPtr record);
@@ -29,9 +29,9 @@ namespace Opm {
         std::vector<DeckRecordConstPtr> m_recordList;
 
     };
-    typedef boost::shared_ptr<DeckKW> DeckKWPtr;
-    typedef boost::shared_ptr<const DeckKW> DeckKWConstPtr;
+    typedef boost::shared_ptr<DeckKeyword> DeckKeywordPtr;
+    typedef boost::shared_ptr<const DeckKeyword> DeckKeywordConstPtr;
 }
 
-#endif	/* DECKKW_HPP */
+#endif	/* DECKKEYWORD_HPP */
 
diff --git a/opm/parser/eclipse/Deck/KeywordContainer.cpp b/opm/parser/eclipse/Deck/KeywordContainer.cpp
index 062d49e15..e08f6dbbb 100644
--- a/opm/parser/eclipse/Deck/KeywordContainer.cpp
+++ b/opm/parser/eclipse/Deck/KeywordContainer.cpp
@@ -19,7 +19,7 @@
 
 #include <map>
 #include <opm/parser/eclipse/Deck/KeywordContainer.hpp>
-#include <opm/parser/eclipse/Deck/DeckKW.hpp>
+#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
 
 namespace Opm {
 
@@ -34,22 +34,22 @@ namespace Opm {
         return m_keywordList.size();
     }
     
-    void KeywordContainer::addKeyword(DeckKWConstPtr keyword) {
+    void KeywordContainer::addKeyword(DeckKeywordConstPtr keyword) {
         m_keywordList.push_back(keyword);
         
         if (!hasKeyword(keyword->name())) {
-            m_keywordMap[keyword->name()] = std::vector<DeckKWConstPtr>();
+            m_keywordMap[keyword->name()] = std::vector<DeckKeywordConstPtr>();
         }
         
         {
-            std::vector<DeckKWConstPtr>& keywordList = m_keywordMap[keyword->name()];
+            std::vector<DeckKeywordConstPtr>& keywordList = m_keywordMap[keyword->name()];
             keywordList.push_back(keyword);
         }
     }
     
-    DeckKWConstPtr KeywordContainer::getKeyword(const std::string& keyword) const {
+    DeckKeywordConstPtr KeywordContainer::getKeyword(const std::string& keyword) const {
         if (hasKeyword(keyword)) {
-            const std::vector<DeckKWConstPtr>& keywordList = m_keywordMap.find(keyword)->second;
+            const std::vector<DeckKeywordConstPtr>& keywordList = m_keywordMap.find(keyword)->second;
             return keywordList.back();
         }
         else
diff --git a/opm/parser/eclipse/Deck/KeywordContainer.hpp b/opm/parser/eclipse/Deck/KeywordContainer.hpp
index f63e000e2..ad23e1c18 100644
--- a/opm/parser/eclipse/Deck/KeywordContainer.hpp
+++ b/opm/parser/eclipse/Deck/KeywordContainer.hpp
@@ -12,7 +12,7 @@
 #include <map>
 
 #include <boost/shared_ptr.hpp>
-#include <opm/parser/eclipse/Deck/DeckKW.hpp>
+#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
 
 
 namespace Opm {
@@ -22,13 +22,13 @@ namespace Opm {
         KeywordContainer();
         bool hasKeyword(const std::string& keyword) const;
         size_t size() const;
-        void addKeyword(DeckKWConstPtr keyword);
-        DeckKWConstPtr getKeyword(const std::string& keyword) const;
+        void addKeyword(DeckKeywordConstPtr keyword);
+        DeckKeywordConstPtr getKeyword(const std::string& keyword) const;
 
 
     private:
-        std::vector<DeckKWConstPtr> m_keywordList;
-        std::map<std::string, std::vector<DeckKWConstPtr> > m_keywordMap;
+        std::vector<DeckKeywordConstPtr> m_keywordList;
+        std::map<std::string, std::vector<DeckKeywordConstPtr> > m_keywordMap;
     };
     typedef boost::shared_ptr<KeywordContainer> KeywordContainerPtr;
     typedef boost::shared_ptr<const KeywordContainer> KeywordContainerConstPtr;
diff --git a/opm/parser/eclipse/Deck/tests/CMakeLists.txt b/opm/parser/eclipse/Deck/tests/CMakeLists.txt
index 9fb534c1f..bc645952d 100644
--- a/opm/parser/eclipse/Deck/tests/CMakeLists.txt
+++ b/opm/parser/eclipse/Deck/tests/CMakeLists.txt
@@ -22,7 +22,7 @@ add_executable(runKeywordContainerTests KeywordContainerTests.cpp)
 target_link_libraries(runKeywordContainerTests Parser Logger ${Boost_LIBRARIES})
 add_test(NAME runKeywordContainerTests  COMMAND ${EXECUTABLE_OUTPUT_PATH}/runKeywordContainerTests  )
 
-add_executable(runDeckKWTests DeckKWTests.cpp)
-target_link_libraries(runDeckKWTests Parser Logger ${Boost_LIBRARIES})
-add_test(NAME runDeckKWTests  COMMAND ${EXECUTABLE_OUTPUT_PATH}/runDeckKWTests  )
+add_executable(runDeckKeywordTests DeckKeywordTests.cpp)
+target_link_libraries(runDeckKeywordTests Parser Logger ${Boost_LIBRARIES})
+add_test(NAME runDeckKeywordTests  COMMAND ${EXECUTABLE_OUTPUT_PATH}/runDeckKeywordTests  )
 
diff --git a/opm/parser/eclipse/Deck/tests/DeckKWTests.cpp b/opm/parser/eclipse/Deck/tests/DeckKeywordTests.cpp
similarity index 56%
rename from opm/parser/eclipse/Deck/tests/DeckKWTests.cpp
rename to opm/parser/eclipse/Deck/tests/DeckKeywordTests.cpp
index 92b740359..216b042a9 100644
--- a/opm/parser/eclipse/Deck/tests/DeckKWTests.cpp
+++ b/opm/parser/eclipse/Deck/tests/DeckKeywordTests.cpp
@@ -18,49 +18,49 @@
  */
 
 
-#define BOOST_TEST_MODULE DeckKWTests
+#define BOOST_TEST_MODULE DeckKeywordTests
 
 #include <stdexcept>
 #include <boost/test/unit_test.hpp>
-#include <opm/parser/eclipse/Deck/DeckKW.hpp>
+#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
 
 using namespace Opm;
 
 BOOST_AUTO_TEST_CASE(Initialize) {
-    DeckKW deckKW1("KW");
-    DeckKWPtr deckKW2(new DeckKW("KW"));
-    DeckKWConstPtr deckKW3(new DeckKW("KW"));
+    DeckKeyword deckKeyword1("KW");
+    DeckKeywordPtr deckKeyword2(new DeckKeyword("KW"));
+    DeckKeywordConstPtr deckKeyword3(new DeckKeyword("KW"));
 }
 BOOST_AUTO_TEST_CASE(name_nameSetInConstructor_nameReturned) {
-    DeckKWPtr deckKW(new DeckKW("KW"));
-    BOOST_CHECK_EQUAL("KW", deckKW->name());
+    DeckKeywordPtr deckKeyword(new DeckKeyword("KW"));
+    BOOST_CHECK_EQUAL("KW", deckKeyword->name());
 }
 
 BOOST_AUTO_TEST_CASE(size_noRecords_returnszero) {
-    DeckKWPtr deckKW(new DeckKW("KW"));
-    BOOST_CHECK_EQUAL(0U, deckKW->size());
+    DeckKeywordPtr deckKeyword(new DeckKeyword("KW"));
+    BOOST_CHECK_EQUAL(0U, deckKeyword->size());
 }
 
 
 BOOST_AUTO_TEST_CASE(addRecord_onerecord_recordadded) {
-    DeckKWPtr deckKW(new DeckKW("KW"));
-    deckKW->addRecord(DeckRecordConstPtr(new DeckRecord()));
-    BOOST_CHECK_EQUAL(1U, deckKW->size());
+    DeckKeywordPtr deckKeyword(new DeckKeyword("KW"));
+    deckKeyword->addRecord(DeckRecordConstPtr(new DeckRecord()));
+    BOOST_CHECK_EQUAL(1U, deckKeyword->size());
 }
 
 BOOST_AUTO_TEST_CASE(getRecord_onerecord_recordretured) {
-    DeckKWPtr deckKW(new DeckKW("KW"));
+    DeckKeywordPtr deckKeyword(new DeckKeyword("KW"));
     DeckRecordConstPtr deckRecord(new DeckRecord());
-    deckKW->addRecord(deckRecord);
-    BOOST_CHECK_EQUAL(deckRecord, deckKW->getRecord(0));
+    deckKeyword->addRecord(deckRecord);
+    BOOST_CHECK_EQUAL(deckRecord, deckKeyword->getRecord(0));
 }
 
 
 BOOST_AUTO_TEST_CASE(getRecord_outofrange_exceptionthrown) {
-    DeckKWPtr deckKW(new DeckKW("KW"));
+    DeckKeywordPtr deckKeyword(new DeckKeyword("KW"));
     DeckRecordConstPtr deckRecord(new DeckRecord());
-    deckKW->addRecord(deckRecord);
-    BOOST_CHECK_THROW(deckKW->getRecord(1), std::range_error);
+    deckKeyword->addRecord(deckRecord);
+    BOOST_CHECK_THROW(deckKeyword->getRecord(1), std::range_error);
 }
 
 
diff --git a/opm/parser/eclipse/Deck/tests/DeckTests.cpp b/opm/parser/eclipse/Deck/tests/DeckTests.cpp
index 124415eae..58b341ddb 100644
--- a/opm/parser/eclipse/Deck/tests/DeckTests.cpp
+++ b/opm/parser/eclipse/Deck/tests/DeckTests.cpp
@@ -39,7 +39,7 @@ BOOST_AUTO_TEST_CASE(hasKeyword_empty_returnFalse) {
 
 BOOST_AUTO_TEST_CASE(addKeyword_singlekeyword_keywordAdded) {
     Deck deck;
-    DeckKWConstPtr keyword(new DeckKW("BJARNE"));
+    DeckKeywordConstPtr keyword(new DeckKeyword("BJARNE"));
     BOOST_CHECK_NO_THROW(deck.addKeyword(keyword));
 }
 
@@ -50,7 +50,7 @@ BOOST_AUTO_TEST_CASE(getKeyword_nosuchkeyword_throws) {
 
 BOOST_AUTO_TEST_CASE(getKeyword_singlekeyword_keywordreturned) {
     Deck deck;
-    DeckKWConstPtr keyword(new DeckKW("BJARNE"));
+    DeckKeywordConstPtr keyword(new DeckKeyword("BJARNE"));
     deck.addKeyword(keyword);
     BOOST_CHECK_EQUAL(keyword, deck.getKeyword("BJARNE"));
 }
diff --git a/opm/parser/eclipse/Deck/tests/KeywordContainerTests.cpp b/opm/parser/eclipse/Deck/tests/KeywordContainerTests.cpp
index ce4846a1f..4e4b3647a 100644
--- a/opm/parser/eclipse/Deck/tests/KeywordContainerTests.cpp
+++ b/opm/parser/eclipse/Deck/tests/KeywordContainerTests.cpp
@@ -24,7 +24,7 @@
 #include <boost/test/unit_test.hpp>
 #include <opm/parser/eclipse/Deck/KeywordContainer.hpp>
 #include <opm/parser/eclipse/Deck/Deck.hpp>
-#include <opm/parser/eclipse/Deck/DeckKW.hpp>
+#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
 
 
 using namespace Opm;
@@ -43,7 +43,7 @@ BOOST_AUTO_TEST_CASE(hasKeyword_empty_returnsfalse) {
 
 BOOST_AUTO_TEST_CASE(addKeyword_keywordAdded_keywordAdded) {
     KeywordContainerPtr container(new KeywordContainer());
-    DeckKWPtr keyword = DeckKWPtr(new DeckKW("Truls"));
+    DeckKeywordPtr keyword = DeckKeywordPtr(new DeckKeyword("Truls"));
     container->addKeyword(keyword);
     
     BOOST_CHECK_EQUAL(true, container->hasKeyword("Truls"));
@@ -57,7 +57,7 @@ BOOST_AUTO_TEST_CASE(getKeyword_nosuchkeyword_throws) {
 
 BOOST_AUTO_TEST_CASE(getKeyword_singleKeyword_keywordReturned) {
     KeywordContainerPtr container(new KeywordContainer());
-    DeckKWPtr keyword = DeckKWPtr(new DeckKW("TRULS"));
+    DeckKeywordPtr keyword = DeckKeywordPtr(new DeckKeyword("TRULS"));
     container->addKeyword(keyword);
     BOOST_CHECK_EQUAL(keyword, container->getKeyword("TRULS"));
 }
diff --git a/opm/parser/eclipse/IntegrationTests/IntegrationTests.cpp b/opm/parser/eclipse/IntegrationTests/IntegrationTests.cpp
index 176a559ba..da414383d 100644
--- a/opm/parser/eclipse/IntegrationTests/IntegrationTests.cpp
+++ b/opm/parser/eclipse/IntegrationTests/IntegrationTests.cpp
@@ -33,15 +33,15 @@
 using namespace Opm;
 
 ParserPtr createWWCTParser() {
-    ParserKWPtr parserKW(new ParserKW("WWCT"));
+    ParserKeywordPtr parserKeyword(new ParserKeyword("WWCT"));
     {
         ParserRecordPtr wwctRecord(new ParserRecord());
         wwctRecord->addItem(ParserStringItemConstPtr(new ParserStringItem("WELL", ALL)));
-        parserKW->setRecord(wwctRecord);
+        parserKeyword->setRecord(wwctRecord);
     }
 
     ParserPtr parser(new Parser());
-    parser->addKW(parserKW);
+    parser->addKEYWORD(parserKeyword);
     return parser;
 }
 
@@ -68,18 +68,18 @@ BOOST_AUTO_TEST_CASE(parse_fileWithWWCTKeyword_dataIsCorrect) {
 }
 
 ParserPtr createBPRParser() {
-    ParserKWPtr parserKW(new ParserKW("BPR"));
+    ParserKeywordPtr parserKeyword(new ParserKeyword("BPR"));
     {
         ParserRecordPtr bprRecord(new ParserRecord());
         bprRecord->addItem(ParserIntItemConstPtr(new ParserIntItem("I", SINGLE)));
         bprRecord->addItem(ParserIntItemConstPtr(new ParserIntItem("J", SINGLE)));
         bprRecord->addItem(ParserIntItemConstPtr(new ParserIntItem("K", SINGLE)));
 
-        parserKW->setRecord(bprRecord);
+        parserKeyword->setRecord(bprRecord);
     }
 
     ParserPtr parser(new Parser());
-    parser->addKW(parserKW);
+    parser->addKEYWORD(parserKeyword);
     return parser;
 }
 
@@ -105,7 +105,7 @@ BOOST_AUTO_TEST_CASE(parse_fileWithBPRKeyword_dataiscorrect) {
     ParserPtr parser = createBPRParser();
     DeckPtr deck = parser->parse(singleKeywordFile.string());
 
-    DeckKWConstPtr keyword = deck->getKeyword("BPR");
+    DeckKeywordConstPtr keyword = deck->getKeyword("BPR");
     BOOST_CHECK_EQUAL(2U, keyword->size());
 
     DeckRecordConstPtr record1 = keyword->getRecord(0);
diff --git a/opm/parser/eclipse/IntegrationTests/IntegrationTestsInternalData.cpp b/opm/parser/eclipse/IntegrationTests/IntegrationTestsInternalData.cpp
index 8cdf43765..9d6ebbd11 100644
--- a/opm/parser/eclipse/IntegrationTests/IntegrationTestsInternalData.cpp
+++ b/opm/parser/eclipse/IntegrationTests/IntegrationTestsInternalData.cpp
@@ -26,7 +26,7 @@
 #include <boost/test/unit_test.hpp>
 
 #include <opm/parser/eclipse/Parser/Parser.hpp>
-#include <opm/parser/eclipse/Parser/ParserKW.hpp>
+#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
 #include <opm/parser/eclipse/Parser/ParserRecordSize.hpp>
 #include <opm/parser/eclipse/RawDeck/RawDeck.hpp>
 #include <opm/parser/eclipse/Deck/Deck.hpp>
diff --git a/opm/parser/eclipse/Parser/Parser.cpp b/opm/parser/eclipse/Parser/Parser.cpp
index 753cb0fa8..8dad93a8f 100644
--- a/opm/parser/eclipse/Parser/Parser.cpp
+++ b/opm/parser/eclipse/Parser/Parser.cpp
@@ -17,8 +17,8 @@
   along with OPM.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include <opm/parser/eclipse/Parser/Parser.hpp>
-#include <opm/parser/eclipse/Parser/ParserKW.hpp>
-#include <opm/parser/eclipse/RawDeck/RawParserKWs.hpp>
+#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
+#include <opm/parser/eclipse/RawDeck/RawParserKeywords.hpp>
 #include <opm/parser/eclipse/RawDeck/RawConsts.hpp>
 #include <opm/parser/eclipse/Logger/Logger.hpp>
 #include <opm/parser/eclipse/Deck/Deck.hpp>
@@ -40,17 +40,17 @@ namespace Opm {
             RawKeywordConstPtr rawKeyword = rawDeck->getKeyword(i);
 
             if (hasKeyword(rawKeyword->getKeywordName())) {
-                ParserKWConstPtr parserKW = m_parserKeywords[rawKeyword->getKeywordName()];
-                DeckKWConstPtr deckKW = parserKW->parse(rawKeyword);
-                deck->addKeyword(deckKW);
+                ParserKeywordConstPtr parserKeyword = m_parserKeywords[rawKeyword->getKeywordName()];
+                DeckKeywordConstPtr deckKeyword = parserKeyword->parse(rawKeyword);
+                deck->addKeyword(deckKeyword);
             } else
                 std::cerr << "Keyword: " << rawKeyword->getKeywordName() << " is not recognized, skipping this." << std::endl;
         }
         return deck;
     }
 
-    void Parser::addKW(ParserKWConstPtr parserKW) {
-        m_parserKeywords.insert(std::make_pair(parserKW->getName(), parserKW));
+    void Parser::addKEYWORD(ParserKeywordConstPtr parserKeyword) {
+        m_parserKeywords.insert(std::make_pair(parserKeyword->getName(), parserKeyword));
     }
 
     bool Parser::hasKeyword(const std::string& keyword) const {
@@ -58,7 +58,7 @@ namespace Opm {
     }
 
     RawDeckPtr Parser::readToRawDeck(const std::string& path) const {
-        RawDeckPtr rawDeck(new RawDeck(RawParserKWsConstPtr(new RawParserKWs())));
+        RawDeckPtr rawDeck(new RawDeck(RawParserKeywordsConstPtr(new RawParserKeywords())));
         readToRawDeck(rawDeck, path);
         return rawDeck;
     }
@@ -66,7 +66,7 @@ namespace Opm {
     /// The main data reading function, reads one and one keyword into the RawDeck
     /// If the INCLUDE keyword is found, the specified include file is inline read into the RawDeck.
     /// The data is read into a keyword, record by record, until the fixed number of records specified
-    /// in the RawParserKW is met, or till a slash on a separate line is found.
+    /// in the RawParserKeyword is met, or till a slash on a separate line is found.
 
     void Parser::readToRawDeck(RawDeckPtr rawDeck, const std::string& path) const {
         boost::filesystem::path dataFolderPath = verifyValidInputPath(path);
diff --git a/opm/parser/eclipse/Parser/Parser.hpp b/opm/parser/eclipse/Parser/Parser.hpp
index fd31ac3ac..5b18dc494 100644
--- a/opm/parser/eclipse/Parser/Parser.hpp
+++ b/opm/parser/eclipse/Parser/Parser.hpp
@@ -28,7 +28,7 @@
 #include <opm/parser/eclipse/RawDeck/RawKeyword.hpp>
 #include <opm/parser/eclipse/RawDeck/RawDeck.hpp>
 #include <opm/parser/eclipse/Deck/Deck.hpp>
-#include <opm/parser/eclipse/Parser/ParserKW.hpp>
+#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
 
 namespace Opm {
 
@@ -49,12 +49,12 @@ namespace Opm {
         /// Reads an eclipse file and returns a tokenized RawDeck
         RawDeckPtr readToRawDeck(const std::string& path) const;
 
-        /// Method to add ParserKW instances, these holding type and size information about the keywords and their data.
-        void addKW(ParserKWConstPtr parserKW);
+        /// Method to add ParserKeyword instances, these holding type and size information about the keywords and their data.
+        void addKEYWORD(ParserKeywordConstPtr parserKeyword);
         bool hasKeyword(const std::string& keyword) const;
 
     private:
-        std::map<std::string, ParserKWConstPtr> m_parserKeywords;
+        std::map<std::string, ParserKeywordConstPtr> m_parserKeywords;
         void readToRawDeck(RawDeckPtr rawDeck, const std::string& path) const;
         void processIncludeKeyword(RawDeckPtr rawDeck, RawKeywordConstPtr keyword, const boost::filesystem::path& dataFolderPath) const;
         boost::filesystem::path verifyValidInputPath(const std::string& inputPath) const;
diff --git a/opm/parser/eclipse/Parser/ParserConst.hpp b/opm/parser/eclipse/Parser/ParserConst.hpp
index f202650a8..6a77b645c 100644
--- a/opm/parser/eclipse/Parser/ParserConst.hpp
+++ b/opm/parser/eclipse/Parser/ParserConst.hpp
@@ -23,7 +23,7 @@
 
 namespace Opm {
     namespace ParserConst {
-        const unsigned int maxKWLength = 8;
+        const unsigned int maxKEYWORDLength = 8;
     }
 }
 
diff --git a/opm/parser/eclipse/Parser/ParserKW.cpp b/opm/parser/eclipse/Parser/ParserKeyword.cpp
similarity index 73%
rename from opm/parser/eclipse/Parser/ParserKW.cpp
rename to opm/parser/eclipse/Parser/ParserKeyword.cpp
index c17d8c647..2c1c6fdfe 100644
--- a/opm/parser/eclipse/Parser/ParserKW.cpp
+++ b/opm/parser/eclipse/Parser/ParserKeyword.cpp
@@ -22,16 +22,16 @@
 
 #include <opm/parser/eclipse/Parser/ParserConst.hpp>
 #include <opm/parser/eclipse/Parser/ParserRecordSize.hpp>
-#include <opm/parser/eclipse/Parser/ParserKW.hpp>
+#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
 
 namespace Opm {
 
-    ParserKW::ParserKW(const std::string& name) {
+    ParserKeyword::ParserKeyword(const std::string& name) {
         m_name = name;
     }
 
-    ParserKW::ParserKW(const std::string& name, ParserRecordSizeConstPtr recordSize) {
-        if (name.length() > ParserConst::maxKWLength)
+    ParserKeyword::ParserKeyword(const std::string& name, ParserRecordSizeConstPtr recordSize) {
+        if (name.length() > ParserConst::maxKEYWORDLength)
             throw std::invalid_argument("Given keyword name is too long - max 8 characters.");
 
         for (unsigned int i = 0; i < name.length(); i++)
@@ -42,20 +42,20 @@ namespace Opm {
         this->recordSize = recordSize;
     }
 
-    void ParserKW::setRecord(ParserRecordConstPtr record) {
+    void ParserKeyword::setRecord(ParserRecordConstPtr record) {
         m_record = record;
     }
 
-    ParserRecordConstPtr ParserKW::getRecord() {
+    ParserRecordConstPtr ParserKeyword::getRecord() {
         return m_record;
     }
     
-    const std::string& ParserKW::getName() const {
+    const std::string& ParserKeyword::getName() const {
         return m_name;
     }
 
-    DeckKWPtr ParserKW::parse(RawKeywordConstPtr rawKeyword) const {
-        DeckKWPtr keyword(new DeckKW(getName()));
+    DeckKeywordPtr ParserKeyword::parse(RawKeywordConstPtr rawKeyword) const {
+        DeckKeywordPtr keyword(new DeckKeyword(getName()));
         if (m_record != NULL) {
             for (size_t i=0; i<rawKeyword->size(); i++) {
                 DeckRecordConstPtr deckRecord = m_record->parse(rawKeyword->getRecord(i));
@@ -63,7 +63,7 @@ namespace Opm {
             }
         }
         else 
-            throw std::logic_error("Unable to parse rawKeyword, because the ParserKW's record is not set!");
+            throw std::logic_error("Unable to parse rawKeyword, because the ParserKeyword's record is not set!");
         
         return keyword;
     }
diff --git a/opm/parser/eclipse/Parser/ParserKW.hpp b/opm/parser/eclipse/Parser/ParserKeyword.hpp
similarity index 72%
rename from opm/parser/eclipse/Parser/ParserKW.hpp
rename to opm/parser/eclipse/Parser/ParserKeyword.hpp
index f1d70999f..40044a62d 100644
--- a/opm/parser/eclipse/Parser/ParserKW.hpp
+++ b/opm/parser/eclipse/Parser/ParserKeyword.hpp
@@ -16,36 +16,36 @@
   You should have received a copy of the GNU General Public License
   along with OPM.  If not, see <http://www.gnu.org/licenses/>.
  */
-#ifndef PARSER_KW_H
-#define PARSER_KW_H
+#ifndef PARSER_KEYWORD_H
+#define PARSER_KEYWORD_H
 
 #include <string>
 #include <boost/shared_ptr.hpp>
 
 #include <opm/parser/eclipse/Parser/ParserRecordSize.hpp>
 #include <opm/parser/eclipse/Parser/ParserRecord.hpp>
-#include <opm/parser/eclipse/Deck/DeckKW.hpp>
+#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
 #include <opm/parser/eclipse/RawDeck/RawKeyword.hpp>
 
 
 namespace Opm {
 
-    class ParserKW {
+    class ParserKeyword {
     public:
-        ParserKW(const std::string& name);
-        ParserKW(const std::string& name, ParserRecordSizeConstPtr recordSize);
+        ParserKeyword(const std::string& name);
+        ParserKeyword(const std::string& name, ParserRecordSizeConstPtr recordSize);
         void setRecord(ParserRecordConstPtr record);
         ParserRecordConstPtr getRecord();
         const std::string& getName() const;
-        DeckKWPtr parse(RawKeywordConstPtr rawKeyword) const;
+        DeckKeywordPtr parse(RawKeywordConstPtr rawKeyword) const;
         
     private:
         std::string m_name;
         ParserRecordConstPtr m_record;
         ParserRecordSizeConstPtr recordSize;
     };
-    typedef boost::shared_ptr<ParserKW> ParserKWPtr;
-    typedef boost::shared_ptr<const ParserKW> ParserKWConstPtr;
+    typedef boost::shared_ptr<ParserKeyword> ParserKeywordPtr;
+    typedef boost::shared_ptr<const ParserKeyword> ParserKeywordConstPtr;
 }
 
 #endif
diff --git a/opm/parser/eclipse/Parser/tests/CMakeLists.txt b/opm/parser/eclipse/Parser/tests/CMakeLists.txt
index cd3a4507b..fa87d7c49 100644
--- a/opm/parser/eclipse/Parser/tests/CMakeLists.txt
+++ b/opm/parser/eclipse/Parser/tests/CMakeLists.txt
@@ -1,17 +1,17 @@
 add_executable(runParserTests ParserTests.cpp)
-add_executable(runParserKWTests ParserKWTests.cpp)
+add_executable(runParserKeywordTests ParserKeywordTests.cpp)
 add_executable(runParserRecordTests ParserRecordTests.cpp)
 add_executable(runParserRecordSizeTests ParserRecordSizeTests.cpp)
 add_executable(runParserItemTests ParserItemTests.cpp)
 
 target_link_libraries(runParserTests Parser ${Boost_LIBRARIES})
-target_link_libraries(runParserKWTests Parser ${Boost_LIBRARIES})
+target_link_libraries(runParserKeywordTests Parser ${Boost_LIBRARIES})
 target_link_libraries(runParserRecordSizeTests Parser ${Boost_LIBRARIES})
 target_link_libraries(runParserRecordTests Parser ${Boost_LIBRARIES})
 target_link_libraries(runParserItemTests Parser ${Boost_LIBRARIES})
 
 add_test(NAME runParserTests WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} COMMAND ${EXECUTABLE_OUTPUT_PATH}/runParserTests )
-add_test(NAME runParserKWTests COMMAND ${EXECUTABLE_OUTPUT_PATH}/runParserKWTests )
+add_test(NAME runParserKeywordTests COMMAND ${EXECUTABLE_OUTPUT_PATH}/runParserKWTests )
 add_test(NAME runParserRecordSizeTests COMMAND ${EXECUTABLE_OUTPUT_PATH}/runParserRecordSizeTests )
 add_test(NAME runParserRecordTests COMMAND ${EXECUTABLE_OUTPUT_PATH}/runParserRecordTests )
 add_test(NAME runParserItemTests COMMAND ${EXECUTABLE_OUTPUT_PATH}/runParserItemTests )
diff --git a/opm/parser/eclipse/Parser/tests/ParserKWTests.cpp b/opm/parser/eclipse/Parser/tests/ParserKeywordTests.cpp
similarity index 68%
rename from opm/parser/eclipse/Parser/tests/ParserKWTests.cpp
rename to opm/parser/eclipse/Parser/tests/ParserKeywordTests.cpp
index a554bebca..921a0e049 100644
--- a/opm/parser/eclipse/Parser/tests/ParserKWTests.cpp
+++ b/opm/parser/eclipse/Parser/tests/ParserKeywordTests.cpp
@@ -21,7 +21,7 @@
 #define BOOST_TEST_MODULE ParserTests
 #include <boost/test/unit_test.hpp>
 
-#include "opm/parser/eclipse/Parser/ParserKW.hpp"
+#include "opm/parser/eclipse/Parser/ParserKeyword.hpp"
 #include "opm/parser/eclipse/Parser/ParserIntItem.hpp"
 #include "opm/parser/eclipse/Parser/ParserItem.hpp"
 
@@ -30,42 +30,42 @@
 using namespace Opm;
 
 BOOST_AUTO_TEST_CASE(construct_withname_nameSet) {
-    ParserKW parserKW("BPR");
-    BOOST_CHECK_EQUAL(parserKW.getName(), "BPR");
+    ParserKeyword parserKeyword("BPR");
+    BOOST_CHECK_EQUAL(parserKeyword.getName(), "BPR");
 }
 
 BOOST_AUTO_TEST_CASE(NamedInit) {
     std::string keyword("KEYWORD");
 
     ParserRecordSizeConstPtr recordSize(new ParserRecordSize(100));
-    ParserKW parserKW(keyword, recordSize);
-    BOOST_CHECK_EQUAL(parserKW.getName(), keyword);
+    ParserKeyword parserKeyword(keyword, recordSize);
+    BOOST_CHECK_EQUAL(parserKeyword.getName(), keyword);
 }
 
 BOOST_AUTO_TEST_CASE(setRecord_validRecord_recordSet) {
-    ParserKWPtr parserKW(new ParserKW("JA"));
+    ParserKeywordPtr parserKeyword(new ParserKeyword("JA"));
     ParserRecordConstPtr parserRecord = ParserRecordConstPtr(new ParserRecord());
-    parserKW->setRecord(parserRecord);
-    BOOST_CHECK_EQUAL(parserRecord, parserKW->getRecord());
+    parserKeyword->setRecord(parserRecord);
+    BOOST_CHECK_EQUAL(parserRecord, parserKeyword->getRecord());
 }
 
 BOOST_AUTO_TEST_CASE(NameTooLong) {
     std::string keyword("KEYWORDTOOLONG");
     ParserRecordSizeConstPtr recordSize(new ParserRecordSize(100));
-    BOOST_CHECK_THROW(ParserKW parserKW(keyword, recordSize), std::invalid_argument);
+    BOOST_CHECK_THROW(ParserKeyword parserKeyword(keyword, recordSize), std::invalid_argument);
 }
 
 BOOST_AUTO_TEST_CASE(MixedCase) {
     std::string keyword("KeyWord");
 
     ParserRecordSizeConstPtr recordSize(new ParserRecordSize(100));
-    BOOST_CHECK_THROW(ParserKW parserKW(keyword, recordSize), std::invalid_argument);
+    BOOST_CHECK_THROW(ParserKeyword parserKeyword(keyword, recordSize), std::invalid_argument);
 }
 
-BOOST_AUTO_TEST_CASE(parse_rawKeyword_returnsDeckKW) {
+BOOST_AUTO_TEST_CASE(parse_rawKeyword_returnsDeckKeyword) {
     RawKeywordPtr rawKeyword(new RawKeyword("TEST2"));
     rawKeyword->addRawRecordString("2 3 5 /");
-    ParserKWPtr parserKW(new ParserKW("TEST2"));
+    ParserKeywordPtr parserKeyword(new ParserKeyword("TEST2"));
     
     ParserRecordPtr parserRecord = ParserRecordPtr(new ParserRecord());
 
@@ -76,7 +76,7 @@ BOOST_AUTO_TEST_CASE(parse_rawKeyword_returnsDeckKW) {
     ParserItemPtr item3(new ParserIntItem("K", SINGLE));
     parserRecord->addItem(item3);
     
-    parserKW->setRecord(parserRecord);
-    DeckKWPtr deckKW = parserKW->parse(rawKeyword);
-    BOOST_CHECK_EQUAL(1U, deckKW->size());
+    parserKeyword->setRecord(parserRecord);
+    DeckKeywordPtr deckKeyword = parserKeyword->parse(rawKeyword);
+    BOOST_CHECK_EQUAL(1U, deckKeyword->size());
 }
diff --git a/opm/parser/eclipse/Parser/tests/ParserTests.cpp b/opm/parser/eclipse/Parser/tests/ParserTests.cpp
index d76db19c2..c2328145c 100644
--- a/opm/parser/eclipse/Parser/tests/ParserTests.cpp
+++ b/opm/parser/eclipse/Parser/tests/ParserTests.cpp
@@ -25,7 +25,7 @@
 
 
 #include <opm/parser/eclipse/Parser/Parser.hpp>
-#include <opm/parser/eclipse/Parser/ParserKW.hpp>
+#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
 #include <opm/parser/eclipse/Parser/ParserRecordSize.hpp>
 #include <opm/parser/eclipse/RawDeck/RawDeck.hpp>
 
@@ -41,25 +41,25 @@ BOOST_AUTO_TEST_CASE(Initializing) {
     BOOST_CHECK_NO_THROW(ParserConstPtr parserConstPtr(new Parser()));
 }
 
-BOOST_AUTO_TEST_CASE(addKW_keyword_doesntfail) {
+BOOST_AUTO_TEST_CASE(addKEYWORD_keyword_doesntfail) {
     Parser parser;
     {
         ParserRecordSizePtr recordSize(new ParserRecordSize(9));
-        ParserKWPtr equilKW(new ParserKW("EQUIL", recordSize));
-        parser.addKW(equilKW);
+        ParserKeywordPtr equilKEYWORD(new ParserKeyword("EQUIL", recordSize));
+        parser.addKEYWORD(equilKEYWORD);
     }
 }
 
 BOOST_AUTO_TEST_CASE(hasKeyword_hasKeyword_returnstrue) {
     ParserPtr parser(new Parser());
-    parser->addKW(ParserKWConstPtr(new ParserKW("FJAS")));
+    parser->addKEYWORD(ParserKeywordConstPtr(new ParserKeyword("FJAS")));
     BOOST_CHECK(parser->hasKeyword("FJAS"));
 }
 
 /***************** Simple Int parsing ********************************/
 
-ParserKWPtr setupParserKWInt(std::string name, int numberOfItems) {
-    ParserKWPtr parserKw(new ParserKW(name));
+ParserKeywordPtr setupParserKeywordInt(std::string name, int numberOfItems) {
+    ParserKeywordPtr parserKeyword(new ParserKeyword(name));
     ParserRecordPtr parserRecord(new ParserRecord());
     for (int i = 0; i < numberOfItems; i++) {
         std::string name = "ITEM_" + boost::lexical_cast<std::string>(i);
@@ -67,14 +67,14 @@ ParserKWPtr setupParserKWInt(std::string name, int numberOfItems) {
         parserRecord->addItem(intItem);
     }
 
-    parserKw->setRecord(parserRecord);
+    parserKeyword->setRecord(parserRecord);
 
-    return parserKw;
+    return parserKeyword;
 }
 
 RawDeckPtr setupRawDeckInt(std::string name, int numberOfRecords, int numberOfItems) {
-    RawParserKWsConstPtr rawParserKWs(new RawParserKWs());
-    RawDeckPtr rawDeck(new RawDeck(rawParserKWs));
+    RawParserKeywordsConstPtr rawParserKeywords(new RawParserKeywords());
+    RawDeckPtr rawDeck(new RawDeck(rawParserKeywords));
 
     RawKeywordPtr rawKeyword(new RawKeyword(name));
     for (int records = 0; records < numberOfRecords; records++) {
@@ -90,7 +90,7 @@ RawDeckPtr setupRawDeckInt(std::string name, int numberOfRecords, int numberOfIt
 
 BOOST_AUTO_TEST_CASE(parseFromRawDeck_singleRawSingleIntItem_deckReturned) {
     ParserPtr parser(new Parser());
-    parser->addKW(setupParserKWInt("RANDOM", 1));
+    parser->addKEYWORD(setupParserKeywordInt("RANDOM", 1));
     DeckPtr deck = parser->parseFromRawDeck(setupRawDeckInt("RANDOM", 1, 1));
 
     BOOST_CHECK(!deck->hasKeyword("ANDOM"));
@@ -101,7 +101,7 @@ BOOST_AUTO_TEST_CASE(parseFromRawDeck_singleRawSingleIntItem_deckReturned) {
 
 BOOST_AUTO_TEST_CASE(parseFromRawDeck_singleRawRecordsSeveralIntItem_deckReturned) {
     ParserPtr parser(new Parser());
-    parser->addKW(setupParserKWInt("RANDOM", 50));
+    parser->addKEYWORD(setupParserKeywordInt("RANDOM", 50));
     DeckPtr deck = parser->parseFromRawDeck(setupRawDeckInt("RANDOM", 1, 50));
 
     BOOST_CHECK(deck->hasKeyword("RANDOM"));
@@ -110,7 +110,7 @@ BOOST_AUTO_TEST_CASE(parseFromRawDeck_singleRawRecordsSeveralIntItem_deckReturne
 
 BOOST_AUTO_TEST_CASE(parseFromRawDeck_severalRawRecordsSeveralIntItem_deckReturned) {
     ParserPtr parser(new Parser());
-    parser->addKW(setupParserKWInt("RANDOM", 50));
+    parser->addKEYWORD(setupParserKeywordInt("RANDOM", 50));
     DeckPtr deck = parser->parseFromRawDeck(setupRawDeckInt("RANDOM", 10, 50));
 
     BOOST_CHECK(deck->hasKeyword("RANDOM"));
@@ -120,8 +120,8 @@ BOOST_AUTO_TEST_CASE(parseFromRawDeck_severalRawRecordsSeveralIntItem_deckReturn
 
 /***************** Simple String parsing ********************************/
 
-ParserKWPtr setupParserKWString(std::string name, int numberOfItems) {
-    ParserKWPtr parserKw(new ParserKW(name));
+ParserKeywordPtr setupParserKeywordString(std::string name, int numberOfItems) {
+    ParserKeywordPtr parserKeyword(new ParserKeyword(name));
     ParserRecordPtr parserRecord(new ParserRecord());
     for (int i = 0; i < numberOfItems; i++) {
         std::string name = "ITEM_" + boost::lexical_cast<std::string>(i);
@@ -129,14 +129,14 @@ ParserKWPtr setupParserKWString(std::string name, int numberOfItems) {
         parserRecord->addItem(stringItem);
     }
 
-    parserKw->setRecord(parserRecord);
+    parserKeyword->setRecord(parserRecord);
 
-    return parserKw;
+    return parserKeyword;
 }
 
 RawDeckPtr setupRawDeckString(std::string name, int numberOfRecords, int numberOfItems) {
-    RawParserKWsConstPtr rawParserKWs(new RawParserKWs());
-    RawDeckPtr rawDeck(new RawDeck(rawParserKWs));
+    RawParserKeywordsConstPtr rawParserKeywords(new RawParserKeywords());
+    RawDeckPtr rawDeck(new RawDeck(rawParserKeywords));
 
     RawKeywordPtr rawKeyword(new RawKeyword(name));
     for (int records = 0; records < numberOfRecords; records++) {
@@ -154,7 +154,7 @@ RawDeckPtr setupRawDeckString(std::string name, int numberOfRecords, int numberO
 
 BOOST_AUTO_TEST_CASE(parseFromRawDeck_singleRawRecordsSingleStringItem_deckReturned) {
     ParserPtr parser(new Parser());
-    parser->addKW(setupParserKWString("WWCT", 1));
+    parser->addKEYWORD(setupParserKeywordString("WWCT", 1));
     DeckPtr deck = parser->parseFromRawDeck(setupRawDeckString("WWCT",1, 1));
 
     BOOST_CHECK(deck->hasKeyword("WWCT"));
diff --git a/opm/parser/eclipse/RawDeck/RawDeck.cpp b/opm/parser/eclipse/RawDeck/RawDeck.cpp
index 82fdf0251..242f89d09 100644
--- a/opm/parser/eclipse/RawDeck/RawDeck.cpp
+++ b/opm/parser/eclipse/RawDeck/RawDeck.cpp
@@ -24,8 +24,8 @@
 
 namespace Opm {
 
-    RawDeck::RawDeck(RawParserKWsConstPtr rawParserKWs) {
-        m_rawParserKWs = rawParserKWs;
+    RawDeck::RawDeck(RawParserKeywordsConstPtr rawParserKeywords) {
+        m_rawParserKeywords = rawParserKeywords;
     }
 
     void RawDeck::addKeyword(RawKeywordConstPtr keyword) {
@@ -44,11 +44,11 @@ namespace Opm {
     }
 
     /// Checks if the current keyword being read is finished, based on the number of records
-    /// specified for the current keyword type in the RawParserKW class.
+    /// specified for the current keyword type in the RawParserKeyword class.
 
     bool RawDeck::isKeywordFinished(RawKeywordConstPtr rawKeyword) {
-        if (m_rawParserKWs->keywordExists(rawKeyword->getKeywordName())) {
-            return rawKeyword->size() == m_rawParserKWs->getFixedNumberOfRecords(rawKeyword->getKeywordName());
+        if (m_rawParserKeywords->keywordExists(rawKeyword->getKeywordName())) {
+            return rawKeyword->size() == m_rawParserKeywords->getFixedNumberOfRecords(rawKeyword->getKeywordName());
         }
         return false;
     }
diff --git a/opm/parser/eclipse/RawDeck/RawDeck.hpp b/opm/parser/eclipse/RawDeck/RawDeck.hpp
index f9aa4c38c..0eb328ac7 100644
--- a/opm/parser/eclipse/RawDeck/RawDeck.hpp
+++ b/opm/parser/eclipse/RawDeck/RawDeck.hpp
@@ -24,7 +24,7 @@
 #include <boost/shared_ptr.hpp>
 #include <boost/filesystem.hpp>
 #include <opm/parser/eclipse/RawDeck/RawKeyword.hpp>
-#include <opm/parser/eclipse/RawDeck/RawParserKWs.hpp>
+#include <opm/parser/eclipse/RawDeck/RawParserKeywords.hpp>
 
 namespace Opm {
 
@@ -38,15 +38,15 @@ namespace Opm {
 
         /// Constructor that requires information about the fixed record length keywords. 
         /// All relevant keywords with a fixed number of records 
-        /// must be specified through the RawParserKW class. This is to be able to know how the records
+        /// must be specified through the RawParserKeyword class. This is to be able to know how the records
         /// of the keyword is structured.
 
-        RawDeck(RawParserKWsConstPtr rawParserKWs);
+        RawDeck(RawParserKeywordsConstPtr rawParserKeywords);
         void addKeyword(RawKeywordConstPtr keyword);
         RawKeywordConstPtr getKeyword(size_t index) const;
         size_t size() const;
         
-        // This will move to Parser class when m_rawParserKWs is moved.
+        // This will move to Parser class when m_rawParserKeywords is moved.
         bool isKeywordFinished(RawKeywordConstPtr rawKeyword);
       
         friend std::ostream& operator<<(std::ostream& os, const RawDeck& deck);
@@ -55,8 +55,8 @@ namespace Opm {
     private:
         std::vector<RawKeywordConstPtr> m_keywords;
         
-        // This variable should be replaced by an equivalent collection of ParserKWs, and put in the Parser class
-        RawParserKWsConstPtr m_rawParserKWs;
+        // This variable should be replaced by an equivalent collection of ParserKeywords, and put in the Parser class
+        RawParserKeywordsConstPtr m_rawParserKeywords;
 
         void processIncludeKeyword(RawKeywordConstPtr keyword, const boost::filesystem::path& dataFolderPath);
         static boost::filesystem::path verifyValidInputPath(const std::string& inputPath);
diff --git a/opm/parser/eclipse/RawDeck/RawParserKWs.cpp b/opm/parser/eclipse/RawDeck/RawParserKeywords.cpp
similarity index 87%
rename from opm/parser/eclipse/RawDeck/RawParserKWs.cpp
rename to opm/parser/eclipse/RawDeck/RawParserKeywords.cpp
index a88c08bac..b7b49ea3e 100644
--- a/opm/parser/eclipse/RawDeck/RawParserKWs.cpp
+++ b/opm/parser/eclipse/RawDeck/RawParserKeywords.cpp
@@ -17,30 +17,30 @@
   along with OPM.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include <stdexcept>
-#include "RawParserKWs.hpp"
+#include "RawParserKeywords.hpp"
 
 namespace Opm {
 
-    RawParserKWs::RawParserKWs() {
+    RawParserKeywords::RawParserKeywords() {
         initializeFixedKeywordLenghts();
     }
 
-    bool RawParserKWs::keywordExists(const std::string& keyword) const {
+    bool RawParserKeywords::keywordExists(const std::string& keyword) const {
         return m_keywordRecordLengths.find(keyword) != m_keywordRecordLengths.end();
     }
 
-    unsigned int RawParserKWs::getFixedNumberOfRecords(const std::string& keyword) const {
+    unsigned int RawParserKeywords::getFixedNumberOfRecords(const std::string& keyword) const {
         if (keywordExists(keyword)) {
             return m_keywordRecordLengths.find(keyword) -> second;
         } else
             throw std::invalid_argument("Given keyword is not found, offending keyword: " + keyword);
     }
 
-    void RawParserKWs::add(std::pair<std::string, unsigned int> keywordAndNumRecords) {
+    void RawParserKeywords::add(std::pair<std::string, unsigned int> keywordAndNumRecords) {
         m_keywordRecordLengths.insert(keywordAndNumRecords);
     }
 
-    void RawParserKWs::initializeFixedKeywordLenghts() {
+    void RawParserKeywords::initializeFixedKeywordLenghts() {
         add(std::pair<std::string, unsigned int>("GRIDUNIT", 1));
         add(std::pair<std::string, unsigned int>("INCLUDE", 1));
         add(std::pair<std::string, unsigned int>("RADFIN4", 1));
@@ -74,7 +74,7 @@ namespace Opm {
         add(std::pair<std::string, unsigned int>("VAPOIL", 0));
     }
 
-    RawParserKWs::~RawParserKWs() {
+    RawParserKeywords::~RawParserKeywords() {
     }
 }
 
diff --git a/opm/parser/eclipse/RawDeck/RawParserKWs.hpp b/opm/parser/eclipse/RawDeck/RawParserKeywords.hpp
similarity index 72%
rename from opm/parser/eclipse/RawDeck/RawParserKWs.hpp
rename to opm/parser/eclipse/RawDeck/RawParserKeywords.hpp
index 0e8b57732..429ffd0f7 100644
--- a/opm/parser/eclipse/RawDeck/RawParserKWs.hpp
+++ b/opm/parser/eclipse/RawDeck/RawParserKeywords.hpp
@@ -1,12 +1,12 @@
 /* 
- * File:   RawParserKW.h
+ * File:   RawParserKeyword.h
  * Author: kflik
  *
  * Created on April 4, 2013, 12:12 PM
  */
 
-#ifndef RAWPARSERKW_H
-#define	RAWPARSERKW_H
+#ifndef RAWPARSERKEYWORD_H
+#define	RAWPARSERKEYWORD_H
 
 #include <string>
 #include <map>
@@ -17,20 +17,20 @@ namespace Opm {
     /// The characteristics being held is the ones important for the raw parsing,
     /// these being the keywords name and fixed number of records for the keyword.
 
-    class RawParserKWs {
+    class RawParserKeywords {
     public:
-        RawParserKWs();
+        RawParserKeywords();
         bool keywordExists(const std::string& keyword) const;
         unsigned int getFixedNumberOfRecords(const std::string& keyword) const;
-        virtual ~RawParserKWs();
+        virtual ~RawParserKeywords();
     private:
         std::map<std::string, unsigned int> m_keywordRecordLengths;
         void initializeFixedKeywordLenghts();
         void add(std::pair<std::string, unsigned int> keywordAndNumRecords);
 
     };
-    typedef boost::shared_ptr<const RawParserKWs> RawParserKWsConstPtr;
+    typedef boost::shared_ptr<const RawParserKeywords> RawParserKeywordsConstPtr;
 
 }
-#endif	/* RAWPARSERKW_H */
+#endif	/* RAWPARSERKEYWORD_H */
 
diff --git a/opm/parser/eclipse/RawDeck/tests/CMakeLists.txt b/opm/parser/eclipse/RawDeck/tests/CMakeLists.txt
index f6b53a8df..8003ebf31 100644
--- a/opm/parser/eclipse/RawDeck/tests/CMakeLists.txt
+++ b/opm/parser/eclipse/RawDeck/tests/CMakeLists.txt
@@ -1,14 +1,14 @@
 add_executable(runRawRecordTests RawRecordTests.cpp)
 add_executable(runRawKeywordTests RawKeywordTests.cpp)
 add_executable(runRawDeckTests RawDeckTests.cpp)
-add_executable(runRawParserKWsTests RawParserKWsTests.cpp)
+add_executable(runRawParserKeywordsTests RawParserKeywordsTests.cpp)
 
 target_link_libraries(runRawRecordTests Parser ${Boost_LIBRARIES})
 target_link_libraries(runRawKeywordTests Parser ${Boost_LIBRARIES})
 target_link_libraries(runRawDeckTests Parser ${Boost_LIBRARIES})
-target_link_libraries(runRawParserKWsTests Parser ${Boost_LIBRARIES})
+target_link_libraries(runRawParserKeywordsTests Parser ${Boost_LIBRARIES})
 
 add_test(NAME runRawRecordTests COMMAND ${EXECUTABLE_OUTPUT_PATH}/runRawRecordTests )
 add_test(NAME runRawKeywordTests COMMAND ${EXECUTABLE_OUTPUT_PATH}/runRawKeywordTests )
 add_test(NAME runRawDeckTests WORKING_DIRECTORY ${EXECUTABLE_OUTPUT_PATH} COMMAND runRawDeckTests )
-add_test(NAME runRawParserKWsTests COMMAND ${EXECUTABLE_OUTPUT_PATH}/runRawParserKWsTests )
+add_test(NAME runRawParserKeywordsTests COMMAND ${EXECUTABLE_OUTPUT_PATH}/runRawParserKeywordsTests )
diff --git a/opm/parser/eclipse/RawDeck/tests/RawDeckTests.cpp b/opm/parser/eclipse/RawDeck/tests/RawDeckTests.cpp
index 3da6f3608..e2bef1a19 100644
--- a/opm/parser/eclipse/RawDeck/tests/RawDeckTests.cpp
+++ b/opm/parser/eclipse/RawDeck/tests/RawDeckTests.cpp
@@ -23,7 +23,7 @@
 #define BOOST_TEST_MODULE RawDeckTests
 #include <boost/test/unit_test.hpp>
 #include <opm/parser/eclipse/RawDeck/RawDeck.hpp>
-#include <opm/parser/eclipse/RawDeck/RawParserKWs.hpp>
+#include <opm/parser/eclipse/RawDeck/RawParserKeywords.hpp>
 #include <opm/parser/eclipse/RawDeck/RawKeyword.hpp>
 #include <boost/test/test_tools.hpp>
 
@@ -32,25 +32,25 @@
 using namespace Opm;
 
 BOOST_AUTO_TEST_CASE(Initialize_NoThrow) {
-    RawParserKWsConstPtr fixedKeywords(new RawParserKWs());
+    RawParserKeywordsConstPtr fixedKeywords(new RawParserKeywords());
     BOOST_CHECK_NO_THROW(RawDeck rawDeck(fixedKeywords));
 }
 
 
 BOOST_AUTO_TEST_CASE(GetNumberOfKeywords_EmptyDeck_RetunsZero) {
-    RawParserKWsConstPtr fixedKeywords(new RawParserKWs());
+    RawParserKeywordsConstPtr fixedKeywords(new RawParserKeywords());
     RawDeckPtr rawDeck(new RawDeck(fixedKeywords));
     BOOST_CHECK_EQUAL((unsigned) 0, rawDeck->size());
 }
 
 BOOST_AUTO_TEST_CASE(GetKeyword_EmptyDeck_ThrowsExeption) {
-    RawParserKWsConstPtr fixedKeywords(new RawParserKWs());
+    RawParserKeywordsConstPtr fixedKeywords(new RawParserKeywords());
     RawDeckPtr rawDeck(new RawDeck(fixedKeywords));
     BOOST_CHECK_THROW(rawDeck->getKeyword(0), std::range_error);
 }
 
 BOOST_AUTO_TEST_CASE(addKeyword_withkeywords_keywordAdded) {
-    RawParserKWsConstPtr fixedKeywords(new RawParserKWs());
+    RawParserKeywordsConstPtr fixedKeywords(new RawParserKeywords());
     RawDeckPtr rawDeck(new RawDeck(fixedKeywords));
     
     RawKeywordPtr keyword(new RawKeyword("BJARNE"));
diff --git a/opm/parser/eclipse/RawDeck/tests/RawParserKWsTests.cpp b/opm/parser/eclipse/RawDeck/tests/RawParserKeywordsTests.cpp
similarity index 58%
rename from opm/parser/eclipse/RawDeck/tests/RawParserKWsTests.cpp
rename to opm/parser/eclipse/RawDeck/tests/RawParserKeywordsTests.cpp
index 840f34e50..6d66feddb 100644
--- a/opm/parser/eclipse/RawDeck/tests/RawParserKWsTests.cpp
+++ b/opm/parser/eclipse/RawDeck/tests/RawParserKeywordsTests.cpp
@@ -19,33 +19,33 @@
 
 #include <map>
 #include <string>
-#define BOOST_TEST_MODULE RawParserKWsTests
+#define BOOST_TEST_MODULE RawParserKeywordsTests
 #include <boost/test/unit_test.hpp>
 #include <opm/parser/eclipse/RawDeck/RawDeck.hpp>
-#include <opm/parser/eclipse/RawDeck/RawParserKWs.hpp>
+#include <opm/parser/eclipse/RawDeck/RawParserKeywords.hpp>
 using namespace Opm;
 
 BOOST_AUTO_TEST_CASE(KeywordExists_KeywordNotPresent_ReturnsFalse) {
-    RawParserKWsConstPtr parserKWs(new RawParserKWs());
-    BOOST_CHECK_EQUAL(false, parserKWs->keywordExists("FLASKE"));
+    RawParserKeywordsConstPtr parserKeywords(new RawParserKeywords());
+    BOOST_CHECK_EQUAL(false, parserKeywords->keywordExists("FLASKE"));
 }
 
 BOOST_AUTO_TEST_CASE(KeywordExists_KeywordPresent_ReturnsTrue) {
-    RawParserKWsConstPtr parserKWs(new RawParserKWs());
-    BOOST_CHECK_EQUAL(true, parserKWs->keywordExists("TITLE"));
+    RawParserKeywordsConstPtr parserKeywords(new RawParserKeywords());
+    BOOST_CHECK_EQUAL(true, parserKeywords->keywordExists("TITLE"));
 }
 
 BOOST_AUTO_TEST_CASE(GetFixedNumberOfRecords_KeywordNotPresent_ThrowsException) {
-    RawParserKWsConstPtr parserKWs(new RawParserKWs());
-    BOOST_CHECK_THROW(parserKWs->getFixedNumberOfRecords("FLASKE"), std::invalid_argument);
+    RawParserKeywordsConstPtr parserKeywords(new RawParserKeywords());
+    BOOST_CHECK_THROW(parserKeywords->getFixedNumberOfRecords("FLASKE"), std::invalid_argument);
 }
 
 BOOST_AUTO_TEST_CASE(GetFixedNumberOfRecords_OneRecord_ReturnsOne) {
-    RawParserKWsConstPtr parserKWs(new RawParserKWs());
-    BOOST_CHECK_EQUAL((unsigned) 1, parserKWs->getFixedNumberOfRecords("GRIDUNIT"));
+    RawParserKeywordsConstPtr parserKeywords(new RawParserKeywords());
+    BOOST_CHECK_EQUAL((unsigned) 1, parserKeywords->getFixedNumberOfRecords("GRIDUNIT"));
 }
 
 BOOST_AUTO_TEST_CASE(GetFixedNumberOfRecords_ZeroRecords_ReturnsZero) {
-    RawParserKWsConstPtr parserKWs(new RawParserKWs());
-    BOOST_CHECK_EQUAL((unsigned) 0, parserKWs->getFixedNumberOfRecords("METRIC"));
+    RawParserKeywordsConstPtr parserKeywords(new RawParserKeywords());
+    BOOST_CHECK_EQUAL((unsigned) 0, parserKeywords->getFixedNumberOfRecords("METRIC"));
 }