SctApiInfo.java

package DisplayGUI;
import GuiComponents.System.*;
import Sct_SctApi.*;

public class SctApiInfo implements TestDataInfo {
        private static SctApiInfo instance = new SctApiInfo();
        Sct_SctApi.SctApiIPC api;
        sctConf.Configuration sctconf;
        ConfigurationInterface guiConfig=null;
        java.util.Map probeHash, countHash, chanMap, chanMap2;
        String[] dTypes ={"0","1","2","J","E"};
        java.util.regex.Pattern keyPattern = java.util.regex.Pattern.compile("(\\d+)\\*(\\d+)\\*(\\d+)");
        java.util.Vector chanList;
        java.util.Set errorModuleList;


public static SctApiInfo getInstance() {
      return instance;
        }

private SctApiInfo() {
      probeHash = new java.util.HashMap();
      countHash = new java.util.HashMap();
      }

public boolean refreshChannelMap(int viewCategory, int selectedView) {

        sctconf = SystemInterface.getInstance().getConfigurationService();
        if(sctconf==null) {
        javax.swing.JOptionPane.showMessageDialog(null,"Configuration Service is not available.");
        return false;
        }
      api = SystemInterface.getInstance().getSctApi();
        if(api==null) {
        javax.swing.JOptionPane.showMessageDialog(null,"SctApi is not available.");
        return false;
        }

        chanMap = new java.util.HashMap();
        chanMap2 = new java.util.HashMap();
   // first loop trough all modules to determine which RODs we need to probe, and their channels
      guiConfig = ConfigurationInterface.getInstance();
      for (java.util.Iterator m = guiConfig.getSerialNumberList(viewCategory,selectedView).iterator(); m.hasNext(); ) {
        String sn=(String)m.next();
                String crate = guiConfig.getSNInfo(sn,SNInfo.ROD_CRATE);
                String rod = guiConfig.getSNInfo(sn,SNInfo.ROD_NUMBER);
                String chan = guiConfig.getSNInfo(sn,SNInfo.ROD_CHANNEL);
                String partition = guiConfig.getSNInfo(sn,SNInfo.PARTITION);
                String key = partition+"*"+crate+"*"+rod;
                if(chanMap.containsKey(key)) chanList = (java.util.Vector)chanMap.get(key);
                else chanList =  new java.util.Vector();
                chanList.addElement(chan);
                chanMap.put(key,chanList);
                chanMap2.put(key+"*"+chan,sn);
                }
    // now chanMap is map of parition*crate*rod to vector of channels in that rod
    // chanMap2 is a map of partition*crate*rod*chan to serial number
    return true;
        }

public void probeConfig(int viewCategory, int selectedView, int BOCParameter) {

        sctConf.BOCChannelConfig [] block;
        byte[] mappings;

        probeHash = new java.util.HashMap();

        if(!refreshChannelMap(viewCategory,selectedView)) return;

    // iterate through chanMap
        for (java.util.Iterator i=chanMap.entrySet().iterator(); i.hasNext(); ) {
                java.util.Map.Entry e = (java.util.Map.Entry) i.next();
                String key = (String)e.getKey();
                chanList = (java.util.Vector)e.getValue();

                java.util.regex.Matcher matcher = keyPattern.matcher(key);
                if(!matcher.matches()) {
                System.err.println("**ERROR no key match in SctApiInfo");
                continue;
                }

                String partition = key.substring(matcher.start(1),matcher.end(1));
                String crate = key.substring(matcher.start(2),matcher.end(2));
                String rod = key.substring(matcher.start(3),matcher.end(3));

                int icrate = Integer.valueOf(crate).intValue();
                int irod = Integer.valueOf(rod).intValue();
                int ipartition = Integer.valueOf(partition).intValue();

                try {
                        block = api.currentBOCSetup(ipartition, icrate, irod);
                        if(block.length!=48) {
                                System.err.println("Got "+block.length+" values from api.currentBOCSetup?");
                                continue;
                                }
                        // mappings:
                        // [0,1,2] is chan0 TX Stream0 Stream1 fibre mapping
                        // [3,4,5] is chan1 TX Stream0 Stream1 fibre mapping ...etc
                        // eg 0,0,1  1,2,3  2,4,5  3,6,7 etc
                        mappings = sctconf.getFibreMappings(ipartition,icrate,irod);
                        }
                catch(Exception ee) {javax.swing.JOptionPane.showMessageDialog(null,"Exception from SctApi: "+ee.toString()); return;}

                for(int j=0;j<chanList.size();j++) {
                        String chan = (String)chanList.elementAt(j);
                int ichan = Integer.valueOf(chan).intValue();
                        Double data = null;

                        LinkData linkData = new LinkData();

                        byte mappingIndex;

                switch(BOCParameter) {
                                case 1: // TX Current
                                        mappingIndex = mappings[ichan*3];
                                        //System.out.println("chan="+chan+" mappingindex="+mappingIndex);
                                        if(mappingIndex>=0) linkData.put(0,Double.valueOf((double)block[mappingIndex].current));
                                        break;
                                case 2:// TX Coarse Delay
                                        mappingIndex = mappings[ichan*3];
                                        //System.out.println("chan="+chan+" mappingindex="+mappingIndex);
                                        if(mappingIndex>=0) linkData.put(0,Double.valueOf((double)((block[mappingIndex].delay & 0xff00) >> 8)));
                                        break;
                                case 3: // TX Fine Delay
                                        mappingIndex = mappings[ichan*3];
                                        //System.out.println("chan="+chan+" mappingindex="+mappingIndex);
                                        if(mappingIndex>=0) linkData.put(0,Double.valueOf((double)(block[mappingIndex].delay & 0xff)));
                                        break;
                                case 4: // Mark Space Ratio
                                        mappingIndex = mappings[ichan*3];
                                        //System.out.println("chan="+chan+" mappingindex="+mappingIndex);
                                        if(mappingIndex>=0) linkData.put(0,Double.valueOf((double)block[mappingIndex].markSpace));
                                        break;
                                case 5: // RX Threshold 0
                                case 7: // RX Threshold 1
                                        mappingIndex = mappings[ichan*3 + 1];
                                        if(mappingIndex>=0) {
                                                int newchan = mappingIndex/2;
                                                //System.out.println("chan="+chan+" mappingIndex="+mappingIndex+" actual chan="+newchan);
                                                linkData.put(0,Double.valueOf((double)block[newchan].threshold0));
                                                }
                                        mappingIndex = mappings[ichan*3 + 2];
                                        if(mappingIndex>=0) {
                                                int newchan = mappingIndex/2;
                                                //System.out.println("chan="+chan+" mappingIndex="+mappingIndex+" actual chan="+newchan);
                                                linkData.put(1,Double.valueOf((double)block[newchan].threshold1));
                                                }
                                        break;
                                case 6: // RX Delay 0
                                case 8: // RX Delay 1
                                        mappingIndex = mappings[ichan*3 + 1];
                                        if(mappingIndex>=0) {
                                                int newchan = mappingIndex/2;
                                                //System.out.println("chan="+chan+" mappingIndex="+mappingIndex+" actual chan="+newchan);
                                                linkData.put(0,Double.valueOf((double)block[newchan].delay0));
                                                }
                                        mappingIndex = mappings[ichan*3 + 2];
                                        if(mappingIndex>=0) {
                                                int newchan = mappingIndex/2;
                                                //System.out.println("chan="+chan+" mappingIndex="+mappingIndex+" actual chan="+newchan);
                                                linkData.put(1,Double.valueOf((double)block[newchan].delay1));
                                                }
                                        break;
                                default:
                        }

                    String thisKey = partition+"*"+crate+"*"+rod+"*"+chan;
                    probeHash.put(thisKey,linkData);
                        } // chan loop
                } // rod loop
        }

   public void probe(int viewCategory, int selectedView) {
        probe(viewCategory, selectedView, false);
        }


   public void probe(int viewCategory, int selectedView, boolean listBadModules) {

   countHash = new java.util.HashMap();
   probeHash = new java.util.HashMap();
   errorModuleList = new java.util.HashSet();

   if(!refreshChannelMap(viewCategory,selectedView)) return;

    // iterate through chanMap
    for (java.util.Iterator i=chanMap.entrySet().iterator(); i.hasNext(); ) {
           java.util.Map.Entry e = (java.util.Map.Entry) i.next();
           String key = (String)e.getKey();
           chanList = (java.util.Vector)e.getValue();

           java.util.regex.Matcher matcher = keyPattern.matcher(key);
           if(!matcher.matches()) {
              System.err.println("**sctGUI: ERROR no key match in SctApiInfo for key "+key);
              continue;
              }

           String partition = key.substring(matcher.start(1),matcher.end(1));
           String crate = key.substring(matcher.start(2),matcher.end(2));
           String rod = key.substring(matcher.start(3),matcher.end(3));

           int icrate = Integer.valueOf(crate).intValue();
           int irod = Integer.valueOf(rod).intValue();
           int ipartition = Integer.valueOf(partition).intValue();

           // probe rod
           short[] results;
           byte[] mappings;
           try {
             results = api.probe(ipartition, icrate, irod);
             if(results.length!=96) {
                System.err.println("**sctGUI: Got "+results.length+" values from api.probe?");
                continue;
                }
           // get fibre mappings for rod, in case any are set explicitly in xml file
             mappings = sctconf.getFibreMappings(ipartition,icrate,irod);
         //    System.out.println("Got "+mappings.length+" mappings from getFibreMappings for rod "+irod);
             }catch(Exception ee){System.err.println("**sctGUI Exception in SctapiInfo::probe - "+ee.toString()); continue;}
           
           for(int j=0;j<chanList.size();j++) {
                String chan = (String)chanList.elementAt(j);
              int ichan = Integer.valueOf(chan).intValue();

              LinkData linkData = new LinkData();
                String thisKey = partition+"*"+crate+"*"+rod+"*"+chan;

                for(int link=0;link<2;link++) {

                        int index = ichan*3 + link + 1;
                        byte mappingIndex = mappings[index];
                //   System.out.println("Key "+key+" Link "+link+" channel "+chan+" maps to "+mappingIndex);
                        if(mappingIndex<0) continue;  // link switched off?

                        short value = (mappingIndex>=0) ? results[mappingIndex] : 48;
                String thisChar = Character.toString((char)value);
                if(!countHash.containsKey(thisChar)) countHash.put(thisChar, new Integer(1));
                else {
                        int thiscount = ((Integer)countHash.get(thisChar)).intValue();
                                thiscount++;
                                countHash.put(thisChar, new Integer(thiscount));
                                }


                   Double data = new Double(5.0);
                   switch(value) {
                        case 48:
                                data = new Double(0.0);  // 0
                                break;
                        case 49:
                                data = new Double(1.0);  // 1
                                break;
                        case 50:
                                data = new Double(2.0);  // 2
                                break;
                case 69:
                                data = new Double(4.0);  // E
                                 break;
                case 74:
                                data = new Double(3.0);  // J
                                break;
                        default:
                        }

                    if(errorModuleList!=null && value!=69) errorModuleList.add((String)chanMap2.get(thisKey));
                    linkData.put(link,data);
                    } // link loop
                    probeHash.put(thisKey,linkData);
                }  // chan loop
          } // rod loop
     }

     public java.util.Set getErrorModuleList() {return errorModuleList;}
         
     public Double getProbeData(String sn, int link) {
        if(guiConfig==null) return null;
                String crate = guiConfig.getSNInfo(sn,SNInfo.ROD_CRATE);
                String rod = guiConfig.getSNInfo(sn,SNInfo.ROD_NUMBER);
                String chan = guiConfig.getSNInfo(sn,SNInfo.ROD_CHANNEL);
                String partition = guiConfig.getSNInfo(sn,SNInfo.PARTITION);
                String key = partition+"*"+crate+"*"+rod+"*"+chan;
        if(!probeHash.containsKey(key)) return null;
                LinkData lData = (LinkData)probeHash.get(key);
                return lData.getData(link);
                }
     public java.util.Vector getCountVector() {
        java.util.Vector table = new java.util.Vector();
                java.util.Vector theLine = new java.util.Vector();
                theLine.addElement("Result");
                theLine.addElement("Count");
                table.addElement(theLine);

         for (int i=0;i<dTypes.length;i++) {
            theLine = new java.util.Vector();
            theLine.addElement(dTypes[i]);
            if(!countHash.containsKey(dTypes[i])) theLine.addElement(new Integer(0));
            else theLine.addElement((Integer)countHash.get(dTypes[i]));
            table.addElement(theLine);
            }
        return table;
        }
     public void checkProbe() {
        try  {
            String txt = javax.swing.JOptionPane.showInputDialog(null,"Probe Pattern?","E");
            txt.toUpperCase();
            if(SystemInterface.getInstance().getSctApi().checkAllModulesProbe(txt)) {
                javax.swing.JOptionPane.showMessageDialog(null, "Check modules succeeded");
            } else {
                javax.swing.JOptionPane.showMessageDialog(null, "Check modules failed, see MRS for details");
            }
        } catch(Sct_SctApi.SctApiException s) {
            javax.swing.JOptionPane.showMessageDialog(null, "Check modules aborted: " + s);
        }
    }


}

---