Main Page | Packages | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | Related Pages

ISInterface.java

00001 package DisplayGUI;
00002 
00003 import java.io.*;
00004 import java.util.*;
00005 import javax.swing.*;
00006 import javax.swing.text.*;
00007 import java.util.regex.*;
00008 import is.*;
00009 import Sct.Serializable;
00010 import Sct.IS.*;
00011 import GuiComponents.Console.ExternalProcess;
00012 import GuiComponents.Inspector.InspectorPanel;
00013 import Sct_CalibrationController.TestData;
00014 import GuiComponents.System.*;
00015 import SummaryReader.*;
00016 
00017 /*
00018  * ISInterface.java
00019  *
00020  */
00021 
00026 public class ISInterface implements TestDataInfo,InfoListener {
00027     
00028     gui guiControl;
00029  
00030     ISRequestBuffer isRequestBuffer;
00031     ISCounter isCounter;
00032 
00033     Hashtable serverHash;  // hash to keep track of which servers we are subscribed to...
00034     String theObjectName;
00035 //    String isFilterHeader;
00036 //    String isFilterRunInfo;
00037     TestData testData;       // the currently selected test
00038     String serverName;       // the currently selected server name
00039     int noScans;             // the number of scans in the currently selected test
00040 
00041     int listFilterIndex;
00042 
00043     String eventServerRegex;      // regex for event server objects
00044     String fitServerRegex;        //regex for fit server objects
00045     String controlObjectRegex;          //regex for control data
00046     String rControlObjectRegex;
00047     String dbControlObjectRegex;   // regex for database control data
00048     String testServerRegex;          //regex for test server objects
00049     Pattern objectPattern, rObjectPattern;
00050     String resultObjectRegex;     // regex for test Summary objects
00051     String ivscanRegex;  // regex for ivscan objects
00052     String ivscanControlRegex;
00053 
00054     String eventServer;
00055     String fitServer;
00056     String testServer;
00057     String controlServer;
00058     String SCTDBServer;
00059     String retrievedArchiveServer;
00060 
00061     String testLocation;     // the test location for SCTDB downloads
00062 
00063     int serverIndex=0;        // the currently selected server
00064 
00065     boolean infoListenersAreActive=true;
00066 
00067 //    Vector infoListenerQueue = new Vector();
00068 
00069     java.util.Map moduleCount = new HashMap();
00070 
00071     Pattern defectPattern = Pattern.compile("(\\d+)-(\\d+)\\s*:\\s*(\\w+)");
00072     guiUtilities.Cache cache=null;
00073     Map dcsMap = new HashMap();
00074     
00075     java.text.DecimalFormat nf = new java.text.DecimalFormat("#.###");
00076 
00077     Preferences.PreferencesInterface prefs;
00078 
00079     PlotOptionsFrame plotOptionsFrame=null;
00080 
00081     public ISInterface(gui parent) {
00082         guiControl=parent;
00083 
00084         prefs = Preferences.PreferencesInterface.getInstance();
00085 
00086         isRequestBuffer = new ISRequestBuffer(guiControl);
00087 
00088         is = GuiComponents.System.ISInterface.getInstance();
00089         isCounter = new ISCounter();
00090         serverHash = new Hashtable();
00091         noScans=0;
00092         listFilterIndex=-1;
00093 
00094         eventServerRegex = ".*RawScanResult.*[0-9]+\\.[0-9]+(\\.[0-9]{14})?";
00095         fitServerRegex = ".*FitScanResult.*[0-9]+\\.[0-9]+(\\.[0-9]{14})?";
00096         testServerRegex = ".*Result.*[0-9]+\\.[0-9]+(\\.[0-9]{14})?";
00097         controlObjectRegex = "TestData\\.[0-9]+\\.[0-9]+";
00098         rControlObjectRegex = "TestData\\.[0-9]+\\.[0-9]+.*Test";
00099         dbControlObjectRegex = "ControlData.TestData\\.[0-9]+\\.[0-9]+";
00100         resultObjectRegex = ".*(Summary).*";
00101         ivscanRegex = ".*IVScanData.*";
00102         ivscanControlRegex = ".*ControlIVScanData.*";
00103 
00104         objectPattern = Pattern.compile(".*TestData\\.[0-9]+\\.[0-9]+");
00105         rObjectPattern = Pattern.compile(".*\\.[0-9]+\\.[0-9]+.*Test");
00106 
00107         eventServer = SctNames.getEventISServer();
00108         fitServer = SctNames.getFitISServer();
00109         testServer = SctNames.getTestISServer();
00110         controlServer = SctNames.getControlISServer();
00111         SCTDBServer = "SCTDBData";
00112         retrievedArchiveServer = "RetrievedData";
00113 
00114         testLocation="Any";
00115 
00116         if(cache==null) setCacheSize(200);
00117 
00118 
00119     }
00120     protected void subscribe() {
00121         subscribe(-1);
00122         }
00123 
00124     public void setISCounter(String regex) {
00125         isCounter.refresh(regex);
00126         }
00127         
00128     protected void subscribe(int testType) {
00129         listFilterIndex=testType;
00130         String[] objects;
00131         Vector ISTests = new Vector();
00132  
00133         try {
00134 
00135         switch(guiControl.displayStatus.getStatus()) {
00136            case DisplayStatus.SCTDB_RODDAQ_DATA:
00137               objects = is.getISObjects(SCTDBServer,dbControlObjectRegex);
00138               for(int i=0;i<objects.length;i++) ISTests.addElement(objects[i]);
00139               break;
00140            case DisplayStatus.IV_DATA:
00141               objects = is.getISObjects(retrievedArchiveServer,ivscanControlRegex);
00142               for(int i=0;i<objects.length;i++) ISTests.addElement(objects[i]);
00143               break;
00144             default:
00145               objects = is.getISObjects(retrievedArchiveServer,rControlObjectRegex);
00146               for(int i=0;i<objects.length;i++) ISTests.addElement(objects[i]);
00147               objects = is.getISObjects(controlServer,controlObjectRegex);
00148               for(int i=0;i<objects.length;i++) ISTests.addElement(objects[i]);
00149               }
00150 
00151          if(guiControl.displayStatus.getStatus()!=DisplayStatus.IV_DATA) {
00152            for(int j=ISTests.size()-1;j>=0;j--) {
00153               String controlObject = (String)ISTests.elementAt(j);
00154               Matcher matcher = objectPattern.matcher(controlObject);
00155               Matcher matcher2 = rObjectPattern.matcher(controlObject);
00156               if(!matcher.matches() && !matcher2.matches()) {
00157                  ISTests.removeElementAt(j);
00158                  continue;
00159                  }
00160               if(listFilterIndex==-1) continue;
00161               else {
00162                  TestData testData = new TestData(); 
00163                  is.getRepository().getValue(controlObject, testData); 
00164                  String thisTestName = (listFilterIndex==TEST_3PTGAIN) ? testNames[TEST_NPTGAIN] : testNames[listFilterIndex];
00165                  if(testData.testName.indexOf(thisTestName)==-1) ISTests.removeElementAt(j);
00166                  }
00167               }  
00168              }
00169         guiControl.tablesDisplayPane.setTestTable(ISTests);
00170 
00171          switch(guiControl.displayStatus.getStatus()) {
00172           case DisplayStatus.IS_MONITOR:
00173 
00174 
00175             if(!serverHash.containsKey(eventServer)) {
00176               is.subscribe(eventServer, eventServerRegex, true, this);
00177               serverHash.put(eventServer, eventServerRegex);
00178               }
00179             if(!serverHash.containsKey(fitServer)) {
00180               is.subscribe(fitServer, fitServerRegex, true, this);
00181               serverHash.put(fitServer, fitServerRegex);
00182               }
00183             if(!serverHash.containsKey(testServer)) {
00184               is.subscribe(testServer, testServerRegex, true, this);
00185               serverHash.put(testServer, testServerRegex);
00186               }
00187             if(!serverHash.containsKey(controlServer)) {
00188              is.subscribe(controlServer, controlObjectRegex, true, this);
00189              serverHash.put(controlServer, controlObjectRegex);
00190              }
00191             if(!serverHash.containsKey(retrievedArchiveServer)) {
00192              List subscriptions = new ArrayList();
00193              subscriptions.add(rControlObjectRegex);
00194              subscriptions.add(fitServerRegex);
00195              subscriptions.add(eventServerRegex);
00196              subscriptions.add(testServerRegex);  
00197              for (ListIterator i = subscriptions.listIterator(); i.hasNext(); ) {
00198                 is.subscribe(retrievedArchiveServer, (String)i.next(), true, this);
00199                 }           
00200              serverHash.put(retrievedArchiveServer, subscriptions);
00201              }
00202 
00203             break;
00204 
00205           case DisplayStatus.TEST_DATA:
00206              if(!serverHash.containsKey(testServer)) {
00207                is.subscribe(testServer, resultObjectRegex, true, this);
00208                serverHash.put(testServer, resultObjectRegex);
00209              }
00210              if(!serverHash.containsKey(controlServer)) {
00211                is.subscribe(controlServer, controlObjectRegex, true, this);
00212                serverHash.put(controlServer, controlObjectRegex);
00213                }
00214             if(!serverHash.containsKey(retrievedArchiveServer)) {
00215              List subscriptions = new ArrayList();
00216              subscriptions.add(resultObjectRegex);
00217              subscriptions.add(rControlObjectRegex);
00218              for (ListIterator i = subscriptions.listIterator(); i.hasNext(); ) {
00219                 is.subscribe(retrievedArchiveServer, (String)i.next(), true, this);
00220                 }           
00221              serverHash.put(retrievedArchiveServer, subscriptions);
00222              }
00223 
00224 
00225 
00226              break;
00227           case DisplayStatus.SCTDB_DATA:
00228              if(!serverHash.containsKey(controlServer)) {
00229                is.subscribe(controlServer, controlObjectRegex, true, this);
00230                serverHash.put(controlServer, controlObjectRegex);
00231                }
00232              if(!serverHash.containsKey(SCTDBServer)) {
00233                is.subscribe(SCTDBServer, ".*", true, this);
00234                serverHash.put(SCTDBServer, ".*");
00235                }
00236               break;
00237           case DisplayStatus.SCTDB_RODDAQ_DATA:
00238              if(!serverHash.containsKey(SCTDBServer)) {
00239                is.subscribe(SCTDBServer, ".*", true, this);
00240                serverHash.put(SCTDBServer, ".*");
00241                }
00242               break;
00243           case DisplayStatus.IV_DATA:
00244              if(!serverHash.containsKey(retrievedArchiveServer)) {
00245                List subscriptions = new ArrayList();
00246                subscriptions.add(ivscanRegex);
00247                is.subscribe(retrievedArchiveServer, ivscanRegex, true, this);
00248                serverHash.put(retrievedArchiveServer, subscriptions);
00249                }
00250               break;
00251           case DisplayStatus.DCS_DATA:
00252 
00253                 Preferences.PreferencesInterface prefs = Preferences.PreferencesInterface.getInstance();
00254                 if(!serverHash.containsKey(prefs.getPreference(prefs.DCS_SERVER_NAME))) {
00255                         is.subscribe(prefs.getPreference(prefs.DCS_SERVER_NAME),".*",true,this);
00256                         serverHash.put(prefs.getPreference(prefs.DCS_SERVER_NAME),".*");
00257                         }
00258                 break;
00259            default:
00260            }
00261 
00262 
00263 
00264         } catch (RuntimeException e) {
00265             System.err.println("SctGUI::ISInterface: Exception in IS subscription: " + e.toString());
00266         }
00267 //        guiControl.displayPane.setDisplayColors();
00268 //        guiControl.displayPane.refreshDisplay();   
00269     }
00270 
00271     protected void unsubscribe() {
00272             if(serverHash.containsKey(retrievedArchiveServer)) {
00273                 List subscriptions = (List)serverHash.get(retrievedArchiveServer);
00274                 for (ListIterator i = subscriptions.listIterator(); i.hasNext(); ) {
00275                   is.unsubscribe(retrievedArchiveServer, (String)i.next());
00276 //                 System.out.println(is.unsubscribe(retrievedArchiveServer, (String)i.next()));
00277                   }  
00278                 serverHash.remove(retrievedArchiveServer);
00279                 }
00280 
00281             for(Enumeration e = serverHash.keys(); e.hasMoreElements();) {
00282                String server = (String)e.nextElement();
00283                String pattern = (String)serverHash.get(server);
00284                is.unsubscribe(server, pattern);
00285 //               System.out.println(is.unsubscribe(server, pattern));
00286                }
00287             serverHash = new Hashtable();
00288     }
00289 
00290     public javax.swing.tree.DefaultMutableTreeNode getISTree() {
00291 
00292         String[] servers = is.getISServers();        
00293         
00294         //Setup tree
00295         
00296         javax.swing.tree.DefaultMutableTreeNode top = new javax.swing.tree.DefaultMutableTreeNode("IS Servers");
00297         javax.swing.tree.DefaultMutableTreeNode server;
00298         javax.swing.tree.DefaultMutableTreeNode object;
00299         for (int i=0; i<servers.length; i++) {
00300             server = new javax.swing.tree.DefaultMutableTreeNode(servers[i]);
00301             String[] objects = is.getISObjects(servers[i],".*");
00302             for (int j=0; j<objects.length; j++) {
00303                 object = new javax.swing.tree.DefaultMutableTreeNode(objects[j]);
00304                 server.add(object);
00305             }
00306             top.add(server);
00307         }
00308         return top;
00309 //        trISServers.setModel(new DefaultTreeModel(top));
00310     }
00311     
00315     abstract class StringRunnable implements Runnable {
00316         protected String name;
00317         StringRunnable(String name) {
00318             this.name = name;
00319         }       
00320     }
00321     
00322     public void infoCreated(InfoEvent e) {
00323        isCounter.addObject(e.getName());
00324        javax.swing.SwingUtilities.invokeLater(new StringRunnable(e.getName()) {
00325           public void run() {
00326                    isRequestBuffer.queueObject(name,true);
00327              }
00328         });
00329     }   
00330     
00331     
00332     public void infoDeleted(InfoEvent e) {
00333        javax.swing.SwingUtilities.invokeLater(new StringRunnable(e.getName()) {
00334           public void run() {   
00335              if(!infoListenersAreActive) return;
00336              if(name.startsWith("ControlData")) guiControl.tablesDisplayPane.removeTest(name);
00337              guiControl.displayPane.setDisplayColors();
00338              guiControl.displayPane.refreshDisplay();  // just refresh the display
00339           }
00340         });
00341     }
00342     
00343     public void infoUpdated(InfoEvent e) {
00344         javax.swing.SwingUtilities.invokeLater(new StringRunnable(e.getName()) {
00345           public void run() {  
00346             isRequestBuffer.queueObject(name,false);
00347             }
00348         });
00349     }
00350 
00351 //***************************************************************************
00352    public void removeTests(Vector testObjectNames, int minRow, int maxRow) {
00353 // remove tests from IS
00354 // firstRowNo is the first row number in the test JTable
00355 // lastTestNo is the last
00356 
00357       infoListenersAreActive=false;
00358 
00359       for(int i=maxRow;i>=minRow;i--) {
00360          String testObjectName = (String)testObjectNames.elementAt(i);
00361          TestData thisTestData = new TestData(); 
00362          is.getRepository().getValue(testObjectName, thisTestData); 
00363 // first extract the run number, and scan numbers
00364          int runNo = thisTestData.runNumber;
00365          int startScanNumber = thisTestData.startScanNumber;
00366 // form a regular espression
00367          StringBuffer regex = new StringBuffer(".*(");
00368          for(int k=thisTestData.startScanNumber;k<thisTestData.startScanNumber+thisTestData.nScans;k++) {
00369            if(k>thisTestData.startScanNumber) regex.append("|");
00370            regex.append("\\.");
00371            regex.append(Integer.toString(runNo));
00372            regex.append("\\.");
00373            regex.append(Integer.toString(k));
00374            regex.append("\\.");
00375          }
00376          regex.append(").*");
00377       
00378          String[] deletionObjects;
00379 // check if all data objects are in RetrievedData server or not...
00380          if(!testObjectName.matches("RetrievedData.*")) {
00381            deletionObjects = is.getISObjects(SctNames.getEventISServer(),regex.toString());
00382            for(int j=0;j<deletionObjects.length;j++) System.out.println(is.remove(deletionObjects[j]));
00383            deletionObjects = is.getISObjects(SctNames.getFitISServer(),regex.toString());
00384            for(int j=0;j<deletionObjects.length;j++) System.out.println(is.remove(deletionObjects[j])); 
00385            deletionObjects = is.getISObjects(SctNames.getTestISServer(),regex.toString());
00386            for(int j=0;j<deletionObjects.length;j++) System.out.println(is.remove(deletionObjects[j]));  
00387            }
00388          else {
00389            deletionObjects = is.getISObjects("RetrievedData",regex.toString());
00390            for(int j=0;j<deletionObjects.length;j++) System.out.println(is.remove(deletionObjects[j]));  
00391            }
00392     
00393 // finally, the control object itself
00394 // the object names in the control server do not have a final '.' after the first scan no 
00395          System.out.println(is.remove(testObjectName)); 
00396          guiControl.tablesDisplayPane.removeTest(testObjectName);
00397         }
00398 
00399        infoListenersAreActive=true;
00400         
00401      }
00402 //***************************************************8
00403         public void removeObjects(Vector objectNames) {
00404            for(int i=0;i<objectNames.size();i++) System.out.println(is.remove((String)objectNames.elementAt(i)));
00405            }
00406 //***************************************************8
00407      public int getListFilterIndex() {
00408            return listFilterIndex;
00409            }
00410         
00411 //****************************************************************************
00412 //     public void setTestFilter(String testObjectName) {
00413 //          if(testObjectName==null) testSelection=null;
00414 //          else testSelection = new TestSelection(testObjectName,testLocation);
00415 //          setIsFilterHeader();
00416 //          setIsFilterRunInfo();
00417 //          if(guiControl.displayStatus.getStatus()==DisplayStatus.IS_MONITOR) resetModuleCount();
00418 //          } 
00419 //*******************************************************
00420     private String getIsFilterHeader() {
00421          String isFilterHeader = "SctData::Result";
00422          int serverIndex = guiControl.selectorPane.getDisplayParameterIndex();
00423          switch(serverIndex) {
00424             case 0:
00425                 isFilterHeader = "SctData::RawScanResult";
00426                break;
00427             case 1:
00428                 isFilterHeader = "SctData::FitScanResult";
00429                break;
00430             case 2:
00431             default:
00432                TestSelection testSelection = guiControl.tablesDisplayPane.getTestSelection();
00433                if(testSelection!=null) {
00434                   String testName;
00435                   if((testName=testSelection.getTestName())!=null) isFilterHeader="SctData::"+testName+"Result";
00436                   }
00437                break;
00438             } 
00439          return isFilterHeader;
00440      }
00441     private String getIsFilterRunInfo() {
00442          String isFilterRunInfo="none";
00443          TestSelection testSelection = guiControl.tablesDisplayPane.getTestSelection();
00444          if(testSelection==null || testSelection.getTestData()==null) return isFilterRunInfo;
00445          StringBuffer regex = new StringBuffer("\\."+Integer.toString(testSelection.getRunNo())+"\\.(");
00446          int startScanNo = testSelection.getStartScanNumber();
00447          for(int k=startScanNo;k<startScanNo+testSelection.getNoScans();k++) {
00448            if(k>startScanNo) regex.append("|");
00449            regex.append(Integer.toString(k));
00450            regex.append("\\.");
00451          }
00452          regex.append(").*"); 
00453          return regex.toString();
00454          }
00455     private String getServerName() {
00456          int serverIndex = guiControl.selectorPane.getDisplayParameterIndex();
00457          String serverName=SctNames.getEventISServer();
00458          switch(serverIndex) {
00459             case 0:
00460                serverName=SctNames.getEventISServer();
00461                break;
00462             case 1:
00463                serverName=SctNames.getFitISServer();
00464                break;
00465             case 2:
00466             default:
00467                serverName=SctNames.getTestISServer();
00468                break;
00469             }
00470           return serverName;
00471           }
00472 
00473 //**************************************************************************
00474       public String[] getISObjects(String serialNo) {
00475          return is.getISObjects(getServerName(),getIsFilterHeader()+getIsFilterRunInfo()+serialNo);
00476          }
00477 //**********************************************************************
00478     public Hashtable getModuleISCounts() {
00479        String serverName = getServerName();
00480        Pattern snPattern = Pattern.compile(serverName+"\\."+getIsFilterHeader()+getIsFilterRunInfo()+"(\\d{14}).*");
00481        Hashtable thisHash = new Hashtable();
00482        String[] objects = is.getISObjects(serverName,getIsFilterHeader()+getIsFilterRunInfo()+".*");
00483        for(int i=0;i<objects.length;i++) {
00484            Matcher matcher = snPattern.matcher(objects[i]);
00485            if(matcher.matches()) {
00486                String sn = objects[i].substring(matcher.start(2),matcher.end(2));
00487                if(thisHash.containsKey(sn)) {
00488                    int count = ((Integer)thisHash.get(sn)).intValue();
00489                    count++;
00490                    thisHash.put(sn,new Integer(count));
00491                    }
00492                else thisHash.put(sn,new Integer(1));
00493                }
00494             }
00495         return thisHash;
00496         }
00497 
00498 
00499 
00500 //*********************************************************************
00501 
00502    public void launchExternalViewer(String name) {
00503         try {
00504             ExternalProcess p = new ExternalProcess("DataDisplayer " + name);                                    
00505         } catch (Exception ioe) {
00506             System.out.println(ioe.getMessage());
00507             ioe.printStackTrace();
00508         }
00509 
00510     }
00511 
00512    public void launchExternalViewerWithOptions(String name) {
00513             if(plotOptionsFrame==null) plotOptionsFrame = new PlotOptionsFrame();
00514             plotOptionsFrame.showFrame(name);
00515     }
00516     
00517 
00518     public void viewISData(String name) {
00519         try {
00520             Serializable ob = ObjectManagerIS.getInstance().readObject(name);
00521             InspectorPanel p = new InspectorPanel(name, ob);
00522             //JFrame frame = new JFrame("InspectorPanel");
00523             //frame.getContentPane().add(p, java.awt.BorderLayout.CENTER);
00524             //frame.pack();
00525             //frame.show();
00526 
00527             JFrame frame2 = new JFrame("TreeTable");                    
00528             frame2.getContentPane().add(new JScrollPane(p.treeTable));
00529             frame2.pack();
00530             frame2.show();
00531 
00532         } catch (java.io.IOException ioe) {
00533             System.err.println("Error reading object from IS: " + ioe + "  " +ioe.getMessage() +"\n");
00534         }
00535     }
00536 
00537    public void downloadTests(int index) {
00538          TestSelection testSelection = guiControl.tablesDisplayPane.getTestSelection();
00539          if(testSelection==null || testSelection.getTestIndex()==-1) {
00540               javax.swing.JOptionPane.showMessageDialog(null,"You must select a test in ordre to download sctdaq reference data.");
00541               return;
00542               }
00543          boolean refresh=false;
00544          if(index==-1) {
00545            index=testSelection.getTestIndex();
00546            refresh=true;
00547            }
00548          if(index==-1) return;
00549          if(!testIsSCTDAQ[index]) {
00550             javax.swing.JOptionPane.showMessageDialog(null,"The selected test is not SCTDAQ compatible, so reference data cannot be downloaded.");
00551             return;
00552             }
00553          SCTDBTestDownloader d = new SCTDBTestDownloader(new Vector(guiControl.config.getSortedVector(guiControl.displayPane.getSCTView())),index,testLocation,true,refresh);
00554          if(d.downloadsRequired() && d.isOkToStart()) d.start();
00555          }
00556    public void setLocation(String location) {
00557         testLocation=location;
00558         TestSelection testSelection = guiControl.tablesDisplayPane.getTestSelection();
00559         if(testSelection!=null) testSelection.setSCTDBLocation(testLocation);
00560         }
00561    public String getLocation() {
00562         return testLocation;
00563         }
00564    public void uploadAssemblyInfo() {
00565    
00566              if(ConfigurationInterface.getInstance().getTotalNumberOfModules()<1) return;
00567    
00568              Preferences.PreferencesInterface prefs = Preferences.PreferencesInterface.getInstance();
00569              String uploadDir = prefs.getPreference(Preferences.PreferencesInterface.UPLOAD_DIR);
00570              String institute = prefs.getPreference(Preferences.PreferencesInterface.INSTITUTE);
00571              String password = prefs.getPreference(Preferences.PreferencesInterface.PASSWORD);
00572              String undefinedstring = Preferences.PreferencesInterface.unDefinedString;
00573              SCTDBAssemblyChecker a = new SCTDBAssemblyChecker(guiControl,ConfigurationInterface.getInstance().getSerialNumberMap(), uploadDir, institute, password, undefinedstring);
00574              if(a.isOkToStart()) a.start();
00575              }
00576 
00577 
00578    public Double getSCTDBData(String resultObject, int testIndex) {
00579              if(testIndex==-1) return null;
00580              int parameterIndex = guiControl.selectorPane.getDisplayParameterIndex();
00581              int option = guiControl.selectorPane.getMouseClickIndex();
00582              if(parameterIndex<0) return null;
00583              SummaryReader.Test testResult = getSCTDBTest(resultObject);
00584              if(testResult==null) return null;
00585              Double theData=readTestData(testResult,-1,parameterIndex,option);
00586               return theData;
00587               }
00588               
00589 //   public Double readSCTDBData(SummaryReader.Test testResult, int parameterIndex, int option) {
00590 //             Double theData=null;
00591 //                  switch(parameterIndex) {
00592 //                    case 0: // test status
00593 //                      theData = testResult.getTestInfo().getTestStatusData();
00594 //                      break;
00595 //                    case 1: // defect count
00596 //                      theData = testResult.noDefects();
00597 //                      break;
00598 //                  case 2: // bad channel count
00599 //                      theData = testResult.getNoBadChannels();
00600 //                      break;
00601 //                    case 3: // DCS conditions
00602 //                      SummaryReader.DCSInfo dcsInfo = testResult.getDCSInfo();
00603 //                      if(dcsInfo!=null) theData = dcsInfo.get(option);
00604 //                      break;
00605 //                    default:
00606 //                      theData = testResult.getLastDataBlock().get(option,parameterIndex-4);
00607 //                    }
00608 //              return theData;
00609 //              }
00610 
00611 
00612    public Test getSCTDBTest(String resultObject) {
00613 
00614         SummaryReader.Test testObject;
00615 
00616         testObject = (SummaryReader.Test)cache.get(resultObject);
00617         if(testObject!=null) return testObject;
00618 
00619         try {
00620         if(!Sct.IS.SctNames.getISRepository().contains(resultObject)) return null;
00621         SCTDB_Data result = new SCTDB_Data(); 
00622         Sct.IS.SctNames.getISRepository().getValue(resultObject, result); 
00623 
00624         testObject = new Test();
00625 
00626         int blockSize = result.data_m0.length;
00627         DataBlock dataBlock = new DataBlock("Chip Data",result.data_m0.length,result.testIndex);
00628         for(int i=0;i<blockSize;i++) {
00629           dataBlock.add(0,i,result.data_m0[i]);
00630           dataBlock.add(1,i,result.data_s1[i]);
00631           dataBlock.add(2,i,result.data_s2[i]);
00632           dataBlock.add(3,i,result.data_s3[i]);
00633           dataBlock.add(4,i,result.data_s4[i]);
00634           dataBlock.add(5,i,result.data_e5[i]);
00635           dataBlock.add(6,i,result.data_m8[i]);
00636           dataBlock.add(7,i,result.data_s9[i]);
00637           dataBlock.add(8,i,result.data_s10[i]);
00638           dataBlock.add(9,i,result.data_s11[i]);
00639           dataBlock.add(10,i,result.data_s12[i]);
00640           dataBlock.add(11,i,result.data_e13[i]);
00641           }
00642          testObject.add(dataBlock);
00643          // DCS
00644          DCSInfo dcsInfo = new DCSInfo();
00645          for(int i=0;i<8;i++) if(result.dcsinfo[i]!=SCTDBTestDownloader.NODATA) dcsInfo.put(i,result.dcsinfo[i]);
00646          testObject.add(dcsInfo);
00647          // Defects
00648          for(int i=0;i<result.noDefectChannels;i++) {
00649            String defectLine = result.defectList[i];
00650            Matcher matcher = defectPattern.matcher(defectLine);
00651            if(matcher.matches()) {
00652               DefectInfo defectInfo = new DefectInfo();
00653               defectInfo.setFirstChannel(defectLine.substring(matcher.start(1),matcher.end(1)));
00654               defectInfo.setLastChannel(defectLine.substring(matcher.start(2),matcher.end(2)));
00655               defectInfo.setName(defectLine.substring(matcher.start(3),matcher.end(3)));
00656               testObject.add(defectInfo);
00657               }
00658            else System.err.println("Unrecognised defect descriptor: "+defectLine);
00659            }
00660          // DAQ info
00661          DAQInfo daqInfo = new DAQInfo();
00662          for(int i=0;i<5;i++) daqInfo.put(i,result.daqInfo[i]);
00663          testObject.add(daqInfo);
00664          // Test Status
00665          TestInfo testInfo = new TestInfo();
00666          testInfo.setStatus(new Double(result.status));
00667          testObject.add(testInfo);
00668          cache.put(resultObject,testObject);
00669          return testObject;
00670          }catch(Exception e){System.err.println("SctGUI: Failed to extract "+resultObject+" : "+e.toString());}
00671          return null;
00672          }
00673 
00674      public Double getTestData(String resultObjectHeader, String serialNo,int testIndex, SummaryReader.DCSInfo dcsInfo) {
00675                   if(testIndex==-1) return null;
00676                   int parameterIndex = guiControl.selectorPane.getDisplayParameterIndex();
00677                   int option = guiControl.selectorPane.getMouseClickIndex();
00678                   if(parameterIndex<0) return null;
00679                   SummaryReader.Test testResult = getTest(resultObjectHeader,serialNo,dcsInfo);
00680                   if(testResult==null) return null;
00681                   Double theData=readTestData(testResult,testIndex,parameterIndex,option);
00682                   return theData;
00683                   }
00684 
00685      public Double readTestData(SummaryReader.Test testResult, int testIndex, int parameterIndex, int option) {
00686                  Double theData=null;
00687                   switch(guiControl.displayStatus.getStatus()) {
00688                      case DisplayStatus.IV_DATA:
00689                          switch(parameterIndex) {
00690                             case 0: // test status
00691                               theData = testResult.getTestInfo().getTestStatusData();
00692                               break;
00693                              case 1: // Current
00694                               theData = testResult.getIVData().getCurrent(option);
00695                               break;
00696                              case 2:
00697                               SummaryReader.DCSInfo dcsInfo = testResult.getDCSInfo();
00698                               if(dcsInfo!=null) theData = dcsInfo.get(option);
00699                               break;
00700                              }
00701                             break;
00702                       default:
00703                          switch(parameterIndex) {
00704                            case 0: // test status
00705                              theData = testResult.getTestInfo().getTestStatusData();
00706                              break;
00707                            case 1: // defect count
00708                              theData = testResult.noDefects();
00709                              break;
00710                            case 2: // bad channel count
00711                              theData = testResult.getNoBadChannels();
00712                              break;
00713                            case 3: // DCS conditions
00714                              SummaryReader.DCSInfo dcsInfo = testResult.getDCSInfo();
00715                              if(dcsInfo!=null) theData = dcsInfo.get(option);
00716                              break;
00717                            default:
00718                              theData = (testIndex==TEST_RXTHRESHOLD || testIndex==TEST_RXTHRESHOLDBASEDONCONFIGREGISTER || testIndex==TEST_RXDELAY) ? testResult.getLinkInfo().get(option) : testResult.getLastDataBlock().get(option,parameterIndex-4);
00719                              }
00720                        }
00721                    return theData;
00722                    }
00723 //
00724 // get test data as a single table line
00725 //
00726      public Vector getTestDataLine(String resultObjectHeader, String serialNo,int testIndex, SummaryReader.DCSInfo dcsInfo) {
00727                   Vector dataLine = new Vector();
00728                   dataLine.addElement(serialNo);
00729 
00730                   if(testIndex==-1) return null;
00731                   int parameterIndex = guiControl.selectorPane.getDisplayParameterIndex();
00732                   if(parameterIndex<0) return null;
00733                   SummaryReader.Test testResult = getTest(resultObjectHeader,serialNo,dcsInfo);
00734                   if(testResult==null) return null;
00735                   
00736                   int option = guiControl.selectorPane.getMouseClickIndex();
00737 
00738                   Double theData=null;
00739                   switch(guiControl.displayStatus.getStatus()) {
00740                      case DisplayStatus.IV_DATA:
00741                          switch(parameterIndex) {
00742                             case 0: // test status
00743                               theData = testResult.getTestInfo().getTestStatusData();
00744                               break;
00745                              case 1: // Current
00746                               theData = testResult.getIVData().getCurrent(option);
00747                               break;
00748                              case 2:
00749                               dcsInfo = testResult.getDCSInfo();
00750                               if(dcsInfo!=null) theData = dcsInfo.get(option);
00751                               break;
00752                              }
00753                             if(theData==null) dataLine.addElement("No Data");
00754                             else dataLine.addElement(theData);
00755                             break;
00756                       default:
00757                          switch(parameterIndex) {
00758                            case 0: // test status
00759                              theData = testResult.getTestInfo().getTestStatusData();
00760                             if(theData==null) dataLine.addElement("No Data");
00761                             else dataLine.addElement(theData);
00762                              break;
00763                            case 1: // defect count
00764                              theData = testResult.noDefects();
00765                             if(theData==null) dataLine.addElement("No Data");
00766                             else dataLine.addElement(theData);
00767                              break;
00768                            case 2: // bad channel count
00769                              theData = testResult.getNoBadChannels();
00770                             if(theData==null) dataLine.addElement("No Data");
00771                             else dataLine.addElement(theData);
00772                              break;
00773                            case 3: // DCS conditions
00774                              dcsInfo = testResult.getDCSInfo();
00775                              if(dcsInfo!=null) theData = dcsInfo.get(option);
00776                             if(theData==null) dataLine.addElement("No Data");
00777                             else dataLine.addElement(theData);
00778                              break;
00779                            default:
00780                              if(testIndex==TEST_RXTHRESHOLD || testIndex==TEST_RXTHRESHOLDBASEDONCONFIGREGISTER || testIndex==TEST_RXDELAY) {
00781                                for( int j=0;j<2;j++) {
00782                                  theData = testResult.getLinkInfo().get(j);
00783                             if(theData==null) dataLine.addElement("No Data");
00784                             else dataLine.addElement(theData);
00785                                  }
00786                                }
00787                           else {
00788                                for(int j=0;j<12;j++) {
00789                                  theData = testResult.getLastDataBlock().get(j+4,parameterIndex-4);
00790                             if(theData==null) dataLine.addElement("No Data");
00791                             else dataLine.addElement(theData);
00792                                  }
00793                                 }
00794 
00795                              }
00796                        }
00797                    return dataLine;
00798                    }
00799 
00800 
00801      public SummaryReader.IVData getIVData(String resultObjectHeader,String serialNo) {
00802 
00803                   SummaryReader.Test testResult = getTest(resultObjectHeader,serialNo,null);
00804                   if(testResult==null) return null;
00805                   else return testResult.getIVData();
00806 
00807                    }
00808 
00809 
00810     public Test getTest(String resultObjectHeader, String serialNo,SummaryReader.DCSInfo dcsInfo) {
00811              String resultObject = resultObjectHeader+serialNo;
00812              SummaryReader.Test testObject = (SummaryReader.Test)cache.get(resultObject);
00813              if(testObject!=null) return testObject;
00814 
00815 
00816              try {
00817                if(!Sct.IS.SctNames.getISRepository().contains(resultObject)) return null;
00818                TestSummaryIS result = new TestSummaryIS();
00819                Sct.IS.SctNames.getISRepository().getValue(resultObject, result);
00820                SummaryReader.Reader reader = new SummaryReader.Reader(serialNo,result.dataString,dcsInfo);
00821                cache.put(resultObject,reader.getTest());
00822                return reader.getTest();
00823                }catch(Exception e){System.err.println("SctGUI: Failed to extract "+resultObject+" : "+e.toString());}
00824              return null;
00825              }
00826 
00827 
00828    public void fillDCSMap(String objectName) {
00829       ConfigurationInterface config = ConfigurationInterface.getInstance();
00830       if(!config.isDCSAvailable()) return;
00831       try {
00832       Map snMap = new HashMap();
00833       for(Enumeration e = config.getSerialNumberMap(guiControl.displayPane.getSCTView()).elements(); e.hasMoreElements();) {
00834            ModuleCell thisCell = (ModuleCell) e.nextElement();
00835            String sn = thisCell.getSerialNo();
00836            SummaryReader.DCSInfo dcsInfo = new SummaryReader.DCSInfo();
00837            for(int i=0;i<dcsParams.length;i++) {
00838                 Double thisData = readDCSData(sn,i);
00839                 if(thisData!=null) dcsInfo.put(i,thisData.doubleValue());
00840                 }
00841            snMap.put(sn,dcsInfo);
00842            }
00843        dcsMap.put(objectName,snMap);
00844       }catch(Exception e){System.err.println("SctGUI: Failed to extract DCS data");}
00845 
00846       }
00847       
00848 
00849    public Double getDCSData(String sn, int parameterIndex) {
00850          switch(parameterIndex) {
00851            case 8:
00852               SummaryReader.DCSInfo dcsInfo = new SummaryReader.DCSInfo();
00853               for(int i=2;i<=3;i++) {
00854                  Double thisData = readDCSData(sn,i);
00855                  if(thisData!=null) dcsInfo.put(i,thisData.doubleValue());
00856                  }
00857               return dcsInfo.get(parameterIndex);
00858 
00859            case 9: // for TDiff and Power, need to read all params
00860               dcsInfo = new SummaryReader.DCSInfo();
00861               for(int i=0;i<dcsParams.length;i++) {
00862                 if(i==2 || i==3) continue;    // dont need T0 and T1
00863                 Double thisData = readDCSData(sn,i);
00864                 if(thisData!=null) dcsInfo.put(i,thisData.doubleValue());
00865                 }
00866                return dcsInfo.get(parameterIndex);
00867            default:
00868                return readDCSData(sn,parameterIndex);
00869            }
00870         }
00871 
00872 
00873 
00874    public Double readDCSData(String sn, int parameterIndex) {
00875          try {
00876          ConfigurationInterface config = ConfigurationInterface.getInstance();
00877          if(!config.isDCSAvailable()) return null;
00878          String dcsHeader = config.getSNInfo(sn,SNInfo.DCS_HEADER);
00879          if(dcsHeader==null) return null;
00880 
00881          String ISObject = prefs.getPreference(prefs.DCS_SERVER_NAME)+"."+dcsHeader+dcsParams[parameterIndex]+".Recv";
00882          if(!Sct.IS.SctNames.getISRepository().contains(ISObject)) return null;
00883          is.AnyInfo theValue = new is.AnyInfo();
00884          Sct.IS.SctNames.getISRepository().getValue(ISObject, theValue);
00885          double theData = ((Float)theValue.getAttribute(theValue.getAttributeCount()-1)).doubleValue();
00886          if(parameterIndex==SummaryReader.DCSInfo.IDET) theData/=1000.;
00887          return Double.valueOf(nf.format(theData));
00888          }catch(Exception e){return null;}
00889          }
00890 
00891 
00892     public Map getDCSMap(String controlObjectName) {
00893        return (Map)dcsMap.get(controlObjectName);
00894        }
00895     public void setCacheSize(int size) {
00896        cache = new guiUtilities.Cache(size);
00897        }
00898  
00899 
00900 
00901 
00902      private GuiComponents.System.ISInterface is;
00903 
00904 
00905 }
00906 

Generated on Fri Jan 14 12:49:53 2005 for SCT DAQ/DCS Software - Java by doxygen 1.3.5