Get the map linking the symbol of the element and number maximum of occurrence.
For the analysis with the Wisley database and mass lower than 1000 Da.

@return The HashMap of the symbol linked with the maximum occurrence
962328
private HashMap<String, Integer> getWisley_1000() {
        HashMap<String, Integer> map = new HashMap<String, Integer>();

        map.put("C", 78);
        map.put("H", 126);
        map.put("N", 20);
        map.put("O", 27);
        map.put("P", 9);
        map.put("S", 14);
        map.put("F", 34);
        map.put("Cl", 12);
        map.put("Br", 8);
        map.put("Si", 14);

        return map;
    }
295037
public Map<String, MBeanAttributeInfo> getAttributeMetadata() {

        MBeanAttributeInfo[] attributeList = mBeanInfo.getAttributes();

        Map<String, MBeanAttributeInfo> attributeMap = new TreeMap<String, MBeanAttributeInfo>();
        for (MBeanAttributeInfo attribute: attributeList) {
            attributeMap.put(attribute.getName(), attribute);
        }
        return attributeMap;
    }
1093963
public static Map<String, IAminoAcid> getHashMapBySingleCharCode() {
        IAminoAcid[] monomers = createAAs();
        HashMap<String, IAminoAcid> map = new HashMap<String, IAminoAcid>();
        for (int i = 0; i < monomers.length; i++) {
            map.put((String) monomers[i].getProperty(RESIDUE_NAME_SHORT), monomers[i]);
        }
        return map;
    }
928792
private HashMap<String, Integer> getDNP_3000() {
        HashMap<String, Integer> map = new HashMap<String, Integer>();

        map.put("C", 162);
        map.put("H", 208);
        map.put("N", 48);
        map.put("O", 78);
        map.put("P", 6);
        map.put("S", 9);
        map.put("F", 16);
        map.put("Cl", 11);
        map.put("Br", 8);

        return map;
    }
1332483
public Map<Integer, String> asMap() {
		initializePosition();
		final Map<Integer, String> results = Maps.newHashMap();
		
		Mapper.from(positions.get()).entryLoop(new Decisional<Map.Entry<Integer, Pair<Integer,Integer>>>() {

			@Override protected void decision(Entry<Integer, Pair<Integer, Integer>> input) {
				results.put(input.getKey(), doSubstring(input.getValue()));
			}
		});
		
		return results;
	}
536498
@Pure
	public Map<BusItineraryHalt, Pair<Integer, Double>> getBusHaltBinding() {
		final Comparator<BusItineraryHalt> comp = (elt1, elt2) -> {
			if (elt1 == elt2) {
				return 0;
			}
			if (elt1 == null) {
				return -1;
			}
			if (elt2 == null) {
				return 1;
			}
			return elt1.getName().compareTo(elt2.getName());
		};
		final Map<BusItineraryHalt, Pair<Integer, Double>> haltBinding = new TreeMap<>(comp);
		for (final BusItineraryHalt halt : busHalts()) {
			haltBinding.put(halt, new Pair<>(
					halt.getRoadSegmentIndex(),
					halt.getPositionOnSegment()));
		}
		return haltBinding;
	}
639064
public Map<String, Node> getTemplateNodeToMatchMap() {
    Map<String, Node> map = new HashMap<>(stringLiteralMatches);

    for (int i = 0; i < templateParams.size(); i++) {
      String name = templateParams.get(i);
      map.put(name, paramNodeMatches.get(i));
    }

    for (int i = 0; i < templateLocals.size(); i++) {
      String name = templateLocals.get(i);
      map.put(name, IR.name(localVarMatches.get(i)));
    }

    return map;
  }
912674
public Map<String, TemplateTokenInfo> getTokensAsMap() {
        HashMap<String, TemplateTokenInfo> tokens = new HashMap<String, TemplateTokenInfo>();
        for (TemplateTokenInfo tokenInfo : tokenInfos)
            tokens.put(tokenInfo.getName(), tokenInfo);
        return Collections.unmodifiableMap(tokens);
    }
1264266
public HashMap<String, String> getData() {
        HashMap<String, String> hash = new HashMap<>();
        HashMap p = new HashMap<String, String>();
        int nameskip = getName().length() + 1;

        extractValues(hash);

        hash.forEach((key, value) -> {
            p.put(key.substring(nameskip), value);
        });

        return p;
    }
1154277
protected Map<String, String> getElementAttributes() {
        // Preserve order of attributes
        Map<String, String> attrs = new HashMap<>();

        if (this.getAlphabet() != null) {
            attrs.put("alphabet", this.getAlphabet().toString());
        }
        if (this.getPh() != null) {
            attrs.put("ph", this.getPh());
        }

        return attrs;
    }
456069
@Nonnull
    public BiMap<String, String> getOutputMapper() {
        final BiMap<String, String> outputMapper = this.processor.getOutputMapperBiMap();
        if (outputMapper == null) {
            return HashBiMap.create();
        }
        return outputMapper;
    }
259329
public Map<Integer, String> getPageLinks() {

        Map<Integer, String> links = new TreeMap<Integer, String>();
        if (m_pageCount <= 1) {
            return links;
        }
        int startIndex, endIndex;
        String link = m_cms.getRequestContext().getUri() + m_parameters.toQueryString() + "&searchPage=";
        if (getDisplayPages() < 1) {
            // number of displayed pages not limited, build a map with all available page links
            startIndex = 1;
            endIndex = m_pageCount;
        } else {
            // limited number of displayed pages, calculate page range
            int currentPage = getSearchPage();
            int countBeforeCurrent = getDisplayPages() / 2;
            int countAfterCurrent;
            if ((currentPage - countBeforeCurrent) < 1) {
                // set count before to number of available pages
                countBeforeCurrent = currentPage - 1;
            }
            // set count after to number of remaining pages (- 1 for current page)
            countAfterCurrent = getDisplayPages() - countBeforeCurrent - 1;
            // calculate start and end index
            startIndex = currentPage - countBeforeCurrent;
            endIndex = currentPage + countAfterCurrent;
            // check end index
            if (endIndex > m_pageCount) {
                int delta = endIndex - m_pageCount;
                // decrease start index with delta to get the right number of displayed pages
                startIndex -= delta;
                // check start index to avoid values < 1
                if (startIndex < 1) {
                    startIndex = 1;
                }
                endIndex = m_pageCount;
            }
        }

        // build the sorted tree map of page links
        for (int i = startIndex; i <= endIndex; i++) {
            links.put(new Integer(i), (link + i));
        }
        return links;
    }
910821
public Map<String, Object> toRepresentation() {
        Map<String, Object> representation = new HashMap<>();
        if (templated()) {
            representation.put("href-template", hrefTemplate);
            representation.put("href-vars", hrefVars());
        } else {
            representation.put("href", href);
        }
        if (hints != null) {
            Map<String, Object> hintsRepresentation = hints.toRepresentation();
            if (!hintsRepresentation.isEmpty()) {
                representation.put("hints", hintsRepresentation);
            }
        }
        return representation;
    }
648013
public Map<Any2<Integer, String>, Any3<Boolean, Integer, String>> getRawMap() {
        return unmodifiableMap(data);
    }
415168
private Map<String,Object> getMap()
    {
        if (m_data == null)
            m_data = new HashMap<String,Object>();
        return (Map<String, Object>)m_data;
    }
38122
private HashMap<String, Integer> getDNP_2000() {
        HashMap<String, Integer> map = new HashMap<String, Integer>();

        map.put("C", 115);
        map.put("H", 236);
        map.put("N", 32);
        map.put("O", 63);
        map.put("P", 6);
        map.put("S", 8);
        map.put("F", 16);
        map.put("Cl", 11);
        map.put("Br", 8);

        return map;
    }
239516
@SuppressWarnings("unchecked")
    public Map toMap() {
        HashMap map = new HashMap();
        map.put("code", code);
        map.put("message", message);
        if (data != null)
            map.put("data", data);
        return map;
    }