Example usage for com.google.common.collect Multimaps index

List of usage examples for com.google.common.collect Multimaps index

Introduction

In this page you can find the example usage for com.google.common.collect Multimaps index.

Prototype

public static <K, V> ImmutableListMultimap<K, V> index(Iterator<V> values, Function<? super V, K> keyFunction) 

Source Link

Document

Creates an index ImmutableListMultimap that contains the results of applying a specified function to each item in an Iterator of values.

Usage

From source file:org.caleydo.view.domino.api.model.typed.TypedSets.java

/**
 * compress the sets such that one idtype occurs only ones
 *
 * @param sets//from  w  ww .java 2  s.c o  m
 * @return
 */
private static TypedSet[] compress(TypedSet[] sets, boolean union) {
    ListMultimap<IDType, TypedSet> index = Multimaps.index(Arrays.asList(sets), TypedCollections.TO_IDTYPE);

    if (index.keySet().size() == sets.length) // nothing to compress
        return sets;
    TypedSet[] new_ = new TypedSet[index.keySet().size()];
    int i = 0;
    for (IDType idType : index.keySet()) {
        List<TypedSet> same = index.get(idType);
        new_[i++] = union ? TypedSet.union(same) : TypedSet.intersection(same);
    }
    return new_;
}

From source file:eu.itesla_project.iidm.ddb.psse_imp_exp.DdbDyrLoader.java

/**
 * @param dyrPath/*from   w ww.  j  a  v  a2  s. com*/
 * @param cimPsseIdsMap
 * @param psseVersion
 * @param config
 * @param deleteData
 * @throws IOException
 */
public void load(Path dyrPath, Map<String, String> cimPsseIdsMap, String psseVersion, DdbConfig config,
        boolean deleteData) throws IOException {
    writer = new FileWriter(new File("DdbDyrLoader.log"));

    log.info("Loading {}", dyrPath);
    List<PsseRegister> aList = null;
    aList = PsseDyrParser.parseFile(dyrPath.toFile());

    Set<String> mtcSet = new LinkedHashSet<>();
    ArrayList<String> ptcList = new ArrayList<>();
    ArrayList<String> internalsList = new ArrayList<>();
    ArrayList<String> equipmentsList = new ArrayList<>();

    //partitions the list of PsseRegisters by  dyrId=r.getBusNum() + "_" + r.getId()
    //NOTE: this dyrId is the default internal id used in resolving mappings iidm ID - psse ID
    Multimap<String, PsseRegister> groupsByBus = Multimaps.index(aList, new Function<PsseRegister, String>() {
        @Override
        public String apply(final PsseRegister s) {
            return s.getBusNum() + "_" + s.getId();
        }
    });

    try (EjbClientCtx cx = newEjbClientEcx(config)) {
        DDBManager ddbmanager = cx.connectEjb(DDBMANAGERJNDINAME);
        SimulatorInst simulator = getOrCreatePsseSimulatorInst(ddbmanager, psseVersion);

        //iterate over the (dyrId=r.getBusNum() + "_" + r.getId()) indexed collection
        int counter = 0;
        for (String dyrId : groupsByBus.keySet()) {
            counter = counter + 1;
            //get iddmId from mapping (read from file)
            String iidmId = cimPsseIdsMap.get(dyrId);
            if (iidmId == null) {
                //throw new RuntimeException("  No mapping found for ", dyrId);
                log.warn("No mapping found for bus_id {}", dyrId);
                continue;
            }

            //for a given dyrId, partitions the sublist of related registers in equipment and internals
            ListMultimap<String, PsseRegister> groupByBusByType = Multimaps.index(groupsByBus.get(dyrId),
                    new Function<PsseRegister, String>() {
                        @Override
                        public String apply(final PsseRegister s) {
                            return ((PsseRegisterType.isEquipment(s) == true) ? "equipment" : "internal");
                        }
                    });
            // check the assumption that for a given dyrId there must be just one machine: if not , ERROR
            if (groupByBusByType.get("equipment").size() != 1) {
                throw new RuntimeException("must be 1 machine in " + dyrId);
            }

            //get the machine register and the other components registers
            PsseRegister equipmentReg = (PsseRegister) groupByBusByType.get("equipment").get(0);
            List<PsseRegister> internalsRegs = groupByBusByType.get("internal");

            //logs some info about this group machine-regulators
            List<String> modelsNamesList = FluentIterable.from(internalsRegs)
                    .transform(new Function<PsseRegister, String>() {
                        public String apply(PsseRegister f) {
                            String rName = f.getModel();
                            return rName;
                        }
                    }).toList();
            log.info("bus_id:{}, generator model: {}; regulators models: {}", dyrId, equipmentReg.getModel(),
                    modelsNamesList);

            //create the ddb data
            String equipmentId = iidmId;
            String equipmentMtcId = MTC_PREFIX_NAME + equipmentReg.getModel();
            String equipmentPcId = dyrId;

            //step a:  process Equipment
            //                log.info("Equipment: iidmId {}", equipmentId);
            //                log.info("  MTC id: {}", equipmentMtcId);
            //                log.info("  PC id: {}", equipmentPcId);
            //                for (String parName : equipmentReg.parameters.keySet()) {
            //                    log.info("    {}={}", parName, equipmentReg.parameters.get(parName));
            //                }

            ModelTemplateContainer eqMtc = ddbmanager.findModelTemplateContainer(equipmentMtcId);
            if (eqMtc == null) {
                log.debug("-- creating MTC " + equipmentMtcId);
                eqMtc = new ModelTemplateContainer(equipmentMtcId, "");
                ModelTemplate mt = new ModelTemplate(simulator, equipmentReg.getModel(), "");
                // must be decided what to put in data attribute; here we put
                // again the typename, as in the original example circulated
                mt.setData("data", DdbDyrLoader.stringAsByteArrayUTF8(equipmentReg.getModel()));
                eqMtc.getModelTemplates().add(mt);
                eqMtc = ddbmanager.save(eqMtc);

            } else {
                log.info("-- MTC " + equipmentMtcId + " already defined, id: " + eqMtc.getId());
            }
            mtcSet.add(equipmentMtcId);
            ParametersContainer eqPc = ddbmanager.findParametersContainer(equipmentPcId);
            if (eqPc == null) {
                log.info("-- creating PC " + equipmentPcId + " plus parameters.");
                eqPc = new ParametersContainer(equipmentPcId);
                Parameters pars = new Parameters(simulator);
                for (String parName : equipmentReg.parameters.keySet()) {
                    //tokenize parname (separator, comma char) to handle cases where one psse var leads to a couple of parameters (with the same value)
                    //eg. "Xppd,Xppq" in GENROU
                    List<String> splitParamNames = Arrays.asList(parName.trim().split("\\s*,\\s*"));
                    for (String spName : splitParamNames) {
                        log.info("    {}={}", spName, equipmentReg.parameters.get(parName));
                        pars.addParameter(new ParameterFloat(spName, equipmentReg.parameters.get(parName)));
                    }
                }
                eqPc.getParameters().add(pars);
                eqPc = ddbmanager.save(eqPc);
            } else {
                log.info("-- PC " + equipmentPcId + " already defined, id: " + eqPc.getId());
            }
            ptcList.add(equipmentPcId);

            Equipment equipment = ddbmanager.findEquipment(equipmentId);
            if (equipment == null) {
                log.info("-- creating Equipment " + equipmentId + "; psse name is: " + dyrId);
                equipment = new Equipment(equipmentId);
                equipment.setModelContainer(eqMtc);
                equipment.setParametersContainer(eqPc);
                equipment = ddbmanager.save(equipment);
            } else {
                log.info("-- Equipment  " + equipmentId + " already defined, id: " + equipment.getId());
            }
            equipmentReg.setId(equipmentId);
            equipmentsList.add(equipmentId);

            //create a connection schema, if needed
            ConnectionSchema cs = ddbmanager.findConnectionSchema(equipmentId, null);
            if (cs == null) {
                log.info("- creating conn. schema with cimId " + equipmentId);
                cs = new ConnectionSchema(equipmentId, null);
                cs = ddbmanager.save(cs);
            } else {
                log.info("- conn. schema with cimId " + equipmentId
                        + ", already exists! currently defined connections: " + cs.getConnections());
            }

            writer.write("Equipment: " + equipmentReg.getModel() + "\n");

            //step b:  process Internals
            boolean hasHygov = false;
            boolean hasPss2a = false;
            boolean hasTgov1 = false;
            boolean hasIeesgo = false;
            for (PsseRegister regulatorRegister : internalsRegs) {
                if (regulatorRegister.getModel().endsWith("HYGOV")) {
                    hasHygov = true;
                }
                if (regulatorRegister.getModel().endsWith("PSS2A")) {
                    hasPss2a = true;
                }
                if (regulatorRegister.getModel().endsWith("TGOV1")) {
                    hasTgov1 = true;
                }
                if (regulatorRegister.getModel().endsWith("IEESGO")) {
                    hasIeesgo = true;
                }

                String internalId = iidmId + "_" + regulatorRegister.getModel();
                String internalMtcId = MTC_PREFIX_NAME + regulatorRegister.getModel();
                String internalPcId = PC_PREFIX_NAME + iidmId + "_" + regulatorRegister.getModel();

                //                    log.info(" Internal: id {}", internalId);
                //                    log.info("   MTC id: {}", internalMtcId);
                //                    log.info("   PC id: {}", internalPcId);
                //                    for (String parName : regulatorRegister.parameters.keySet()) {
                //                        log.info("     {}={}", parName, regulatorRegister.parameters.get(parName));
                //                    }

                ModelTemplateContainer internalMtc = ddbmanager.findModelTemplateContainer(internalMtcId);
                if (internalMtc == null) {
                    log.info("-- creating MTC " + internalMtcId);
                    internalMtc = new ModelTemplateContainer(internalMtcId, "");
                    ModelTemplate mt = new ModelTemplate(simulator, regulatorRegister.getModel(), "");
                    // must be decided what to put in data attribute; here we put
                    // again the typename, as in the original example circulated
                    mt.setData("data", DdbDyrLoader.stringAsByteArrayUTF8(regulatorRegister.getModel()));
                    internalMtc.getModelTemplates().add(mt);
                    internalMtc = ddbmanager.save(internalMtc);

                } else {
                    log.info("-- MTC " + internalMtcId + " already defined, id: " + internalMtc.getId());
                }
                mtcSet.add(internalMtcId);
                ParametersContainer intPc = ddbmanager.findParametersContainer(internalPcId);
                if (intPc == null) {
                    log.info("-- creating PC " + internalPcId + " plus parameters.");
                    intPc = new ParametersContainer(internalPcId);
                    Parameters pars = new Parameters(simulator);
                    for (String parName : regulatorRegister.parameters.keySet()) {
                        List<String> splitParamNames = Arrays.asList(parName.trim().split("\\s*,\\s*"));
                        for (String spName : splitParamNames) {
                            log.info("    {}={}", spName, regulatorRegister.parameters.get(parName));
                            pars.addParameter(
                                    new ParameterFloat(spName, regulatorRegister.parameters.get(parName)));
                        }
                    }
                    intPc.getParameters().add(pars);
                    intPc = ddbmanager.save(intPc);
                } else {
                    log.info("-- PC " + internalPcId + " already defined, id: " + intPc.getId());
                }
                ptcList.add(internalPcId);
                Internal internal = ddbmanager.findInternal(internalId);
                if (internal == null) {
                    log.info("-- Creating Internal " + internalId);
                    internal = new Internal(internalId);
                    internal.setModelContainer(internalMtc);
                    internal.setParametersContainer(intPc);
                    internal = ddbmanager.save(internal);
                } else {
                    log.info("-- Internal  " + internalId + " already defined, id: " + internal.getId());
                }
                regulatorRegister.setId(internalId);
                internalsList.add(internalId);
            }

            //Connection schemas
            List<Connection> clist = cs.getConnections();
            // first create equipment-regulators connections
            for (PsseRegister regulatorRegister : internalsRegs) {
                LinkedHashSet<String> sharedPins = PsseRegisterFactory.intersectPinsSets(equipmentReg,
                        regulatorRegister);
                if (sharedPins.size() > 0) {
                    log.info("-- connection eq-int {}-{}  on pins {}", equipmentReg.getModel(),
                            regulatorRegister.getModel(), sharedPins);
                    for (String pinName : sharedPins) {
                        log.info("----  {} {} {} {} {} {} {}", "inside", "equipment", equipmentId, pinName,
                                pinName, "internal", regulatorRegister.getId());
                        Connection newC = new Connection(equipmentId, Connection.EQUIPMENT_TYPE,
                                regulatorRegister.getId(), Connection.INTERNAL_TYPE, pinName, pinName,
                                Connection.INSIDE_CONNECTION);
                        if (!(clist.contains(newC))) {
                            log.info("----- creating connection " + newC);
                            log.info("------- clist size" + clist.size());
                            clist.add(newC);
                        } else {
                            log.info("----- connection already exist: " + newC);
                        }
                    }
                } else {
                    log.info("-- connection eq-int {}-{} does not exist: no shared pins names",
                            equipmentReg.getModel(), regulatorRegister.getModel());
                }
                //possibly create connections  equipment-regulator when pin names are different
                //here is hardcoded the one and only case known, so far: ETERM(equipment), ECOMP(all regulators thaqt have this pin)
                //There is also the case ETERM (equipment) and V_CT (IEEEST)
                String eqPin = "ETERM";
                String regPin = "ECOMP";
                if ((equipmentReg.pins.contains(eqPin) && (regulatorRegister.pins.contains(regPin)))) {
                    log.info("--* connection eq-int {}-{}  on pins {},{}", equipmentReg.getModel(),
                            regulatorRegister.getModel(), eqPin, regPin);
                    log.info("----*  {} {} {} {} {} {} {}", "inside", "equipment", equipmentId, eqPin, regPin,
                            "internal", regulatorRegister.getId());
                    Connection newC = new Connection(equipmentId, Connection.EQUIPMENT_TYPE,
                            regulatorRegister.getId(), Connection.INTERNAL_TYPE, eqPin, regPin,
                            Connection.INSIDE_CONNECTION);
                    if (!(clist.contains(newC))) {
                        log.info("----- creating connection " + newC);
                        log.info("------- clist size" + clist.size());
                        clist.add(newC);
                    } else {
                        log.info("----- connection already exist: " + newC);
                    }
                }

                regPin = "V_CT";
                if ((equipmentReg.pins.contains(eqPin)
                        && (regulatorRegister.getModel().equalsIgnoreCase("IEEEST")))) {
                    log.info("--* connection eq-int {}-{}  on pins {},{}", equipmentReg.getModel(),
                            regulatorRegister.getModel(), eqPin, regPin);
                    log.info("----*  {} {} {} {} {} {} {}", "inside", "equipment", equipmentId, eqPin, regPin,
                            "internal", regulatorRegister.getId());
                    Connection newC = new Connection(equipmentId, Connection.EQUIPMENT_TYPE,
                            regulatorRegister.getId(), Connection.INTERNAL_TYPE, eqPin, regPin,
                            Connection.INSIDE_CONNECTION);
                    if (!(clist.contains(newC))) {
                        log.info("----- creating connection " + newC);
                        log.info("------- clist size" + clist.size());
                        clist.add(newC);
                    } else {
                        log.info("----- connection already exist: " + newC);
                    }
                }

                regPin = "VT";
                if (equipmentReg.pins.contains(eqPin) && regulatorRegister.Model.equalsIgnoreCase("ESST1A")) {
                    log.info("--* connection eq-int {}-{}  on pins {},{}", equipmentReg.getModel(),
                            regulatorRegister.getModel(), eqPin, regPin);
                    log.info("----*  {} {} {} {} {} {} {}", "inside", "equipment", equipmentId, eqPin, regPin,
                            "internal", regulatorRegister.getId());
                    Connection newC = new Connection(equipmentId, Connection.EQUIPMENT_TYPE,
                            regulatorRegister.getId(), Connection.INTERNAL_TYPE, eqPin, regPin,
                            Connection.INSIDE_CONNECTION);
                    if (!(clist.contains(newC))) {
                        log.info("----- creating connection " + newC);
                        log.info("------- clist size" + clist.size());
                        clist.add(newC);
                    } else {
                        log.info("----- connection already exist: " + newC);
                    }
                }

                if (equipmentReg.pins.contains(eqPin) && regulatorRegister.Model.equalsIgnoreCase("ESDC2A")) {
                    log.info("--* connection eq-int {}-{}  on pins {},{}", equipmentReg.getModel(),
                            regulatorRegister.getModel(), eqPin, regPin);
                    log.info("----*  {} {} {} {} {} {} {}", "inside", "equipment", equipmentId, eqPin, regPin,
                            "internal", regulatorRegister.getId());
                    Connection newC = new Connection(equipmentId, Connection.EQUIPMENT_TYPE,
                            regulatorRegister.getId(), Connection.INTERNAL_TYPE, eqPin, regPin,
                            Connection.INSIDE_CONNECTION);
                    if (!(clist.contains(newC))) {
                        log.info("----- creating connection " + newC);
                        log.info("------- clist size" + clist.size());
                        clist.add(newC);
                    } else {
                        log.info("----- connection already exist: " + newC);
                    }
                }

                //This is a rule from PSS/E about how to connect IEEEST.V_S
                regPin = "V_S";
                if (regulatorRegister.Model.equalsIgnoreCase("IEEEST")) {
                    if ((regulatorRegister.parameters.get("IM") == 3)
                            && regulatorRegister.parameters.get("IM1") == 0) {
                        eqPin = "PELEC";
                        log.info("--* connection eq-int {}-{}  on pins {},{}", equipmentReg.getModel(),
                                regulatorRegister.getModel(), eqPin, regPin);
                        log.info("----*  {} {} {} {} {} {} {}", "inside", "equipment", equipmentId, eqPin,
                                regPin, "internal", regulatorRegister.getId());
                        Connection newC = new Connection(equipmentId, Connection.EQUIPMENT_TYPE,
                                regulatorRegister.getId(), Connection.INTERNAL_TYPE, eqPin, regPin,
                                Connection.INSIDE_CONNECTION);
                        if (!(clist.contains(newC))) {
                            log.info("----- creating connection " + newC);
                            log.info("------- clist size" + clist.size());
                            clist.add(newC);
                        } else {
                            log.info("----- connection already exist: " + newC);
                        }
                    }
                }

                if (equipmentReg.Model.equals("GENSAL") && hasPss2a && hasHygov) {
                    if (regulatorRegister.getModel().equals("PSS2A")) {
                        eqPin = "PELEC";
                        regPin = "V_S2";
                        log.info("--* connection eq-int {}-{}  on pins {},{}", equipmentReg.getModel(),
                                regulatorRegister.getModel(), eqPin, regPin);
                        log.info("----*  {} {} {} {} {} {} {}", "inside", "equipment", equipmentId, eqPin,
                                regPin, "internal", regulatorRegister.getId());
                        Connection newC = new Connection(equipmentId, Connection.EQUIPMENT_TYPE,
                                regulatorRegister.getId(), Connection.INTERNAL_TYPE, eqPin, regPin,
                                Connection.INSIDE_CONNECTION);
                        if (!(clist.contains(newC))) {
                            log.info("----- creating connection " + newC);
                            log.info("------- clist size" + clist.size());
                            clist.add(newC);
                        } else {
                            log.info("----- connection already exist: " + newC);
                        }
                    }
                }
                if (equipmentReg.Model.equals("GENROU") && hasPss2a && hasTgov1) {
                    if (regulatorRegister.getModel().equals("PSS2A")) {
                        eqPin = "PELEC";
                        regPin = "V_S2";
                        log.info("--* connection eq-int {}-{}  on pins {},{}", equipmentReg.getModel(),
                                regulatorRegister.getModel(), eqPin, regPin);
                        log.info("----*  {} {} {} {} {} {} {}", "inside", "equipment", equipmentId, eqPin,
                                regPin, "internal", regulatorRegister.getId());
                        Connection newC = new Connection(equipmentId, Connection.EQUIPMENT_TYPE,
                                regulatorRegister.getId(), Connection.INTERNAL_TYPE, eqPin, regPin,
                                Connection.INSIDE_CONNECTION);
                        if (!(clist.contains(newC))) {
                            log.info("----- creating connection " + newC);
                            log.info("------- clist size" + clist.size());
                            clist.add(newC);
                        } else {
                            log.info("----- connection already exist: " + newC);
                        }
                    }
                }
            }

            // second create regulator-regulators connections
            for (int i = 0; i < internalsRegs.size(); i++) {
                for (int j = i + 1; j < internalsRegs.size(); j++) {
                    log.info("-- for iteration {} regulator(i) {} regulator(j) {}",
                            internalsRegs.get(i).getModel(), internalsRegs.get(j).getModel());

                    LinkedHashSet<String> sharedPins = PsseRegisterFactory
                            .intersectPinsSets(internalsRegs.get(i), internalsRegs.get(j));
                    if (sharedPins.size() > 0) {
                        log.info("-- connection int-int {}-{}  on pins {}", internalsRegs.get(i).getModel(),
                                internalsRegs.get(j).getModel(), sharedPins);
                        for (String pinName : sharedPins) {
                            log.info("----  {} {} {} {} {} {} {}", "inside", "internal",
                                    internalsRegs.get(i).getId(), pinName, pinName, "internal",
                                    internalsRegs.get(j).getId());
                            Connection newC = new Connection(internalsRegs.get(i).getId(),
                                    Connection.INTERNAL_TYPE, internalsRegs.get(j).getId(),
                                    Connection.INTERNAL_TYPE, pinName, pinName, Connection.INSIDE_CONNECTION);
                            if (!(clist.contains(newC))) {
                                log.info("---- creating connection: " + newC);
                                clist.add(newC);
                            } else {
                                log.info("---- connection already exists: " + newC);
                            }
                        }
                    } else {
                        log.info("-- connection int-int {}-{}  does not exist: no shared pins names",
                                internalsRegs.get(i).getModel(), internalsRegs.get(j).getModel());
                    }

                    //TODO SMF Specific connections in a specific configuration
                    String regPin1 = "V_S1";
                    String regPin2 = "SPEED";

                    writer.write("Internal 1: " + internalsRegs.get(i).getModel() + ". Internal 2: "
                            + internalsRegs.get(j).getModel() + "\n");

                    if (equipmentReg.Model.equals("GENSAL") && hasPss2a && hasHygov) {
                        if (internalsRegs.get(i).Model.equals("PSS2A")
                                && internalsRegs.get(j).Model.equals("HYGOV")) {
                            log.info("-- connection int-int {}-{}  on pins {},{}",
                                    internalsRegs.get(i).getModel(), internalsRegs.get(j).getModel(), regPin1,
                                    regPin2);
                            log.info("----  {} {} {} {} {} {} {}", "inside", "internal",
                                    internalsRegs.get(i).getId(), regPin1, regPin2, "internal",
                                    internalsRegs.get(j).getId());
                            Connection newC = new Connection(internalsRegs.get(i).getId(),
                                    Connection.INTERNAL_TYPE, internalsRegs.get(j).getId(),
                                    Connection.INTERNAL_TYPE, regPin1, regPin2, Connection.INSIDE_CONNECTION);
                            if (!(clist.contains(newC))) {
                                log.info("---- creating connection: " + newC);
                                clist.add(newC);
                            } else {
                                log.info("---- connection already exists: " + newC);
                            }
                        } else if (internalsRegs.get(i).Model.equals("HYGOV")
                                && internalsRegs.get(j).Model.equals("PSS2A")) {
                            log.info("-- connection int-int {}-{}  on pins {},{}",
                                    internalsRegs.get(i).getModel(), internalsRegs.get(j).getModel(), regPin2,
                                    regPin1);
                            log.info("----  {} {} {} {} {} {} {}", "inside", "internal",
                                    internalsRegs.get(i).getId(), regPin2, regPin1, "internal",
                                    internalsRegs.get(j).getId());
                            Connection newC = new Connection(internalsRegs.get(i).getId(),
                                    Connection.INTERNAL_TYPE, internalsRegs.get(j).getId(),
                                    Connection.INTERNAL_TYPE, regPin2, regPin1, Connection.INSIDE_CONNECTION);
                            if (!(clist.contains(newC))) {
                                log.info("---- creating connection: " + newC);
                                clist.add(newC);
                            } else {
                                log.info("---- connection already exists: " + newC);
                            }
                        }
                    }
                    if (equipmentReg.Model.equals("GENROU") && hasPss2a && hasTgov1) {
                        if (internalsRegs.get(i).Model.equals("PSS2A")
                                && internalsRegs.get(j).Model.equals("TGOV1")) {

                            log.info("-- connection int-int {}-{}  on pins {},{}",
                                    internalsRegs.get(i).getModel(), internalsRegs.get(j).getModel(), regPin1,
                                    regPin2);
                            log.info("----  {} {} {} {} {} {} {}", "inside", "internal",
                                    internalsRegs.get(i).getId(), regPin1, regPin2, "internal",
                                    internalsRegs.get(j).getId());
                            Connection newC = new Connection(internalsRegs.get(i).getId(),
                                    Connection.INTERNAL_TYPE, internalsRegs.get(j).getId(),
                                    Connection.INTERNAL_TYPE, regPin1, regPin2, Connection.INSIDE_CONNECTION);
                            if (!(clist.contains(newC))) {
                                log.info("---- creating connection: " + newC);
                                clist.add(newC);
                            } else {
                                log.info("---- connection already exists: " + newC);
                            }
                        } else if (internalsRegs.get(i).Model.equals("TGOV1")
                                && internalsRegs.get(j).Model.equals("PSS2A")) {
                            log.info("-- connection int-int {}-{}  on pins {},{}",
                                    internalsRegs.get(i).getModel(), internalsRegs.get(j).getModel(), regPin2,
                                    regPin1);
                            log.info("----  {} {} {} {} {} {} {}", "inside", "internal",
                                    internalsRegs.get(i).getId(), regPin2, regPin1, "internal",
                                    internalsRegs.get(j).getId());
                            Connection newC = new Connection(internalsRegs.get(i).getId(),
                                    Connection.INTERNAL_TYPE, internalsRegs.get(j).getId(),
                                    Connection.INTERNAL_TYPE, regPin2, regPin1, Connection.INSIDE_CONNECTION);
                            if (!(clist.contains(newC))) {
                                log.info("---- creating connection: " + newC);
                                clist.add(newC);
                            } else {
                                log.info("---- connection already exists: " + newC);
                            }
                        }
                    }
                }

                //TODO SMF Perhaps this will happen in several cases as if regpins.contains(VOTHSG VUEL and VOEL) ==> connect these pins
                String regPin1;
                String regPin2;
                if (internalsRegs.get(i).Model.equals("IEEEX1")) {
                    regPin1 = "VOTHSG";
                    regPin2 = "VOEL";
                    log.info("-- connection int-int {}-{}  on pins {},{}", internalsRegs.get(i).getModel(),
                            internalsRegs.get(i).getModel(), regPin1, regPin2);
                    log.info("----  {} {} {} {} {} {} {}", "inside", "internal", internalsRegs.get(i).getId(),
                            regPin1, regPin2, "internal", internalsRegs.get(i).getId());
                    Connection newC = new Connection(internalsRegs.get(i).getId(), Connection.INTERNAL_TYPE,
                            internalsRegs.get(i).getId(), Connection.INTERNAL_TYPE, regPin1, regPin2,
                            Connection.INSIDE_CONNECTION);
                    if (!(clist.contains(newC))) {
                        log.info("---- creating connection: " + newC);
                        clist.add(newC);
                    } else {
                        log.info("---- connection already exists: " + newC);
                    }

                    regPin2 = "VUEL";
                    log.info("-- connection int-int {}-{}  on pins {},{}", internalsRegs.get(i).getModel(),
                            internalsRegs.get(i).getModel(), regPin1, regPin2);
                    log.info("----  {} {} {} {} {} {} {}", "inside", "internal", internalsRegs.get(i).getId(),
                            regPin1, regPin2, "internal", internalsRegs.get(i).getId());
                    newC = new Connection(internalsRegs.get(i).getId(), Connection.INTERNAL_TYPE,
                            internalsRegs.get(i).getId(), Connection.INTERNAL_TYPE, regPin1, regPin2,
                            Connection.INSIDE_CONNECTION);
                    if (!(clist.contains(newC))) {
                        log.info("---- creating connection: " + newC);
                        clist.add(newC);
                    } else {
                        log.info("---- connection already exists: " + newC);
                    }
                }
            }

            //third create equipment-equipment connections
            String eqPin1 = "PMECH";
            String eqPin2 = "PMECH0";
            if (equipmentReg.Model.equals("GENROU") && (!hasTgov1 && !hasIeesgo)) {
                log.info("--* connection eq-eq {}-{}  on pins {},{}", equipmentReg.getModel(),
                        equipmentReg.getModel(), eqPin1, eqPin2);
                log.info("----*  {} {} {} {} {} {} {}", "inside", "equipment", equipmentId, eqPin1, eqPin2,
                        "equipment", equipmentId);
                Connection newC = new Connection(equipmentId, Connection.EQUIPMENT_TYPE, equipmentId,
                        Connection.EQUIPMENT_TYPE, eqPin1, eqPin2, Connection.INSIDE_CONNECTION);
                if (!(clist.contains(newC))) {
                    log.info("----- creating connection " + newC);
                    log.info("------- clist size" + clist.size());
                    clist.add(newC);
                } else {
                    log.info("----- connection already exist: " + newC);
                }
            }

            if (equipmentReg.Model.equals("GENSAL") && !hasHygov) {
                log.info("--* connection eq-eq {}-{}  on pins {},{}", equipmentReg.getModel(),
                        equipmentReg.getModel(), eqPin1, eqPin2);
                log.info("----*  {} {} {} {} {} {} {}", "inside", "equipment", equipmentId, eqPin1, eqPin2,
                        "equipment", equipmentId);
                Connection newC = new Connection(equipmentId, Connection.EQUIPMENT_TYPE, equipmentId,
                        Connection.EQUIPMENT_TYPE, eqPin1, eqPin2, Connection.INSIDE_CONNECTION);
                if (!(clist.contains(newC))) {
                    log.info("----- creating connection " + newC);
                    log.info("------- clist size" + clist.size());
                    clist.add(newC);
                } else {
                    log.info("----- connection already exist: " + newC);
                }
            }

            if (equipmentReg.Model.equals("WT4G1")) {
                eqPin1 = "I_qcmd";
                eqPin2 = "I_qcmd0";
                log.info("--* connection eq-eq {}-{}  on pins {},{}", equipmentReg.getModel(),
                        equipmentReg.getModel(), eqPin1, eqPin2);
                log.info("----*  {} {} {} {} {} {} {}", "inside", "equipment", equipmentId, eqPin1, eqPin2,
                        "equipment", equipmentId);
                Connection newC = new Connection(equipmentId, Connection.EQUIPMENT_TYPE, equipmentId,
                        Connection.EQUIPMENT_TYPE, eqPin1, eqPin2, Connection.INSIDE_CONNECTION);
                if (!(clist.contains(newC))) {
                    log.info("----- creating connection " + newC);
                    log.info("------- clist size" + clist.size());
                    clist.add(newC);
                } else {
                    log.info("----- connection already exist: " + newC);
                }

                eqPin1 = "I_pcmd";
                eqPin2 = "I_pcmd0";
                log.info("--* connection eq-eq {}-{}  on pins {},{}", equipmentReg.getModel(),
                        equipmentReg.getModel(), eqPin1, eqPin2);
                log.info("----*  {} {} {} {} {} {} {}", "inside", "equipment", equipmentId, eqPin1, eqPin2,
                        "equipment", equipmentId);
                newC = new Connection(equipmentId, Connection.EQUIPMENT_TYPE, equipmentId,
                        Connection.EQUIPMENT_TYPE, eqPin1, eqPin2, Connection.INSIDE_CONNECTION);
                if (!(clist.contains(newC))) {
                    log.info("----- creating connection " + newC);
                    log.info("------- clist size" + clist.size());
                    clist.add(newC);
                } else {
                    log.info("----- connection already exist: " + newC);
                }
            }

            // fourth persist the connection schema
            if (clist.size() > 0) {
                cs.setConnections(clist);
                cs = ddbmanager.save(cs);
            }

        }
        //TODO loads?

        if (deleteData) {
            for (String csId : equipmentsList) {
                ConnectionSchema cs = ddbmanager.findConnectionSchema(csId, null);
                log.info("- removing  cs {} {}", csId, cs.getId());
                ddbmanager.delete(cs);
            }
            for (String eqId : equipmentsList) {
                Equipment eq = ddbmanager.findEquipment(eqId);
                log.info("- removing  eq {} {}", eqId, eq.getId());
                ddbmanager.delete(eq);
            }
            for (String intId : internalsList) {
                Internal internal = ddbmanager.findInternal(intId);
                log.info("- removing  int {} {}", intId, internal.getId());
                ddbmanager.delete(internal);
            }
            for (String pcId : ptcList) {
                ParametersContainer pc = ddbmanager.findParametersContainer(pcId);
                log.info("- removing  pc {} - {}", pcId, pc.getId());
                ddbmanager.delete(pc);
            }
            for (String mtcId : mtcSet) {
                ModelTemplateContainer mtc = ddbmanager.findModelTemplateContainer(mtcId);
                try {
                    if (mtc != null) {
                        log.info("- removing  mtc {} {}", mtcId, mtc.getId());
                        ddbmanager.delete(mtc);
                    }
                } catch (RuntimeException ex) {
                }
            }
        }
        writer.close();
    } catch (Exception e) {
        log.error(e.getMessage(), e);
    }
}

From source file:net.bunselmeyer.mongo.maven.plugin.MigrateMojo.java

protected ImmutableListMultimap<String, MigrationDetails> buildIndex(Iterable<MigrationDetails> migrations) {
    return Multimaps.index(migrations, new Function<MigrationDetails, String>() {
        public String apply(MigrationDetails input) {
            return input.host + "," + input.db;
        }/*from   w  w w . j av  a2 s . c  om*/
    });
}

From source file:org.opentestsystem.authoring.testauth.service.impl.BlueprintValidationHelper.java

/**
 * Handles active/inactive hierarchical validation for each individual <code>BlueprintElement</code>. This includes:
 * <ul>/*from   w  w w  .  ja va 2 s  . c om*/
 * <li>A child standard may not be ACTIVE if it's parent is INACTIVE</li>
 * </ul>
 */
protected static List<ValidationResult<BlueprintElement>> validateInactiveBlueprintHierarchicalRelationships(
        final List<BlueprintElement> blueprintElementList) {
    final List<ValidationResult<BlueprintElement>> errors = Lists.newArrayList();

    if (!CollectionUtils.isEmpty(blueprintElementList)) {
        final Map<String, BlueprintElement> blueprintElementMap = Maps.uniqueIndex(blueprintElementList,
                BLUEPRINT_ELEMENT_UNIQUE_KEY_FUNCTION);

        final List<BlueprintElement> filteredChildrenBlueprintElementList = Lists
                .newArrayList(Iterables.filter(blueprintElementList, BLUEPRINT_ELEMENT_CHILD_FILTER));
        final Map<String, Collection<BlueprintElement>> blueprintElementGroupedMap = Multimaps
                .index(filteredChildrenBlueprintElementList, BLUEPRINT_ELEMENT_PARENT_KEY_FUNCTION).asMap();

        for (final Entry<String, Collection<BlueprintElement>> blueprintElementEntry : blueprintElementGroupedMap
                .entrySet()) {
            if (StringUtils.isNotBlank(blueprintElementEntry.getKey())) {
                final BlueprintElement parentBlueprintElement = blueprintElementMap
                        .get(blueprintElementEntry.getKey());
                if (parentBlueprintElement != null) {
                    // validate parent/child inactive rules
                    if (!parentBlueprintElement.isActive()) {
                        for (final BlueprintElement childElement : blueprintElementGroupedMap
                                .get(blueprintElementEntry.getKey())) {
                            if (childElement.isActive()) {
                                errors.add(buildValidationResult(childElement, MASTER_KEY, ACTIVE_FIELD,
                                        INACTIVE_MESSAGE));
                            }
                        }
                    }
                }
            }
        }
    }

    return errors;
}

From source file:eu.itesla_project.simulation.ImpactAnalysisTool.java

private static Multimap<String, SecurityIndex> runImpactAnalysis(Network network, Set<String> contingencyIds,
        ComputationManager computationManager, SimulatorFactory simulatorFactory,
        ContingenciesProvider contingenciesProvider) throws Exception {
    Stabilization stabilization = simulatorFactory.createStabilization(network, computationManager, 0);
    ImpactAnalysis impactAnalysis = simulatorFactory.createImpactAnalysis(network, computationManager, 0,
            contingenciesProvider);// w w  w. j a v a2  s  .c  o  m
    Map<String, Object> initContext = new HashMap<>();
    SimulationParameters simulationParameters = SimulationParameters.load();
    stabilization.init(simulationParameters, initContext);
    impactAnalysis.init(simulationParameters, initContext);
    System.out.println("running stabilization simulation...");
    StabilizationResult sr = stabilization.run();
    System.out.println("stabilization status: " + sr.getStatus());
    System.out.println("stabilization metrics: " + sr.getMetrics());
    if (sr.getStatus() == StabilizationStatus.COMPLETED) {
        System.out.println("running impact analysis...");
        ImpactAnalysisResult iar = impactAnalysis.run(sr.getState(), contingencyIds);
        System.out.println("impact analysis metrics: " + iar.getMetrics());

        return Multimaps.index(iar.getSecurityIndexes(), new Function<SecurityIndex, String>() {
            @Override
            public String apply(SecurityIndex securityIndex) {
                return securityIndex.getId().getContingencyId();
            }
        });

    }
    return null;
}

From source file:edu.isi.karma.modeling.research.approach1.SteinerNodes.java

private void computeCoherenceList() {

    if (nodes == null || nodes.size() == 0)
        return;//from  w  w w. jav a 2  s  .c o  m

    Map<String, Integer> patternSize = new HashMap<String, Integer>();
    Map<String, String> patternGuid = new HashMap<String, String>();
    int guidSize = new RandomGUID().toString().length();

    for (Node n : nodes) {
        for (String p : n.getPatternIds()) {

            Integer size = patternSize.get(p);
            if (size == null)
                patternSize.put(p, 1);
            else
                patternSize.put(p, ++size);

            if (!patternGuid.containsKey(p)) {
                String guid = new RandomGUID().toString();
                patternGuid.put(p, guid);
            }
        }
    }

    // find the maximum pattern size
    int maxPatternSize = 0;
    for (Entry<String, Integer> entry : patternSize.entrySet()) {
        if (entry.getValue().intValue() > maxPatternSize)
            maxPatternSize = entry.getValue().intValue();
    }

    List<String> listOfNodesLargestPatterns = new ArrayList<String>();

    for (Node n : nodes) {
        List<String> patternIds = new ArrayList<String>(n.getPatternIds());
        Collections.sort(patternIds);

        String[] nodeMaxPatterns = new String[maxPatternSize];
        Arrays.fill(nodeMaxPatterns, "");

        for (String p : patternIds) {
            int size = patternSize.get(p).intValue();
            nodeMaxPatterns[size - 1] += patternGuid.get(p);
        }
        for (int i = maxPatternSize - 1; i >= 0; i--) {
            if (nodeMaxPatterns[i] != null && nodeMaxPatterns[i].trim().length() > 0) {
                listOfNodesLargestPatterns.add(nodeMaxPatterns[i]);
                break;
            }
        }
    }

    Function<String, String> stringEqualiy = new Function<String, String>() {
        @Override
        public String apply(final String s) {
            return s;
        }
    };

    Multimap<String, String> index = Multimaps.index(listOfNodesLargestPatterns, stringEqualiy);

    this.coherenceList.clear();
    int x, y;
    for (String s : index.keySet()) {
        if (s.trim().length() == 0)
            continue;
        x = index.get(s).size();
        y = x > 0 ? index.get(s).iterator().next().length() / guidSize : 0;
        CoherenceItem ci = new CoherenceItem(x, y);
        this.coherenceList.add(ci);
    }

    Collections.sort(this.coherenceList);

}

From source file:eu.itesla_project.modules.simulation.ImpactAnalysisTool.java

private static Multimap<String, SecurityIndex> runImpactAnalysis(Network network, Set<String> contingencyIds,
        ComputationManager computationManager, SimulatorFactory simulatorFactory,
        DynamicDatabaseClientFactory ddbFactory, ContingenciesAndActionsDatabaseClient contingencyDb)
        throws Exception {
    Stabilization stabilization = simulatorFactory.createStabilization(network, computationManager, 0,
            ddbFactory);/*from  w w  w  .j a v  a2s.co  m*/
    ImpactAnalysis impactAnalysis = simulatorFactory.createImpactAnalysis(network, computationManager, 0,
            contingencyDb);
    Map<String, Object> initContext = new HashMap<>();
    SimulationParameters simulationParameters = SimulationParameters.load();
    stabilization.init(simulationParameters, initContext);
    impactAnalysis.init(simulationParameters, initContext);
    System.out.println("running stabilization simulation...");
    StabilizationResult sr = stabilization.run();
    System.out.println("stabilization status: " + sr.getStatus());
    System.out.println("stabilization metrics: " + sr.getMetrics());
    if (sr.getStatus() == StabilizationStatus.COMPLETED) {
        System.out.println("running impact analysis...");
        ImpactAnalysisResult iar = impactAnalysis.run(sr.getState(), contingencyIds);
        System.out.println("impact analysis metrics: " + iar.getMetrics());

        return Multimaps.index(iar.getSecurityIndexes(), new Function<SecurityIndex, String>() {
            @Override
            public String apply(SecurityIndex securityIndex) {
                return securityIndex.getId().getContingencyId();
            }
        });

    }
    return null;
}

From source file:com.facebook.buck.rules.Manifest.java

/**
 * Adds a new output file to the manifest.
 *//*from   ww  w . j  av a 2 s  . c  o m*/
public void addEntry(FileHashCache fileHashCache, RuleKey key, SourcePathResolver resolver,
        ImmutableSet<SourcePath> universe, ImmutableSet<SourcePath> inputs) throws IOException {
    int index = 0;
    int[] hashIndices = new int[inputs.size()];
    ImmutableListMultimap<String, SourcePath> sortedUniverse = Multimaps.index(universe,
            sourcePathToManifestHeaderFunction(resolver));
    for (SourcePath input : inputs) {
        String relativePath = sourcePathToManifestHeader(input, resolver);
        ImmutableList<SourcePath> paths = sortedUniverse.get(relativePath);
        Preconditions.checkState(!paths.isEmpty());
        hashIndices[index++] = addHash(relativePath, hashSourcePathGroup(fileHashCache, resolver, paths));
    }
    entries.add(new Pair<>(key, hashIndices));
}

From source file:org.obiba.opal.web.gwt.app.client.magma.view.SummaryTabView.java

private void renderDefaultSummary(SummaryStatisticsDto dto) {
    DefaultSummaryDto defaultSummaryDto = dto
            .getExtension(DefaultSummaryDto.SummaryStatisticsDtoExtensions.defaultSummary).cast();

    final double[] totals = { 0d, 0d };
    ImmutableListMultimap<Boolean, FrequencyDto> valuesByMissing = Multimaps.index(
            JsArrays.toIterable(defaultSummaryDto.getFrequenciesArray()),
            new Function<FrequencyDto, Boolean>() {
                @Nullable//from   w w w  . j  a  v  a2 s  . c o  m
                @Override
                public Boolean apply(@Nullable FrequencyDto input) {
                    if (input != null && !input.getMissing()) {
                        input.setValue(translations.notEmpty());
                        totals[0] += input.getFreq();
                        return false;
                    }
                    totals[1] += input == null ? 0 : input.getFreq();
                    return true;
                }
            });

    summary.add(new DefaultSummaryView(defaultSummaryDto, valuesByMissing.get(false), valuesByMissing.get(true),
            totals[0], totals[1]));
}

From source file:org.sonar.server.qualityprofile.RegisterQualityProfiles.java

private static Map<String, Collection<RulesProfile>> profilesByName(List<RulesProfile> profiles) {
    return Multimaps.index(profiles, new Function<RulesProfile, String>() {
        @Override/* w w w.  j ava2 s  .co  m*/
        public String apply(@Nullable RulesProfile profile) {
            return profile != null ? profile.getName() : null;
        }
    }).asMap();
}