ISInterface.java

package DisplayGUI;

import java.io.*;
import java.util.*;
import javax.swing.*;
import javax.swing.text.*;
import java.util.regex.*;
import is.*;
import Sct.Serializable;
import Sct.IS.*;
import GuiComponents.Console.ExternalProcess;
import GuiComponents.Inspector.InspectorPanel;
import Sct_CalibrationController.TestData;
import GuiComponents.System.*;
import SummaryReader.*;

/*
 * ISInterface.java
 *
 */

public class ISInterface implements TestDataInfo,InfoListener {

    gui guiControl;

    ISRequestBuffer isRequestBuffer;
    ISCounter isCounter;

    private List subscriptionList;  // List of current subscriptions

    int listFilterIndex;

    private final String eventServerRegex = ".*RawScanResult.*[0-9]+\\.[0-9]+(\\.[0-9]{14})?";
    private final String fitServerRegex = ".*FitScanResult.*[0-9]+\\.[0-9]+(\\.[0-9]{14})?";
    private final String controlObjectRegex = ".*TestData\\.[0-9]+\\.[0-9]+(.*Test)?";
    private final String rControlObjectRegex = ".*TestData\\.[0-9]+\\.[0-9]+.*Test";
    private final String dbControlObjectRegex = ".*SctRodDaqRefData.*";
    private final String testServerRegex = ".*Result.*[0-9]+\\.[0-9]+(\\.[0-9]{14})?";
    private final String resultObjectRegex = ".*(Summary).*";
    private final String ivscanRegex = ".*IVScanData.*";
    private final String ivscanControlRegex = ".*ControlIVScanData.*";

    private final Pattern objectPattern = Pattern.compile(".*TestData\\.[0-9]+\\.[0-9]+");
    private final Pattern rObjectPattern = Pattern.compile(".*\\.[0-9]+\\.[0-9]+.*Test");
    public static final Pattern defectPattern = Pattern.compile("(\\d+)-(\\d+)\\s*:\\s*(\\w+)");
    public static final Pattern SctRodDaqRefPattern = Pattern.compile(".*SctRodDaqRefData\\.(.*)\\.(.*)\\.(\\d+)\\.(\\d+)");


    String eventServer;
    String fitServer;
    String testServer;
    String controlServer;
    String SCTDBServer;
    String retrievedArchiveServer;

    String testLocation;     // the test location for SCTDB downloads

    int serverIndex=0;        // the currently selected server

    boolean infoListenersAreActive=true;

    java.util.Map moduleCount = new HashMap();


    public static final int LOCATION=2;
    public static final int TESTNAME=1;
    public static final int RUNNO=3;
    public static final int SCANNO=4;

    guiUtilities.Cache cache=null;
    Map dcsCache=null;
    Map dcsMap = new HashMap();
    
    java.text.DecimalFormat nf = new java.text.DecimalFormat("#.###");
    java.text.DecimalFormat nfe = new java.text.DecimalFormat("#.##E0");

    Preferences.PreferencesInterface prefs;

    PlotOptionsFrame plotOptionsFrame=null;

    public ISInterface(gui parent) {
        guiControl=parent;

        prefs = Preferences.PreferencesInterface.getInstance();

        isRequestBuffer = new ISRequestBuffer(guiControl);

        isCounter = new ISCounter();
        listFilterIndex=-1;


        eventServer = SctNames.getEventISServer();
        fitServer = SctNames.getFitISServer();
        testServer = SctNames.getTestISServer();
        controlServer = SctNames.getControlISServer();
        SCTDBServer = "SCTDBData";
        retrievedArchiveServer = "RetrievedData";

        testLocation="Any";

        if(cache==null) setCacheSize(700);  // make it at least barrel 6 worth of modules
        if(dcsCache==null) dcsCache = new HashMap(672*9); // 680 modules worth


    }
    protected void subscribe() {
        subscribe(-1);
        }

    public void setISCounter(String regex) {
        isCounter.refresh(regex);
        }

    protected void subscribe(int testType) {
        listFilterIndex=testType;
        String[] objects;
        Vector ISTests = new Vector();

          is = GuiComponents.System.ISInterface.getInstance();

          subscriptionList = new ArrayList();

        try {

        switch(guiControl.displayStatus.getStatus()) {
           case DisplayStatus.SCTDB_RODDAQ_DATA:
              objects = is.getISObjects(SCTDBServer,dbControlObjectRegex);
              for(int i=0;i<objects.length;i++) ISTests.addElement(objects[i]);
              break;
           case DisplayStatus.IV_DATA:
              objects = is.getISObjects(retrievedArchiveServer,ivscanControlRegex);
              for(int i=0;i<objects.length;i++) ISTests.addElement(objects[i]);
              break;
            default:
              objects = is.getISObjects(retrievedArchiveServer,rControlObjectRegex);
              for(int i=0;i<objects.length;i++) ISTests.addElement(objects[i]);
              objects = is.getISObjects(controlServer,controlObjectRegex);
              for(int i=0;i<objects.length;i++) ISTests.addElement(objects[i]);
              }

         if(guiControl.displayStatus.getStatus()!=DisplayStatus.IV_DATA) {
           for(int j=ISTests.size()-1;j>=0;j--) {
              String controlObject = (String)ISTests.elementAt(j);
              Matcher matcher = objectPattern.matcher(controlObject);
              Matcher matcher2 = rObjectPattern.matcher(controlObject);
              if(!matcher.matches() && !matcher2.matches() && !controlObject.matches(dbControlObjectRegex)) {
                 ISTests.removeElementAt(j);
                 continue;
                 }
              if(listFilterIndex==-1) continue;
              else {
                 TestData testData = new TestData();
                 is.getRepository().getValue(controlObject, testData);
                 String thisTestName = (listFilterIndex==TEST_3PTGAIN) ? testNames[TEST_NPTGAIN] : testNames[listFilterIndex];
                 if(testData.testName.indexOf(thisTestName)==-1) ISTests.removeElementAt(j);
                 }
              }
             }

                }catch(Exception e){System.out.println("SctGUI::ISInterface - Error subscribing to test data");}
        guiControl.tablesDisplayPane.setTestTable(ISTests);

                try {
         switch(guiControl.displayStatus.getStatus()) {
          case DisplayStatus.IS_MONITOR:

            // new data
            subscriptionList.add(new Subscription(eventServer, eventServerRegex));
            subscriptionList.add(new Subscription(fitServer, fitServerRegex));
            subscriptionList.add(new Subscription(testServer, testServerRegex));
            subscriptionList.add(new Subscription(controlServer, controlObjectRegex));
                // retrieved data
            subscriptionList.add(new Subscription("RetrievedData",".*"));
            // if the following is uncommented, the unsubscribe method does not work!! Why????
           // subscriptionList.add(new Subscription("RetrievedData",".*FitScanResult.*[0-9]+\\.[0-9]+(\\.[0-9]{14})?"));
           // subscriptionList.add(new Subscription("RetrievedData",".*RawScanResult.*[0-9]+\\.[0-9]+(\\.[0-9]{14})?"));
           // subscriptionList.add(new Subscription("RetrievedData",".*Result.*[0-9]+\\.[0-9]+(\\.[0-9]{14})?"));
            break;
          case DisplayStatus.TEST_DATA:
             subscriptionList.add(new Subscription(testServer, resultObjectRegex));
             subscriptionList.add(new Subscription(controlServer, controlObjectRegex));
                 subscriptionList.add(new Subscription(retrievedArchiveServer, ".*"));
                 //subscriptionList.add(new Subscription(retrievedArchiveServer, resultObjectRegex));
                 //subscriptionList.add(new Subscription(retrievedArchiveServer, rControlObjectRegex));
             break;
          case DisplayStatus.SCTDB_DATA:
                subscriptionList.add(new Subscription(controlServer, controlObjectRegex));
                subscriptionList.add(new Subscription(SCTDBServer, ".*"));
              break;
          case DisplayStatus.SCTDB_RODDAQ_DATA:
             subscriptionList.add(new Subscription(SCTDBServer, ".*"));
              break;
          case DisplayStatus.IV_DATA:
            subscriptionList.add(new Subscription(retrievedArchiveServer, ivscanRegex));
              break;
          case DisplayStatus.DCS_DATA:
                isCounter.clearDCSObjectList();       // clear the buffer in ISCounter
                int pIndex = guiControl.selectorPane.getDisplayParameterIndex();
                String dcsServer =prefs.getPreference(prefs.DCS_SERVER_NAME);
                switch(pIndex) {
                  case 8: // T0 and T1
                        subscriptionList.add(new Subscription(dcsServer, ".*"+dcsParams[2]+".*"));
                        subscriptionList.add(new Subscription(dcsServer, ".*"+dcsParams[3]+".*"));
                      refillDCSCache(2);
                      refillDCSCache(3);
                      break;
                  case 9:
                      for(int k=0;k<8;k++) {
                          if(k==2 || k==3) continue;
                            subscriptionList.add(new Subscription(dcsServer, ".*"+dcsParams[k]+".*"));
                          refillDCSCache(k);
                          }
                      break;
                  case 10:
                  // special case IPIN
                  subscriptionList.add(new Subscription(dcsServer, ".*"+dcsParams[8]+".*"));
                      refillDCSCache(8);
                      break;
                  default:
                        subscriptionList.add(new Subscription(dcsServer,".*"+dcsParams[pIndex]+".*"));
                      refillDCSCache(pIndex);
                  }

                break;
           default:
           }

            for (ListIterator i = subscriptionList.listIterator(); i.hasNext(); ) {
                    Subscription s = (Subscription)i.next();
                //System.out.println(is.subscribe(s.getServer(),s.getRegex(),this));
                    if(!is.subscribe(s.getServer(),s.getRegex(),this).matches(".*successful.*")) System.out.println("SctGUI ERROR - failed to subscribe to server "+s.getServer()+" with regex "+s.getRegex());
                }



        } catch (RuntimeException e) {
            System.err.println("SctGUI::ISInterface: Exception in IS subscription: " + e.toString());
        }
//        guiControl.displayPane.setDisplayColors();
//        guiControl.displayPane.refreshDisplay();   
    }

    protected void unsubscribe() {

                if(subscriptionList==null) return;
                is = GuiComponents.System.ISInterface.getInstance();

           for (ListIterator i = subscriptionList.listIterator(); i.hasNext(); ) {
                    Subscription s = (Subscription)i.next();
                //String response = is.unsubscribe(s.getServer(),s.getRegex());
                    //System.out.println(response);
                    if(is.unsubscribe(s.getServer(),s.getRegex()).matches(".*successful.*")) i.remove();
                }
//              subscriptionList.clear();
          for (ListIterator i = subscriptionList.listIterator(); i.hasNext(); ) {
                    Subscription s = (Subscription)i.next();
                        System.out.println("sctGUI ERROR - unsubscribe to server "+s.getServer()+" with regex "+s.getRegex()+" FAILED!");
                }
    }

    public void clearSubscriptions() {  // called if IS servers are destroyed (ie if DAQ gets rebooted)
        if(subscriptionList!=null) subscriptionList.clear();
        }

    public String[] getDBISObjects(int testIndex) {
         return GuiComponents.System.ISInterface.getInstance().getISObjects(SCTDBServer,".*SctRodDaqRefData."+testNames[testIndex]+".*");
         }

    public javax.swing.tree.DefaultMutableTreeNode getISTree() {

        is = GuiComponents.System.ISInterface.getInstance();

        String[] servers = is.getISServers();

        //Setup tree
        
        javax.swing.tree.DefaultMutableTreeNode top = new javax.swing.tree.DefaultMutableTreeNode("IS Servers");
        javax.swing.tree.DefaultMutableTreeNode server;
        javax.swing.tree.DefaultMutableTreeNode object;
        for (int i=0; i<servers.length; i++) {
            server = new javax.swing.tree.DefaultMutableTreeNode(servers[i]);
            String[] objects = is.getISObjects(servers[i],".*");
            for (int j=0; j<objects.length; j++) {
                object = new javax.swing.tree.DefaultMutableTreeNode(objects[j]);
                server.add(object);
            }
            top.add(server);
        }
        return top;
//        trISServers.setModel(new DefaultTreeModel(top));
    }
    
    abstract class StringRunnable implements Runnable {
        protected String name;
        StringRunnable(String name) {
            this.name = name;
        }
    }

    public void infoCreated(InfoEvent e) {
//       System.out.println("created "+e.getName());
       isCounter.addObject(e.getName());
       javax.swing.SwingUtilities.invokeLater(new StringRunnable(e.getName()) {
          public void run() {
//                 System.out.println("queueing object "+name);
                   isRequestBuffer.queueObject(name,true);
             }
        });
    }


    public void infoDeleted(InfoEvent e) {
//       System.out.println("deleted "+e.getName());
       javax.swing.SwingUtilities.invokeLater(new StringRunnable(e.getName()) {
          public void run() {
             if(!infoListenersAreActive) return;
             if(name.startsWith("ControlData")) guiControl.tablesDisplayPane.removeTest(name);
//           System.out.println("ISInteferca infoDeleted, name "+name);
             guiControl.displayPane.setDisplayColors();
             guiControl.displayPane.refreshDisplay();  // just refresh the display
          }
        });
    }

    public void infoUpdated(InfoEvent e) {
//           System.out.println("updated "+e.getName());
        isCounter.updateObject(e.getName());
        javax.swing.SwingUtilities.invokeLater(new StringRunnable(e.getName()) {
          public void run() {  
//          System.out.println("queueing object "+name);
            isRequestBuffer.queueObject(name,false);
            }
        });
    }

//***************************************************************************
   public void removeTests(Vector testObjectNames, int minRow, int maxRow) {
// remove tests from IS
// firstRowNo is the first row number in the test JTable
// lastTestNo is the last

      infoListenersAreActive=false;

        is = GuiComponents.System.ISInterface.getInstance();

      for(int i=maxRow;i>=minRow;i--) {
         String testObjectName = (String)testObjectNames.elementAt(i);
         TestData thisTestData = new TestData();
         is.getRepository().getValue(testObjectName, thisTestData);
// first extract the run number, and scan numbers
         int runNo = thisTestData.runNumber;
         int startScanNumber = thisTestData.startScanNumber;
// form a regular espression
         StringBuffer regex = new StringBuffer(".*(");
         for(int k=thisTestData.startScanNumber;k<thisTestData.startScanNumber+thisTestData.nScans;k++) {
           if(k>thisTestData.startScanNumber) regex.append("|");
           regex.append("\\.");
           regex.append(Integer.toString(runNo));
           regex.append("\\.");
           regex.append(Integer.toString(k));
           regex.append("\\.");
         }
         regex.append(").*");

         String[] deletionObjects;
// check if all data objects are in RetrievedData server or not...
         if(testObjectName.matches("RetrievedData.*")) {
           deletionObjects = is.getISObjects("RetrievedData",regex.toString());
           for(int j=0;j<deletionObjects.length;j++) System.out.println(is.remove(deletionObjects[j]));
           }
         else if(testObjectName.matches("SCTDBData.*")) {
           deletionObjects = is.getISObjects("SCTDBData",regex.toString());
           for(int j=0;j<deletionObjects.length;j++) System.out.println(is.remove(deletionObjects[j]));
           }
         else {
           deletionObjects = is.getISObjects(SctNames.getEventISServer(),regex.toString());
           for(int j=0;j<deletionObjects.length;j++) System.out.println(is.remove(deletionObjects[j]));
           deletionObjects = is.getISObjects(SctNames.getFitISServer(),regex.toString());
           for(int j=0;j<deletionObjects.length;j++) System.out.println(is.remove(deletionObjects[j]));
           deletionObjects = is.getISObjects(SctNames.getTestISServer(),regex.toString());
           for(int j=0;j<deletionObjects.length;j++) System.out.println(is.remove(deletionObjects[j]));
           }

    
// finally, the control object itself
// the object names in the control server do not have a final '.' after the first scan no 
         System.out.println(is.remove(testObjectName));
         guiControl.tablesDisplayPane.removeTest(testObjectName);
        }

       infoListenersAreActive=true;
        
     }
//***************************************************8
        public void removeObjects(Vector objectNames) {
                is = GuiComponents.System.ISInterface.getInstance();
           for(int i=0;i<objectNames.size();i++) System.out.println(is.remove((String)objectNames.elementAt(i)));
           }
//***************************************************8
     public int getListFilterIndex() {
           return listFilterIndex;
           }
        
//****************************************************************************
//     public void setTestFilter(String testObjectName) {
//          if(testObjectName==null) testSelection=null;
//          else testSelection = new TestSelection(testObjectName,testLocation);
//          setIsFilterHeader();
//          setIsFilterRunInfo();
//          if(guiControl.displayStatus.getStatus()==DisplayStatus.IS_MONITOR) resetModuleCount();
//          } 
//*******************************************************
    private String getIsFilterHeader() {
         String isFilterHeader = "SctData::Result";
         int serverIndex = guiControl.selectorPane.getDisplayParameterIndex();
         switch(serverIndex) {
            case 0:
                isFilterHeader = "SctData::RawScanResult";
               break;
            case 1:
                isFilterHeader = "SctData::FitScanResult";
               break;
            case 2:
            default:
               TestSelection testSelection = guiControl.tablesDisplayPane.getTestSelection();
               if(testSelection!=null) {
                  String testName;
                  if((testName=testSelection.getTestName())!=null) isFilterHeader="SctData::"+testName+"Result";
                  }
               break;
            }
         return isFilterHeader;
     }
    private String getIsFilterRunInfo() {
         String isFilterRunInfo="none";
         TestSelection testSelection = guiControl.tablesDisplayPane.getTestSelection();
         if(testSelection==null || testSelection.getTestData()==null) return isFilterRunInfo;
         StringBuffer regex = new StringBuffer("\\."+Integer.toString(testSelection.getRunNo())+"\\.(");
         int startScanNo = testSelection.getStartScanNumber();
         for(int k=startScanNo;k<startScanNo+testSelection.getNoScans();k++) {
           if(k>startScanNo) regex.append("|");
           regex.append(Integer.toString(k));
           regex.append("\\.");
         }
         regex.append(").*"); 
         return regex.toString();
         }
    private String getServerName() {
         int serverIndex = guiControl.selectorPane.getDisplayParameterIndex();
         String serverName=SctNames.getEventISServer();
         switch(serverIndex) {
            case 0:
               serverName=SctNames.getEventISServer();
               break;
            case 1:
               serverName=SctNames.getFitISServer();
               break;
            case 2:
            default:
               serverName=SctNames.getTestISServer();
               break;
            }
          return serverName;
          }

//**************************************************************************
      public String[] getISObjects(String serialNo) {
         return GuiComponents.System.ISInterface.getInstance().getISObjects(getServerName(),getIsFilterHeader()+getIsFilterRunInfo()+serialNo);
         }
//**********************************************************************
    public Hashtable getModuleISCounts() {
       String serverName = getServerName();
       Pattern snPattern = Pattern.compile(serverName+"\\."+getIsFilterHeader()+getIsFilterRunInfo()+"(\\d{14}).*");
       Hashtable thisHash = new Hashtable();
       String[] objects = GuiComponents.System.ISInterface.getInstance().getISObjects(serverName,getIsFilterHeader()+getIsFilterRunInfo()+".*");
       for(int i=0;i<objects.length;i++) {
           Matcher matcher = snPattern.matcher(objects[i]);
           if(matcher.matches()) {
               String sn = objects[i].substring(matcher.start(2),matcher.end(2));
               if(thisHash.containsKey(sn)) {
                   int count = ((Integer)thisHash.get(sn)).intValue();
                   count++;
                   thisHash.put(sn,new Integer(count));
                   }
               else thisHash.put(sn,new Integer(1));
               }
            }
        return thisHash;
        }
        //*****************************************************
     public Vector getDataObjectList(String sn, int type) {
        // return a list of raw data or fitted data objects for module thisCell
        // type=0 raw data, =1 fitted data

       java.util.SortedMap m = new java.util.TreeMap();
       TestSelection testSelection = guiControl.tablesDisplayPane.getTestSelection();
       if(testSelection==null || testSelection.getRunScanRegex()==null) {
          return null;
          }

       java.util.List isList = (java.util.List)isCounter.getModuleList(type,testSelection.getRunScanRegex(),sn,testSelection.isRetrievedData());
       if(isList==null) {  // if not present, probably the iscounter has not yet been invoked
              setISCounter(testSelection.getRunScanRegex());
              isList = (java.util.List)isCounter.getModuleList(type,testSelection.getRunScanRegex(),sn,testSelection.isRetrievedData());
              }
       if(isList==null) {
          return null; // ok there really IS no data
          }

       for (ListIterator i = isList.listIterator(); i.hasNext(); ) {
            String object = (String)i.next();
            String[] objectParts = object.split("\\.");
            Integer runNo = Integer.valueOf(objectParts[2]);
            Integer scanNo = Integer.valueOf(objectParts[3]);
            String fname = objectParts[1];
            m.put(new Integer(runNo.intValue()*10000 + scanNo.intValue()),object);
            }
         return new Vector(m.values());
        }



//*********************************************************************

   public void launchExternalViewer(String name) {
        try {
            ExternalProcess p = new ExternalProcess("DataDisplayer " + name);
        } catch (Exception ioe) {
            System.out.println(ioe.getMessage());
            ioe.printStackTrace();
        }

    }

   public void launchExternalViewerWithOptions(String name) {
            if(plotOptionsFrame==null) plotOptionsFrame = new PlotOptionsFrame();
            plotOptionsFrame.showFrame(name);
    }
    

    public void viewISData(String name) {
        try {
            Serializable ob = ObjectManagerIS.getInstance().readObject(name);
            InspectorPanel p = new InspectorPanel(name, ob);
            //JFrame frame = new JFrame("InspectorPanel");
            //frame.getContentPane().add(p, java.awt.BorderLayout.CENTER);
            //frame.pack();
            //frame.show();

            JFrame frame2 = new JFrame("TreeTable");                    
            frame2.getContentPane().add(new JScrollPane(p.treeTable));
            frame2.pack();
            frame2.show();

        } catch (java.io.IOException ioe) {
            System.err.println("Error reading object from IS: " + ioe + "  " +ioe.getMessage() +"\n");
        }
    }

   public void downloadTests(int index) {
         TestSelection testSelection = guiControl.tablesDisplayPane.getTestSelection();
         if(testSelection==null || testSelection.getTestIndex()==-1) {
              javax.swing.JOptionPane.showMessageDialog(null,"You must select a test in ordre to download sctdaq reference data.");
              return;
              }
         boolean refresh=false;
         if(index==-1) {
           index=testSelection.getTestIndex();
           refresh=true;
           }
         if(index==-1) return;
         if(!testIsSCTDAQ[index]) {
            javax.swing.JOptionPane.showMessageDialog(null,"The selected test is not SCTDAQ compatible, so reference data cannot be downloaded.");
            return;
            }
         SCTDBTestDownloader d = new SCTDBTestDownloader(new Vector(ConfigurationInterface.getInstance().getSerialNumberList(guiControl.selectorPane.getViewCategoryIndex(),guiControl.selectorPane.getViewIndex())),index,testLocation,true,refresh);
         if(d.downloadsRequired() && d.isOkToStart()) d.start();
         }
   public void setLocation(String location) {
        testLocation=location;
        TestSelection testSelection = guiControl.tablesDisplayPane.getTestSelection();
        if(testSelection!=null) testSelection.setSCTDBLocation(testLocation);
        }
   public String getLocation() {
        return testLocation;
        }
   public void uploadAssemblyInfo() {

                ConfigurationInterface conf = ConfigurationInterface.getInstance();

             if(conf.getTotalNumberOfModules()<1) return;
   
             Preferences.PreferencesInterface prefs = Preferences.PreferencesInterface.getInstance();
                String uploadDir = prefs.getPreference(Preferences.PreferencesInterface.UPLOAD_DIR);
                String institute = prefs.getPreference(Preferences.PreferencesInterface.INSTITUTE);
                String password = prefs.getPreference(Preferences.PreferencesInterface.PASSWORD);
                String undefinedstring = Preferences.PreferencesInterface.unDefinedString;

             SCTDBAssemblyChecker a = new SCTDBAssemblyChecker(guiControl,conf.buildSerialNumberMap(), uploadDir, institute, password, undefinedstring);
             if(a.isOkToStart()) a.start();
             }


   public Double getSCTDBData(String resultObject, int testIndex) {
             if(testIndex==-1) return null;
             int parameterIndex = guiControl.selectorPane.getDisplayParameterIndex();
             int option = guiControl.selectorPane.getMouseClickIndex();
             if(parameterIndex<0) return null;
             if(!isSCTDAQCompatible[testIndex][parameterIndex]) return null;
             SummaryReader.Test testResult = getSCTDBTest(resultObject);
             if(testResult==null) return null;
             Double theData=readTestData(testResult,-1,parameterIndex,option);
              return theData;
              }


   public Test getSCTDBTest(String resultObject) {

        SummaryReader.Test testObject;

        testObject = (SummaryReader.Test)cache.get(resultObject);
        if(testObject!=null) return testObject;
        
//      System.out.println(resultObject+" not in cache!");

        try {
        if(!Sct.IS.SctNames.getISRepository().contains(resultObject)) return null;
        SCTDB_Data result = new SCTDB_Data(); 
        Sct.IS.SctNames.getISRepository().getValue(resultObject, result);

        testObject = new Test();

        int blockSize = result.data_m0.length;
        DataBlock dataBlock = new DataBlock("Chip Data",result.data_m0.length,result.testIndex);
        for(int i=0;i<blockSize;i++) {
          dataBlock.add(0,i,result.data_m0[i]);
          dataBlock.add(1,i,result.data_s1[i]);
          dataBlock.add(2,i,result.data_s2[i]);
          dataBlock.add(3,i,result.data_s3[i]);
          dataBlock.add(4,i,result.data_s4[i]);
          dataBlock.add(5,i,result.data_e5[i]);
          dataBlock.add(6,i,result.data_m8[i]);
          dataBlock.add(7,i,result.data_s9[i]);
          dataBlock.add(8,i,result.data_s10[i]);
          dataBlock.add(9,i,result.data_s11[i]);
          dataBlock.add(10,i,result.data_s12[i]);
          dataBlock.add(11,i,result.data_e13[i]);
          }
         testObject.add(dataBlock);
         // DCS
         DCSInfo dcsInfo = new DCSInfo();
         for(int i=0;i<8;i++) if(result.dcsinfo[i]!=SCTDBTestDownloader.NODATA) dcsInfo.put(i,result.dcsinfo[i]);
         testObject.add(dcsInfo);
         // Defects
         for(int i=0;i<result.noDefectChannels;i++) {
           String defectLine = result.defectList[i];
           Matcher matcher = defectPattern.matcher(defectLine);
           if(matcher.matches()) {
              DefectInfo defectInfo = new DefectInfo();
              defectInfo.setFirstChannel(defectLine.substring(matcher.start(1),matcher.end(1)));
              defectInfo.setLastChannel(defectLine.substring(matcher.start(2),matcher.end(2)));
              defectInfo.setName(defectLine.substring(matcher.start(3),matcher.end(3)));
              testObject.add(defectInfo);
              }
           else System.err.println("Unrecognised defect descriptor: "+defectLine);
           }
         // DAQ info
         DAQInfo daqInfo = new DAQInfo();
         for(int i=0;i<5;i++) daqInfo.put(i,result.daqInfo[i]);
         testObject.add(daqInfo);
         // Test Status
         TestInfo testInfo = new TestInfo();
         testInfo.setStatus(new Double(result.status));
         testObject.add(testInfo);
         cache.put(resultObject,testObject);
         return testObject;
         }catch(Exception e){System.err.println("SctGUI: Failed to extract "+resultObject+" : "+e.toString());}
         return null;
         }

     public Double getTestData(String resultObjectHeader, String serialNo,int testIndex, SummaryReader.DCSInfo dcsInfo) {
                  if(testIndex==-1) return null;
                  int parameterIndex = guiControl.selectorPane.getDisplayParameterIndex();
                  int option = guiControl.selectorPane.getMouseClickIndex();
                  if(parameterIndex<0) return null;
                  SummaryReader.Test testResult = getTest(resultObjectHeader,serialNo,dcsInfo);
                  if(testResult==null) return null;
                  Double theData=readTestData(testResult,testIndex,parameterIndex,option);
                  return theData;
                  }

     public Double readTestData(SummaryReader.Test testResult, int testIndex, int parameterIndex, int option) {
                 Double theData=null;
                  switch(guiControl.displayStatus.getStatus()) {
                     case DisplayStatus.IV_DATA:
                         switch(parameterIndex) {
                            case 0: // test status
                              theData = testResult.getTestInfo().getTestStatusData();
                              break;
                             case 1: // Current
                              theData = testResult.getIVData().getCurrent(option);
                              break;
                             case 2:
                              SummaryReader.DCSInfo dcsInfo = testResult.getDCSInfo();
                              if(dcsInfo!=null) theData = dcsInfo.get(option);
                              break;
                             }
                            break;
                      default:
                         switch(parameterIndex) {
                           case 0: // test status
                             theData = testResult.getTestInfo().getTestStatusData();
                             break;
                           case 1: // defect count
                             theData = testResult.noDefects();
                             break;
                           case 2: // bad channel count
                             theData = testResult.getNoBadChannels();
                             break;
                           case 3: // DCS conditions
                             SummaryReader.DCSInfo dcsInfo = testResult.getDCSInfo();
                             if(dcsInfo!=null) theData = dcsInfo.get(option);
                             break;
                           default:
                             theData = (testIndex==TEST_RXTHRESHOLD || testIndex==TEST_RXTHRESHOLDBASEDONCONFIGREGISTER || testIndex==TEST_RXDELAY || testIndex==TEST_TXCURRENT) ? testResult.getLinkInfo().get(option,parameterIndex-4) : testResult.getLastDataBlock().get(option,parameterIndex-4);
                             }
                       }
                   return theData;
                   }
//
// get test data as a single table line
//
     public Vector getTestDataLine(String resultObjectHeader, String serialNo,int testIndex, SummaryReader.DCSInfo dcsInfo) {
                  Vector dataLine = new Vector();
                  dataLine.addElement(serialNo);

                  if(testIndex==-1) return null;
                  int parameterIndex = guiControl.selectorPane.getDisplayParameterIndex();
                  if(parameterIndex<0) return null;
                  SummaryReader.Test testResult = getTest(resultObjectHeader,serialNo,dcsInfo);
                  if(testResult==null) return null;
                  
                  int option = guiControl.selectorPane.getMouseClickIndex();

                  Double theData=null;
                  switch(guiControl.displayStatus.getStatus()) {
                     case DisplayStatus.IV_DATA:
                         switch(parameterIndex) {
                            case 0: // test status
                              theData = testResult.getTestInfo().getTestStatusData();
                              break;
                             case 1: // Current
                              theData = testResult.getIVData().getCurrent(option);
                              break;
                             case 2:
                              dcsInfo = testResult.getDCSInfo();
                              if(dcsInfo!=null) theData = dcsInfo.get(option);
                              break;
                             }
                            if(theData==null) dataLine.addElement(new Double(-1.0));
                            else dataLine.addElement(theData);
                            break;
                      default:
                         switch(parameterIndex) {
                           case 0: // test status
                             theData = testResult.getTestInfo().getTestStatusData();
                            if(theData==null) dataLine.addElement(new Double(-1.0));
                            else dataLine.addElement(theData);
                             break;
                           case 1: // defect count
                             theData = testResult.noDefects();
                            if(theData==null) dataLine.addElement(new Double(-1.0));
                            else dataLine.addElement(theData);
                             break;
                           case 2: // bad channel count
                             theData = testResult.getNoBadChannels();
                            if(theData==null) dataLine.addElement(new Double(-1.0));
                            else dataLine.addElement(theData);
                             break;
                           case 3: // DCS conditions
                             dcsInfo = testResult.getDCSInfo();
                             if(dcsInfo!=null) theData = dcsInfo.get(option);
                            if(theData==null) dataLine.addElement(new Double(-1.0));
                            else dataLine.addElement(theData);
                             break;
                           default:
                             if(testIndex==TEST_RXTHRESHOLD || testIndex==TEST_RXDELAY || testIndex==TEST_RXTHRESHOLDBASEDONCONFIGREGISTER || testIndex==TEST_TXCURRENT ) {
                                 LinkInfo linkInfo = testResult.getLinkInfo();
                                 for(int d=0;d<linkInfo.getSize();d++) {
                                   theData = linkInfo.get(option,d);
                                   if(theData==null) dataLine.addElement(new Double(-1.0));
                                   else dataLine.addElement(theData);
                                   }
                               }

                             else {
                               for(int j=0;j<12;j++) {
                                 theData = testResult.getLastDataBlock().get(j+4,parameterIndex-4);
                                 // if occupancy data, want results as strings
                                 if(parameterIndex==5 && testIndex==TEST_NOISE) {
                                     if(theData==null) dataLine.addElement(new Double(-1.0));
                                     else dataLine.addElement(nfe.format(theData.doubleValue()));
                                     }
                                 else {
                                   if(theData==null) dataLine.addElement(new Double(-1.0));
                                   else dataLine.addElement(theData);
                                   }
                                 }
                                }

                             }
                       }
                   return dataLine;
                   }


     public SummaryReader.IVData getIVData(String resultObjectHeader,String serialNo) {

                  SummaryReader.Test testResult = getTest(resultObjectHeader,serialNo,null);
                  if(testResult==null) return null;
                  else return testResult.getIVData();

                   }


    public Test getTest(String resultObjectHeader, String serialNo,SummaryReader.DCSInfo dcsInfo) {
             String resultObject = resultObjectHeader+serialNo;
             SummaryReader.Test testObject = (SummaryReader.Test)cache.get(resultObject);
             if(testObject!=null) return testObject;


             try {
               if(!Sct.IS.SctNames.getISRepository().contains(resultObject)) return null;
               TestSummaryIS result = new TestSummaryIS();
               Sct.IS.SctNames.getISRepository().getValue(resultObject, result);
               SummaryReader.Reader reader = new SummaryReader.Reader(serialNo,result.dataString,dcsInfo);
               cache.put(resultObject,reader.getTest());
               return reader.getTest();
               }catch(Exception e){System.err.println("SctGUI: Failed to extract "+resultObject+" : "+e.toString());}
             return null;
             }


   public void fillDCSMap(String objectName) {
      ConfigurationInterface config = ConfigurationInterface.getInstance();
      if(!config.isDCSAvailable()) return;
      try {
      Map snMap = new HashMap();
       for (java.util.Iterator m = config.getSerialNumberList(guiControl.selectorPane.getViewCategoryIndex(),guiControl.selectorPane.getViewIndex()).iterator(); m.hasNext(); ) {
           String sn=(String)m.next();
           SummaryReader.DCSInfo dcsInfo = new SummaryReader.DCSInfo();
           for(int i=0;i<dcsParams.length;i++) {
                Double thisData = readDCSData(sn,i);
                if(thisData!=null) dcsInfo.put(i,thisData.doubleValue());
                }
           snMap.put(sn,dcsInfo);
           }
       dcsMap.put(objectName,snMap);
      }catch(Exception e){System.err.println("SctGUI: Failed to extract DCS data");}

      }
      

  public Double getDCSData(String sn, int parameterIndex) {
         switch(parameterIndex) {
           case 8:
              SummaryReader.DCSInfo dcsInfo = new SummaryReader.DCSInfo();
              for(int i=2;i<=3;i++) {
                 Double thisData = readDCSData(sn,i);
                 if(thisData!=null) dcsInfo.put(i,thisData.doubleValue());
                 }
              return dcsInfo.get(parameterIndex);

           case 9: // for TDiff and Power, need to read all params
              dcsInfo = new SummaryReader.DCSInfo();
              for(int i=0;i<dcsParams.length;i++) {
                if(i==2 || i==3) continue;    // dont need T0 and T1
                Double thisData = readDCSData(sn,i);
                if(thisData!=null) dcsInfo.put(i,thisData.doubleValue());
                }
               return dcsInfo.get(parameterIndex);
           case 10:
                return readDCSData(sn,8);
           default:
               return readDCSData(sn,parameterIndex);
           }
        }




   public Double readDCSData(String sn, int parameterIndex) {
         String dcsHeader = ConfigurationInterface.getInstance().getSNInfo(sn,SNInfo.DCS_HEADER);
         if(dcsHeader==null) return null;
         String ISObject = prefs.getPreference(prefs.DCS_SERVER_NAME)+"."+dcsHeader+dcsParams[parameterIndex]+".Recv";
         Double dcsData = readDCSData(ISObject);
         if(dcsData!=null && parameterIndex==SummaryReader.DCSInfo.IDET) {  // convert from nA to uA
                  double iInMicroAmps = dcsData.doubleValue()/1000.;
                  try {
                    dcsData =  Double.valueOf(nf.format(iInMicroAmps));
                    }catch(Exception e){dcsData=null;}
                  }
         return dcsData;
         }

   public Double readDCSData(String ISObjectName) {
   // get the DCS data from the dcsCache
   // if it is not there, read it from IS and update the dcsCache
   
         Double theData = (Double)dcsCache.get(ISObjectName);
         if(theData==null) {

            try {
              ConfigurationInterface config = ConfigurationInterface.getInstance();
              if(!config.isDCSAvailable()) return null;
 //             if(!Sct.IS.SctNames.getISRepository().contains(ISObjectName)) return null;
              is.AnyInfo theValue = new is.AnyInfo();
              Sct.IS.SctNames.getISRepository().getValue(ISObjectName, theValue);
              double dData = ((Float)theValue.getAttribute(theValue.getAttributeCount()-1)).doubleValue();
              theData =  Double.valueOf(nf.format(dData));
              if(theData!=null) dcsCache.put(ISObjectName,theData);
            }catch(Exception e){return null;}
           }

         return theData;
         }

   public void fillDCSCache() {
//         System.out.println("fill DCS cache ");
         try {
         Set newDCSDataSet = isCounter.getDCSObjectList();
//       System.out.println("size of update = "+newDCSDataSet.size());
         for (Iterator i = newDCSDataSet.iterator(); i.hasNext(); ) {
                String ISObject = (String)i.next();
                if(!Sct.IS.SctNames.getISRepository().contains(ISObject)) continue;
//              System.out.println("filling DCS Cache for object "+ISObject);
                is.AnyInfo theValue = new is.AnyInfo();
                Sct.IS.SctNames.getISRepository().getValue(ISObject, theValue);
                double theData = ((Float)theValue.getAttribute(theValue.getAttributeCount()-1)).doubleValue();
                dcsCache.put(ISObject,Double.valueOf(nf.format(theData)));
                }
         }catch(Exception e){System.err.println("Exception filling DCS cache - "+e.toString());}
         }

    public void refillDCSCache(int parameterIndex) {
//        System.out.println("refilling DCS Cache");
        ConfigurationInterface config = ConfigurationInterface.getInstance();
        String DCS_Server_Name = prefs.getPreference(prefs.DCS_SERVER_NAME);
        try {
       for (java.util.Iterator m = config.getSerialNumberList(guiControl.selectorPane.getViewCategoryIndex(),guiControl.selectorPane.getViewIndex()).iterator(); m.hasNext(); ) {
               String sn=(String)m.next();
               String dcsHeader = config.getSNInfo(sn,SNInfo.DCS_HEADER);
               if(dcsHeader==null) continue;
               String ISObject = DCS_Server_Name+"."+dcsHeader+dcsParams[parameterIndex]+".Recv";
               if(!Sct.IS.SctNames.getISRepository().contains(ISObject)) continue;
//             System.out.println("Refilling DCS Cache for object "+ISObject);
               is.AnyInfo theValue = new is.AnyInfo();
               Sct.IS.SctNames.getISRepository().getValue(ISObject, theValue);
               double theData = ((Float)theValue.getAttribute(theValue.getAttributeCount()-1)).doubleValue();
               dcsCache.put(ISObject,Double.valueOf(nf.format(theData)));
               }
            }
        catch(Exception ee) {System.err.println("SctGUI::ISInterface - exception retrieving DCS Data: "+ee.toString());}
        }



    public Map getDCSMap(String controlObjectName) {
       return (Map)dcsMap.get(controlObjectName);
       }
    public void setCacheSize(int size) {
       cache = new guiUtilities.Cache(size);
       }
 



     private GuiComponents.System.ISInterface is;


}

---