diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WSDParameters.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WSDParameters.java
index f0bb765..136d5f2 100644
--- a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WSDParameters.java
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WSDParameters.java
@@ -62,7 +62,7 @@
   }
 
   public WSDParameters() {
-    this.isCoarseSense = true;
+    this.isCoarseSense = false;
   }
 
   /**
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WSDisambiguator.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WSDisambiguator.java
index 9ef35d0..06451e5 100644
--- a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WSDisambiguator.java
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/WSDisambiguator.java
@@ -75,8 +75,11 @@
    * @param ambiguousTokenIndex
    * @return result as an array of WordNet IDs
    */
-  public abstract String[] disambiguate(String[] tokenizedContext,
-      String[] tokenTags, String[] lemmas, int ambiguousTokenIndex);
+  public String[] disambiguate(String[] tokenizedContext,
+      String[] tokenTags, String[] lemmas, int ambiguousTokenIndex){
+	  return disambiguate(new WSDSample(tokenizedContext, tokenTags, lemmas,
+		        ambiguousTokenIndex));
+  }
 
   /**
    * The disambiguation method for all the words in a Span
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/oscc/DefaultOSCCContextGenerator.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/oscc/DefaultOSCCContextGenerator.java
new file mode 100644
index 0000000..9584487
--- /dev/null
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/oscc/DefaultOSCCContextGenerator.java
@@ -0,0 +1,109 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package opennlp.tools.disambiguator.oscc;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+
+import net.sf.extjwnl.data.Synset;
+import opennlp.tools.disambiguator.WSDHelper;
+import opennlp.tools.disambiguator.WSDSample;
+import opennlp.tools.disambiguator.WordPOS;
+
+/**
+ * The default Context Generator of IMS
+ */
+public class DefaultOSCCContextGenerator implements OSCCContextGenerator {
+
+  public DefaultOSCCContextGenerator() {
+  }
+
+  public String[] extractSurroundingContextClusters(int index, String[] toks,
+      String[] tags, String[] lemmas, int windowSize) {
+
+    ArrayList<String> contextClusters = new ArrayList<String>();
+
+    for (int i = 0; i < toks.length; i++) {
+      if (lemmas != null) {
+
+        if (!WSDHelper.stopWords.contains(toks[i].toLowerCase())
+            && (index != i)) {
+
+          String lemma = lemmas[i].toLowerCase().replaceAll("[^a-z_]", "")
+              .trim();
+          
+          WordPOS word = new WordPOS(lemma, tags[i]);
+
+          // TODO check fix for "_" and null pointers
+          if (lemma.length() > 1 && !lemma.contains("_")) {
+            try{
+            ArrayList<Synset> synsets = word.getSynsets();
+            if (synsets!=null && synsets.size() > 0 ){
+              contextClusters.add(synsets.get(0).getOffset() + "");
+            }
+            }catch(NullPointerException ex)
+            {
+              //TODO tagger mistake add proper exception
+            }
+          }
+
+        }
+      }
+    }
+
+    return contextClusters.toArray(new String[contextClusters.size()]);
+
+  }
+
+  /**
+   * Get Context of a word To disambiguate
+   * 
+   * @return The OSCC context of the word to disambiguate
+   */
+  @Override
+  public String[] getContext(int index, String[] toks, String[] tags,
+      String[] lemmas, int windowSize) {
+
+    HashSet<String> surroundingContextClusters = new HashSet<>();
+    surroundingContextClusters.addAll(Arrays
+        .asList(extractSurroundingContextClusters(index, toks, tags, lemmas,
+            windowSize)));
+
+    String[] serializedFeatures = new String[surroundingContextClusters.size()];
+
+    int i = 0;
+
+    for (String feature : surroundingContextClusters) {
+      serializedFeatures[i] = "F" + i + "=" + feature;
+      i++;
+    }
+
+    return serializedFeatures;
+
+  }
+
+  public String[] getContext(WSDSample sample, int windowSize) {
+
+    return getContext(sample.getTargetPosition(), sample.getSentence(),
+        sample.getTags(), sample.getLemmas(), windowSize);
+  }
+
+}
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/oscc/OSCCContextGenerator.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/oscc/OSCCContextGenerator.java
new file mode 100644
index 0000000..9c0055f
--- /dev/null
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/oscc/OSCCContextGenerator.java
@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package opennlp.tools.disambiguator.oscc;
+
+import opennlp.tools.disambiguator.WSDSample;
+
+/**
+ * Interface for {@link OSCCME} context generators.
+ */
+public interface OSCCContextGenerator {
+
+  String[] getContext(int index, String[] toks, String[] tags, String[] lemmas,
+    int windowSize);
+
+  String[] getContext(WSDSample sample, int windowSize);
+}
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/oscc/OSCCFactory.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/oscc/OSCCFactory.java
new file mode 100644
index 0000000..e9cdecb
--- /dev/null
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/oscc/OSCCFactory.java
@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package opennlp.tools.disambiguator.oscc;
+
+import opennlp.tools.util.BaseToolFactory;
+import opennlp.tools.util.InvalidFormatException;
+import opennlp.tools.util.ext.ExtensionLoader;
+
+public class OSCCFactory extends BaseToolFactory {
+
+  /**
+   * Creates a {@link OSCCFactory} that provides the default implementation of
+   * the resources.
+   * */
+  public OSCCFactory() {
+
+  }
+
+  public static OSCCFactory create(String subclassName)
+      throws InvalidFormatException {
+    if (subclassName == null) {
+      // will create the default factory
+      return new OSCCFactory();
+    }
+    try {
+      OSCCFactory theFactory = ExtensionLoader.instantiateExtension(
+          OSCCFactory.class, subclassName);
+      return theFactory;
+    } catch (Exception e) {
+      String msg = "Could not instantiate the " + subclassName
+          + ". The initialization throw an exception.";
+      System.err.println(msg);
+      e.printStackTrace();
+      throw new InvalidFormatException(msg, e);
+    }
+  }
+
+  @Override
+  public void validateArtifactMap() throws InvalidFormatException {
+    // no additional artifacts
+  }
+
+  public OSCCContextGenerator getContextGenerator() {
+    return new DefaultOSCCContextGenerator();
+  }
+
+}
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/oscc/OSCCME.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/oscc/OSCCME.java
new file mode 100644
index 0000000..1bb3410
--- /dev/null
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/oscc/OSCCME.java
@@ -0,0 +1,208 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package opennlp.tools.disambiguator.oscc;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import junit.framework.Assert;
+import opennlp.tools.disambiguator.WSDHelper;
+import opennlp.tools.disambiguator.WSDSample;
+import opennlp.tools.disambiguator.WSDisambiguator;
+import opennlp.tools.disambiguator.mfs.MFS;
+import opennlp.tools.ml.EventTrainer;
+import opennlp.tools.ml.TrainerFactory;
+import opennlp.tools.ml.model.MaxentModel;
+import opennlp.tools.ml.model.Event;
+import opennlp.tools.util.InvalidFormatException;
+import opennlp.tools.util.ObjectStream;
+import opennlp.tools.util.ObjectStreamUtils;
+import opennlp.tools.util.TrainingParameters;
+
+public class OSCCME extends WSDisambiguator {
+
+  protected OSCCModel osccModel;
+
+  protected static OSCCContextGenerator cg = new DefaultOSCCContextGenerator();
+
+  public OSCCME(OSCCParameters params) {
+    this.params = params;
+  }
+
+  public OSCCME(OSCCModel model, OSCCParameters params) {
+    this.osccModel = osccModel;
+    this.params = params;
+
+    Assert.assertEquals(model.getWindowSize(), params.getWindowSize());
+  }
+
+  public void setModel(OSCCModel model) {
+    this.osccModel = model;
+  }
+
+  public void setParameters(OSCCParameters parameters) {
+    this.params = parameters;
+  }
+
+  public static OSCCModel train(String lang, ObjectStream<WSDSample> samples,
+      TrainingParameters mlParams, OSCCParameters osccParams,
+      OSCCFactory imsfactory) throws IOException {
+
+    HashMap<String, String> manifestInfoEntries = new HashMap<String, String>();
+
+    MaxentModel osccModel = null;
+
+    ArrayList<Event> events = new ArrayList<Event>();
+    ObjectStream<Event> es = null;
+
+    WSDSample sample = samples.read();
+    String wordTag = "";
+    if (sample != null) {
+      wordTag = sample.getTargetWordTag();
+      do {
+
+        String sense = sample.getSenseIDs().get(0);
+
+        String[] context = cg.getContext(sample, osccParams.windowSize);
+        Event ev = new Event(sense + "", context);
+
+        events.add(ev);
+
+        es = ObjectStreamUtils.createObjectStream(events);
+
+      } while ((sample = samples.read()) != null);
+    }
+
+    EventTrainer trainer = TrainerFactory.getEventTrainer(
+        mlParams.getSettings(), manifestInfoEntries);
+    osccModel = trainer.train(es);
+
+    return new OSCCModel(lang, wordTag, osccParams.windowSize, osccModel, manifestInfoEntries, imsfactory);
+  }
+
+
+  @Override
+  public String[] disambiguate(WSDSample sample) {
+    if (WSDHelper.isRelevantPOSTag(sample.getTargetTag())) {
+      String wordTag = sample.getTargetWordTag();
+
+      String trainingFile = ((OSCCParameters) this.getParams())
+          .getTrainingDataDirectory() + sample.getTargetWordTag();
+
+      if (osccModel == null
+          || !osccModel.getWordTag().equals(sample.getTargetWordTag())) {
+
+        File file = new File(trainingFile + ".ims.model");
+        if (file.exists() && !file.isDirectory()) {
+          try {
+            setModel(new OSCCModel(file));
+
+          } catch (InvalidFormatException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+          } catch (IOException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+          }
+
+          String outcome = "";
+
+          String[] context = cg.getContext(sample,
+              ((OSCCParameters) this.params).windowSize);
+
+          double[] outcomeProbs = osccModel.getOSCCMaxentModel().eval(context);
+          outcome = osccModel.getOSCCMaxentModel().getBestOutcome(outcomeProbs);
+
+          if (outcome != null && !outcome.equals("")) {
+
+            outcome = this.getParams().getSenseSource().name() + " "
+                + wordTag.split("\\.")[0] + "%" + outcome;
+
+            String[] s = { outcome };
+
+            return s;
+          } else {
+            MFS mfs = new MFS();
+            return mfs.disambiguate(wordTag);
+          }
+
+        } else {
+
+          MFS mfs = new MFS();
+          return mfs.disambiguate(wordTag);
+        }
+      } else {
+        String outcome = "";
+
+        String[] context = cg.getContext(sample,
+            ((OSCCParameters) this.params).windowSize);
+
+        double[] outcomeProbs = osccModel.getOSCCMaxentModel().eval(context);
+        outcome = osccModel.getOSCCMaxentModel().getBestOutcome(outcomeProbs);
+
+        if (outcome != null && !outcome.equals("")) {
+
+          outcome = this.getParams().getSenseSource().name() + " "
+              + wordTag.split("\\.")[0] + "%" + outcome;
+
+          String[] s = { outcome };
+
+          return s;
+        } else {
+
+          MFS mfs = new MFS();
+          return mfs.disambiguate(wordTag);
+        }
+      }
+    } else {
+
+      if (WSDHelper.getNonRelevWordsDef(sample.getTargetTag()) != null) {
+        String s = OSCCParameters.SenseSource.WSDHELPER.name() + " "
+            + sample.getTargetTag();
+        String[] sense = { s };
+        return sense;
+      } else {
+        return null;
+      }
+
+    }
+
+  }
+
+  /**
+   * The IMS disambiguation method for a single word
+   * 
+   * @param tokenizedContext
+   *          : the text containing the word to disambiguate
+   * @param tokenTags
+   *          : the tags corresponding to the context
+   * @param lemmas
+   *          : the lemmas of ALL the words in the context
+   * @param index
+   *          : the index of the word to disambiguate
+   * @return an array of the senses of the word to disambiguate
+   */
+  public String[] disambiguate(String[] tokenizedContext, String[] tokenTags,
+      String[] lemmas, int index) {
+    return disambiguate(new WSDSample(tokenizedContext, tokenTags, lemmas,
+        index));
+  }
+
+}
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/oscc/OSCCModel.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/oscc/OSCCModel.java
new file mode 100644
index 0000000..f3b28ab
--- /dev/null
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/oscc/OSCCModel.java
@@ -0,0 +1,155 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package opennlp.tools.disambiguator.oscc;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.Properties;
+import java.net.URL;
+
+import org.apache.commons.lang3.StringUtils;
+
+import opennlp.tools.cmdline.CmdLineUtil;
+import opennlp.tools.ml.model.AbstractModel;
+import opennlp.tools.ml.model.MaxentModel;
+import opennlp.tools.util.BaseToolFactory;
+import opennlp.tools.util.InvalidFormatException;
+import opennlp.tools.util.model.BaseModel;
+
+public class OSCCModel extends BaseModel {
+
+  private static final String COMPONENT_NAME = "OSCCME";
+  private static final String OSCC_MODEL_ENTRY_NAME = "OSCC.model";
+
+  private static final String WORDTAG = "wordtag";
+  private static final String WINSIZE = "winsize";
+  private static final String CONTEXTCLUSTERS = "contextclusters";
+
+  //private ArrayList<String> contextClusters = new ArrayList<String>();
+  private String wordTag;
+  private int windowSize;
+
+  /*public ArrayList<String> getContextClusters() {
+    return contextClusters;
+  }*/
+
+  public int getWindowSize() {
+    return windowSize;
+  }
+
+  public void setWindowSize(int windowSize) {
+    this.windowSize = windowSize;
+  }
+
+ /* public void setContextClusters(ArrayList<String> contextClusters) {
+    this.contextClusters = contextClusters;
+  }*/
+
+  public String getWordTag() {
+    return wordTag;
+  }
+
+  public void setWordTag(String wordTag) {
+    this.wordTag = wordTag;
+  }
+
+   public OSCCModel(String languageCode, String wordTag, int windowSize,
+   MaxentModel osccModel,
+      Map<String, String> manifestInfoEntries, OSCCFactory factory) {
+    super(COMPONENT_NAME, languageCode, manifestInfoEntries, factory);
+
+    artifactMap.put(OSCC_MODEL_ENTRY_NAME, osccModel);
+    this.setManifestProperty(WORDTAG, wordTag);
+    this.setManifestProperty(WINSIZE, windowSize + "");
+    
+//    this.setManifestProperty(CONTEXTCLUSTERS,
+//        StringUtils.join(contextClusters, ","));
+
+    //this.contextClusters = contextClusters;
+    checkArtifactMap();
+  }
+
+  public OSCCModel(String languageCode, String wordTag, int windowSize,
+      int ngram, MaxentModel osccModel, 
+      OSCCFactory factory) {
+    this(languageCode, wordTag, windowSize, osccModel,
+        null, factory);
+  }
+
+  public OSCCModel(InputStream in) throws IOException, InvalidFormatException {
+    super(COMPONENT_NAME, in);
+    updateAttributes();
+  }
+
+  public OSCCModel(File modelFile) throws IOException, InvalidFormatException {
+    super(COMPONENT_NAME, modelFile);
+    updateAttributes();
+  }
+
+  public OSCCModel(URL modelURL) throws IOException, InvalidFormatException {
+    super(COMPONENT_NAME, modelURL);
+    updateAttributes();
+  }
+
+  // path must include the word.tag i.e. : write.v
+  public boolean writeModel(String path) {
+    File outFile = new File(path + ".oscc.model");
+    CmdLineUtil.writeModel("oscc model", outFile, this);
+    return true;
+  }
+
+  @Override
+  protected void validateArtifactMap() throws InvalidFormatException {
+    super.validateArtifactMap();
+
+    if (!(artifactMap.get(OSCC_MODEL_ENTRY_NAME) instanceof AbstractModel)) {
+      throw new InvalidFormatException("OSCC model is incomplete!");
+    }
+  }
+
+  public MaxentModel getOSCCMaxentModel() {
+    if (artifactMap.get(OSCC_MODEL_ENTRY_NAME) instanceof MaxentModel) {
+      return (MaxentModel) artifactMap.get(OSCC_MODEL_ENTRY_NAME);
+    } else {
+      return null;
+    }
+  }
+
+  public void updateAttributes() {
+    Properties manifest = (Properties) artifactMap.get(MANIFEST_ENTRY);
+    //String contextClusters = (String) manifest.get(CONTEXTCLUSTERS);
+
+   /* this.contextClusters = new ArrayList(
+        Arrays.asList(contextClusters.split(",")));*/
+    this.wordTag = (String) manifest.get(WORDTAG);
+    this.windowSize = Integer.parseInt((String) manifest.get(WINSIZE));
+  }
+
+  @Override
+  protected Class<? extends BaseToolFactory> getDefaultFactory() {
+    return OSCCFactory.class;
+  }
+
+  public OSCCFactory getFactory() {
+    return (OSCCFactory) this.toolFactory;
+  }
+
+}
\ No newline at end of file
diff --git a/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/oscc/OSCCParameters.java b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/oscc/OSCCParameters.java
new file mode 100644
index 0000000..42a7742
--- /dev/null
+++ b/opennlp-wsd/src/main/java/opennlp/tools/disambiguator/oscc/OSCCParameters.java
@@ -0,0 +1,117 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package opennlp.tools.disambiguator.oscc;
+
+import java.io.File;
+
+import opennlp.tools.disambiguator.WSDParameters;
+
+/**
+ * This class contains the parameters for the OSCC approach as well as the
+ * directories containing the files used
+ */
+public class OSCCParameters extends WSDParameters {
+
+  protected String languageCode;
+  protected int windowSize;
+  protected String trainingDataDirectory;
+
+  protected static final int DFLT_WIN_SIZE = 3;
+  protected static final String DFLT_LANG_CODE = "En";
+  protected static final SenseSource DFLT_SOURCE = SenseSource.WORDNET;
+
+  /**
+   * This constructor takes only two parameters. The default language used is
+   * <i>English</i>
+   * 
+   * @param windowSize
+   *          the size of the window used for the extraction of the features
+   *          qualified of Surrounding Context Clusters
+   * 
+   * @param source
+   *          the source of the training data
+   */
+  public OSCCParameters(int windowSize, SenseSource senseSource,
+      String trainingDataDirectory) {
+    this.languageCode = DFLT_LANG_CODE;
+    this.windowSize = windowSize;
+    this.senseSource = senseSource;
+    this.trainingDataDirectory = trainingDataDirectory;
+    this.isCoarseSense = false;
+
+    File folder = new File(trainingDataDirectory);
+    if (!folder.exists())
+      folder.mkdirs();
+  }
+
+  public OSCCParameters(String trainingDataDirectory) {
+    this(DFLT_WIN_SIZE, DFLT_SOURCE, trainingDataDirectory);
+
+    File folder = new File(trainingDataDirectory);
+    if (!folder.exists())
+      folder.mkdirs();
+  }
+
+  public OSCCParameters() {
+    // TODO change the "" into null ??
+    this(DFLT_WIN_SIZE, DFLT_SOURCE, "");
+  }
+
+  public OSCCParameters(int windowSize) {
+    // TODO change the "" into null ??
+    this(windowSize, DFLT_SOURCE, "");
+  }
+
+  public String getLanguageCode() {
+    return languageCode;
+  }
+
+  public void setLanguageCode(String languageCode) {
+    this.languageCode = languageCode;
+  }
+
+  public int getWindowSize() {
+    return windowSize;
+  }
+
+  public void setWindowSize(int windowSize) {
+    this.windowSize = windowSize;
+  }
+
+  public OSCCContextGenerator createContextGenerator() {
+
+    return new DefaultOSCCContextGenerator();
+  }
+
+  public String getTrainingDataDirectory() {
+    return trainingDataDirectory;
+  }
+
+  public void setTrainingDataDirectory(String trainingDataDirectory) {
+    this.trainingDataDirectory = trainingDataDirectory;
+  }
+
+  @Override
+  public boolean isValid() {
+    // TODO make validity check
+    return true;
+  }
+
+}
diff --git a/opennlp-wsd/src/test/java/opennlp/tools/disambiguator/OSCCEvaluatorTest.java b/opennlp-wsd/src/test/java/opennlp/tools/disambiguator/OSCCEvaluatorTest.java
new file mode 100644
index 0000000..c9723fa
--- /dev/null
+++ b/opennlp-wsd/src/test/java/opennlp/tools/disambiguator/OSCCEvaluatorTest.java
@@ -0,0 +1,75 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package opennlp.tools.disambiguator;
+
+import java.util.ArrayList;
+
+import opennlp.tools.disambiguator.datareader.SensevalReader;
+import opennlp.tools.disambiguator.oscc.OSCCME;
+import opennlp.tools.disambiguator.oscc.OSCCParameters;
+
+import org.junit.Test;
+
+public class OSCCEvaluatorTest {
+
+  static SensevalReader seReader = new SensevalReader();
+
+  @Test
+  public static void main(String[] args) {
+    
+    
+    WSDHelper.print("Evaluation Started");
+    
+    // TODO write unit test
+    String modelsDir = "src\\test\\resources\\models\\";
+    WSDHelper.loadTokenizer(modelsDir + "en-token.bin");
+    WSDHelper.loadLemmatizer(modelsDir + "en-lemmatizer.dict");
+    WSDHelper.loadTagger(modelsDir + "en-pos-maxent.bin");
+
+    OSCCParameters OSCCParams = new OSCCParameters("");
+    OSCCME oscc = new OSCCME(OSCCParams);
+
+    ArrayList<String> words = seReader.getSensevalWords();
+
+    for (String word : words) {
+      WSDEvaluator evaluator = new WSDEvaluator(oscc);
+
+      // don't take verbs because they are not from WordNet
+      if (!word.split("\\.")[1].equals("v")) {
+
+        ArrayList<WSDSample> instances = seReader.getSensevalData(word);
+        if (instances != null) {
+          WSDHelper.print("------------------" + word + "------------------");
+          for (WSDSample instance : instances) {
+            if (instance.getSenseIDs() != null
+                && !instance.getSenseIDs().get(0).equals("null")) {
+              evaluator.evaluateSample(instance);
+            }
+          }
+          WSDHelper.print(evaluator.toString());
+        } else {
+          WSDHelper.print("null instances");
+        }
+      }
+
+    }
+
+  }
+}
diff --git a/opennlp-wsd/src/test/java/opennlp/tools/disambiguator/OSCCTester.java b/opennlp-wsd/src/test/java/opennlp/tools/disambiguator/OSCCTester.java
new file mode 100644
index 0000000..ec6377d
--- /dev/null
+++ b/opennlp-wsd/src/test/java/opennlp/tools/disambiguator/OSCCTester.java
@@ -0,0 +1,116 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package opennlp.tools.disambiguator;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import opennlp.tools.disambiguator.datareader.SemcorReaderExtended;
+import opennlp.tools.disambiguator.oscc.OSCCFactory;
+import opennlp.tools.disambiguator.oscc.OSCCME;
+import opennlp.tools.disambiguator.oscc.OSCCModel;
+import opennlp.tools.disambiguator.oscc.OSCCParameters;
+import opennlp.tools.util.ObjectStream;
+import opennlp.tools.util.Span;
+import opennlp.tools.util.TrainingParameters;
+
+public class OSCCTester {
+
+  public static void main(String[] args) {
+
+    SemcorReaderExtended sr = new SemcorReaderExtended();
+
+    String modelsDir = "src\\test\\resources\\models\\";
+    WSDHelper.loadTokenizer(modelsDir + "en-token.bin");
+    WSDHelper.loadLemmatizer(modelsDir + "en-lemmatizer.dict");
+    WSDHelper.loadTagger(modelsDir + "en-pos-maxent.bin");
+
+    String test = "write.v";
+    TrainingParameters trainingParams = new TrainingParameters();
+    OSCCParameters OSCCParams = new OSCCParameters("");
+    OSCCFactory OSCCFactory = new OSCCFactory();
+
+    ObjectStream<WSDSample> sampleStream = sr.getSemcorDataStream(test);
+
+    OSCCModel model = null;
+    OSCCModel readModel = null;
+    try {
+      model = OSCCME.train("en", sampleStream, trainingParams, OSCCParams,
+          OSCCFactory);
+      model.writeModel(test);
+      File outFile = new File(test + ".OSCC.model");
+      readModel = new OSCCModel(outFile);
+
+    } catch (IOException e1) {
+      // TODO Auto-generated catch block
+      e1.printStackTrace();
+    }
+    OSCCME OSCC = new OSCCME(readModel, OSCCParams);
+
+    /**
+     * This is how to make the context for one-word-disambiguation using OSCC
+     */
+    String test1 = "We need to discuss important topic, please write to me soon.";
+    String[] sentence1 = WSDHelper.getTokenizer().tokenize(test1);
+    String[] tags1 = WSDHelper.getTagger().tag(sentence1);
+    List<String> tempLemmas1 = new ArrayList<String>();
+    for (int i = 0; i < sentence1.length; i++) {
+      String lemma = WSDHelper.getLemmatizer()
+          .lemmatize(sentence1[i], tags1[i]);
+      tempLemmas1.add(lemma);
+    }
+    String[] lemmas1 = tempLemmas1.toArray(new String[tempLemmas1.size()]);
+
+    // output
+    String[] senses1 = OSCC.disambiguate(sentence1, tags1, lemmas1, 8);
+    System.out.print(lemmas1[8] + " :\t");
+    WSDHelper.print(senses1);
+    WSDHelper.print("*****************************");
+
+    /**
+     * This is how to make the context for disambiguation of span of words
+     */
+    String test2 = "The component was highly radioactive to the point that"
+        + " it has been activated the second it touched water";
+    String[] sentence2 = WSDHelper.getTokenizer().tokenize(test2);
+    String[] tags2 = WSDHelper.getTagger().tag(sentence2);
+    List<String> tempLemmas2 = new ArrayList<String>();
+    for (int i = 0; i < sentence2.length; i++) {
+      String lemma = WSDHelper.getLemmatizer()
+          .lemmatize(sentence2[i], tags2[i]);
+      tempLemmas2.add(lemma);
+    }
+    String[] lemmas2 = tempLemmas2.toArray(new String[tempLemmas2.size()]);
+    Span span = new Span(3, 7);
+
+    // output
+    List<String[]> senses2 = OSCC.disambiguate(sentence2, tags2, lemmas2, span);
+    for (int i = span.getStart(); i < span.getEnd() + 1; i++) {
+      String[] senses = senses2.get(i - span.getStart());
+      System.out.print(lemmas2[i] + " :\t");
+      WSDHelper.print(senses);
+      WSDHelper.print("----------");
+    }
+
+    WSDHelper.print("*****************************");
+  }
+}
\ No newline at end of file
diff --git a/opennlp-wsd/src/test/java/opennlp/tools/disambiguator/Tester.java b/opennlp-wsd/src/test/java/opennlp/tools/disambiguator/Tester.java
index 866fc4c..3adcd7d 100644
--- a/opennlp-wsd/src/test/java/opennlp/tools/disambiguator/Tester.java
+++ b/opennlp-wsd/src/test/java/opennlp/tools/disambiguator/Tester.java
@@ -1,39 +1,36 @@
 package opennlp.tools.disambiguator;
 
-import java.util.ArrayList;
-import java.util.List;
 
-import opennlp.tools.disambiguator.ims.IMS;
 
 public class Tester {
 
   public static void main(String[] args) {
-
-    String modelsDir = "src\\test\\resources\\models\\";
-    WSDHelper.loadTokenizer(modelsDir + "en-token.bin");
-    WSDHelper.loadLemmatizer(modelsDir + "en-lemmatizer.dict");
-    WSDHelper.loadTagger(modelsDir + "en-pos-maxent.bin");
-
-    IMS ims = new IMS();
-
-    String test3 = "The summer is almost over and I haven't been to the beach even once";
-    String[] sentence3 = WSDHelper.getTokenizer().tokenize(test3);
-    String[] tags3 = WSDHelper.getTagger().tag(sentence3);
-    List<String> tempLemmas3 = new ArrayList<String>();
-    for (int i = 0; i < sentence3.length; i++) {
-      String lemma = WSDHelper.getLemmatizer()
-          .lemmatize(sentence3[i], tags3[i]);
-      tempLemmas3.add(lemma);
-    }
-    String[] lemmas3 = tempLemmas3.toArray(new String[tempLemmas3.size()]);
-
-    // output
-    List<String[]> senses3 = ims.disambiguate(sentence3, tags3, lemmas3);
-    for (int i = 0; i < sentence3.length; i++) {
-      System.out.print(sentence3[i] + " : ");
-      WSDHelper.printResults(ims, senses3.get(i));
-      WSDHelper.print("----------");
-    }
+//
+//    String modelsDir = "src\\test\\resources\\models\\";
+//    WSDHelper.loadTokenizer(modelsDir + "en-token.bin");
+//    WSDHelper.loadLemmatizer(modelsDir + "en-lemmatizer.dict");
+//    WSDHelper.loadTagger(modelsDir + "en-pos-maxent.bin");
+//
+//    IMSME ims = new IMSME();
+//
+//    String test3 = "The summer is almost over and I haven't been to the beach even once";
+//    String[] sentence3 = WSDHelper.getTokenizer().tokenize(test3);
+//    String[] tags3 = WSDHelper.getTagger().tag(sentence3);
+//    List<String> tempLemmas3 = new ArrayList<String>();
+//    for (int i = 0; i < sentence3.length; i++) {
+//      String lemma = WSDHelper.getLemmatizer()
+//          .lemmatize(sentence3[i], tags3[i]);
+//      tempLemmas3.add(lemma);
+//    }
+//    String[] lemmas3 = tempLemmas3.toArray(new String[tempLemmas3.size()]);
+//
+//    // output
+//    List<String[]> senses3 = ims.disambiguate(sentence3, tags3, lemmas3);
+//    for (int i = 0; i < sentence3.length; i++) {
+//      System.out.print(sentence3[i] + " : ");
+//      WSDHelper.printResults(ims, senses3.get(i));
+//      WSDHelper.print("----------");
+//    }
 
   }
 }
\ No newline at end of file