Reader.java

00001 package SummaryReader;
00002 //
00003 // @Author Dave Robinson
00004 //
00005 import java.io.*;
00006 import java.util.*;
00007 import java.util.regex.*;
00008 import java.text.*;
00009 
00010 public class Reader implements regExpressions, DisplayGUI.TestDataInfo {
00011 
00012 
00013     Matcher matcher,matcher2;
00014     Test testObject;
00015     Vector testObjects;
00016     int parameterType;
00017     int testType;
00018     Map testMapping;
00019     java.text.DecimalFormat nf = new java.text.DecimalFormat("#.##");
00020     Pattern testregex;
00021 
00022     public Reader(String serialNo,String resultString, DCSInfo dcsInfo) {
00023             testMapping = getTestMapping();
00024             getTestInfo(serialNo,resultString, dcsInfo);
00025             }
00026 //    public Reader(String resultString) {
00027 //            testMapping = getTestMapping();
00028 //            getTestInfo(null,resultString, null);
00029 //            }
00030 
00031 
00032     public String getData(int index) {
00033          return testObject.getData(index);
00034          }
00035     public String getData() {
00036          return testObject.getData(-1);
00037          }
00038     public Test getTest() {
00039          return testObject;
00040          }
00041 
00042 
00043 
00044 //***************************************************************************8
00045    public void getTestInfo(String serialNo,String resultString, DCSInfo dcsInfo) {
00046       boolean[] nextLineIsChipData = {false,false,false,false,false,false,false,false,false,false,false,false};
00047       boolean loopB=false;
00048       boolean nextLineIsLink0Data=false;
00049       boolean nextLineIsLink1Data=false;
00050       boolean nextLineIsVersion=false;
00051       boolean nextLineIsTime=false;
00052       boolean nextLineIsHost=false;
00053       boolean nextLineIsNoScans=false;
00054       boolean nextLineIsScanType=false;
00055       boolean nextLineIsScanPoints=false;
00056       boolean nextLineIsComment=false;
00057       boolean nextLineIsData=false;
00058       boolean nextLineIsT0T1=false;
00059       boolean nextLineIsVDETIDET=false;
00060       boolean nextLineIsVCCICC=false;
00061       boolean nextLineIsVDDIDD=false;
00062       boolean nextLineIsMarkSpaceRatio=false;
00063 
00064       int linkData=-1;
00065 
00066       int scanCount=0;
00067       int parameterIndex=-1;
00068       int byPassSection=-1;
00069       int byPassChipOffset=-1;
00070 
00071 
00072       testObject = new Test();
00073       IVData ivData=null;
00074       DataBlock dataBlock=null;
00075       LinkInfo linkInfo=null;
00076       DAQInfo daqInfo = new DAQInfo();
00077       TestInfo testInfo = new TestInfo();
00078       ScanInfo scanInfo = new ScanInfo();
00079       DefectInfo defectInfo = new DefectInfo();
00080       int testno=999;
00081       
00082       int loopNo=-1;  // loop count for nptgain tests
00083 
00084       String[] lines = resultString.split("\\n");      
00085 
00086       for(int i=0;i<lines.length;i++) {
00087           String line = lines[i];
00088           if(line.equals("")) continue; // shouldn't be necessary
00089 //          System.out.println(line);
00090 
00091 // check for new test
00092              if(line.matches("^%NewTest")) {
00093                 testObject = new Test();
00094                 continue;
00095              }
00096 
00097              if(testObject==null) continue;
00098 
00099 // first the serial No
00100              matcher = serialNoPattern.matcher(line);
00101              if(matcher.matches()) {
00102                   String thisSerialNo = line.substring(matcher.start(1),matcher.end(1));
00103                   if(!thisSerialNo.startsWith("CRATE") && !thisSerialNo.equals(serialNo)) System.err.println("Invalid serial in SummaryWriter String");
00104                   testObject.setSerialNo(serialNo);
00105                   continue;
00106                   }
00107 
00108 // then the run number and scan number
00109                  matcher = runPattern.matcher(line);
00110                  if(matcher.matches()) {
00111                            String runString = line.substring(matcher.start(1),matcher.end(1));
00112                            matcher = scanNoPattern.matcher(runString);
00113                            if(matcher.matches()) {
00114                                  testInfo.setRunNo(runString.substring(matcher.start(1),matcher.end(1)));
00115                                  testInfo.setScanNo(runString.substring(matcher.start(2),matcher.end(2)));
00116                                  }
00117                            else {
00118                                  testInfo.setRunNo(runString);
00119                                  testInfo.setScanNo("None");
00120                                  }
00121                            continue;
00122                            }
00123 // then the date
00124                  matcher = testDatePattern.matcher(line);
00125                  if(matcher.matches()) {
00126                      daqInfo.put(DAQInfo.DATE,line.substring(matcher.start(1),matcher.end(1)));
00127                      continue;
00128                     }
00129 // now passed or fail status
00130                  matcher = passedPattern.matcher(line);
00131                  if(matcher.matches()) {
00132                      testInfo.setPassed(line.substring(matcher.start(1),matcher.end(1)));
00133                      continue;
00134                      }
00135                  matcher = problemPattern.matcher(line);
00136                  if(matcher.matches()) {
00137                      testInfo.setProblem(line.substring(matcher.start(1),matcher.end(1)));
00138                      continue;
00139                      }
00140 // now the test type
00141                  matcher = testregex.matcher(line);
00142                  if(matcher.matches()) {
00143                         String theTestType = line.substring(matcher.start()+1,matcher.end());
00144                         testInfo.setName(theTestType);
00145                         if(testMapping.containsKey(theTestType)) testno = ((Integer)testMapping.get(theTestType)).intValue();
00146                         switch(testno) {
00147                           case TEST_PIPELINE:
00148                             dataBlock = new DataBlock("Number of Defective pipelines",1,testno);
00149                             dataBlock.add(0,"#Channels");
00150                             break;
00151                           case TEST_FULLBYPASS:                          
00152                              dataBlock = new DataBlock("FullBypass Data",testParameters[testno].length-parameterOffset,testno);
00153                              for(int header=parameterOffset;header<testParameters[testno].length;header++) dataBlock.add(header-parameterOffset,testParameters[testno][header]);
00154                              break;
00155                           case TEST_STROBEDELAY: 
00156                             dataBlock = new DataBlock("Optimum Strobe Delays",1,testno);
00157                             dataBlock.add(0,"Delay");
00158                             break;
00159                           case TEST_TRIM:                          
00160                              dataBlock = new DataBlock("Trim Data",testParameters[testno].length-parameterOffset,testno);
00161                              for(int header=parameterOffset;header<testParameters[testno].length;header++) dataBlock.add(header-parameterOffset,testParameters[testno][header]);
00162                              break;
00163                           case TEST_NOISE:
00164                              dataBlock = new DataBlock("Noise Data",testParameters[testno].length-parameterOffset,testno);
00165                              for(int header=parameterOffset;header<testParameters[testno].length;header++) dataBlock.add(header-parameterOffset,testParameters[testno][header]);
00166                              break;
00167                           case TEST_DOUBLETRIGGERNOISE:
00168                              dataBlock = new DataBlock("DoubleTriggerNoise Data",testParameters[testno].length-parameterOffset,testno);
00169                              for(int header=parameterOffset;header<testParameters[testno].length;header++) dataBlock.add(header-parameterOffset,testParameters[testno][header]);
00170                              break;
00171                           case TEST_TIMEWALK:
00172                             dataBlock = new DataBlock("TimeWalk Data",testParameters[testno].length-parameterOffset,testno);
00173                              for(int header=parameterOffset;header<testParameters[testno].length;header++) dataBlock.add(header-parameterOffset,testParameters[testno][header]);
00174                              break;
00175                           case TEST_RXTHRESHOLD:
00176                             linkInfo = new LinkInfo(1);
00177                             for(int header=parameterOffset;header<testParameters[testno].length;header++) linkInfo.addTitle(header-parameterOffset,testParameters[testno][header]);
00178                             break;
00179                          case TEST_RXTHRESHOLDBASEDONCONFIGREGISTER:
00180                             linkInfo = new LinkInfo(3);
00181                     for(int header=parameterOffset;header<testParameters[testno].length;header++) linkInfo.addTitle(header-parameterOffset,testParameters[testno][header]);
00182                             break;
00183                          case TEST_TXCURRENT:
00184                             linkInfo = new LinkInfo(3);
00185                     for(int header=parameterOffset;header<testParameters[testno].length;header++) linkInfo.addTitle(header-parameterOffset,testParameters[testno][header]);
00186                             break;
00187                           case TEST_RXDELAY: 
00188                             linkInfo = new LinkInfo(1);
00189                     for(int header=parameterOffset;header<testParameters[testno].length;header++) linkInfo.addTitle(header-parameterOffset,testParameters[testno][header]);
00190                             break;
00191                           case TEST_MARKSPACERATIO:
00192                              dataBlock = new DataBlock("MarkSpaceRatio",testParameters[testno].length-parameterOffset,testno);
00193                              for(int header=parameterOffset;header<testParameters[testno].length;header++) dataBlock.add(header-parameterOffset,testParameters[testno][header]);
00194                              break;
00195                           case TEST_IV:
00196                             ivData = new IVData(testObject.getSerialNo());
00197                             break;
00198                           default:
00199                           }
00200                         continue;
00201                         }
00202 //
00203 
00204                  matcher = spacerPattern.matcher(line);
00205                  if(matcher.matches()) line=line.substring(matcher.start(1),matcher.end(1));
00206                  switch(testno) {
00207                     case TEST_IV:
00208                          Matcher matcher2 = ivDataPattern.matcher(line);
00209                          if(matcher2.matches()) ivData.add(line.substring(matcher2.start(1),matcher2.end(1)),line.substring(matcher2.start(2),matcher2.end(2)));
00210                          break;
00211                     case TEST_PIPELINE:
00212                          if(nextLineIsLink0Data || nextLineIsLink1Data) {
00213                            String[] dataLine = line.split("\\s+");
00214                            if(dataLine.length!=6) break;
00215                            for(int j=0;j<dataLine.length;j++) {
00216                                       int index = nextLineIsLink1Data ? j+6 : j;
00217                                        try {  // subtract 128 from Ngood into N-notGood
00218                                           int thisData = Integer.parseInt(dataLine[j]);
00219                                           thisData=128-thisData;
00220                                           dataLine[j]=Integer.toString(thisData);
00221                                        }catch(Exception e2){};
00222                                       dataBlock.add(index,0,dataLine[j]);
00223                                       }
00224                            }
00225                           nextLineIsLink0Data = line.startsWith("#M0");
00226                           nextLineIsLink1Data = line.startsWith("#M8");
00227                           break;
00228                     case TEST_FULLBYPASS:
00229 //  byPassChipOffset   chip0  chip0   chip1  chip1
00230 //                 0   data0  data1   data0  data1
00231 //                 1   data0  data1   data0  data1
00232 //          ...
00233 // where chip0=m0,s2 etc for byPassChipOffset=0,1 etc
00234 //       chip1=s1,s3 etc for byPassChipOffset=0,1 etc
00235                          if(line.matches("^#Comment$")) {
00236                                 byPassSection=1;
00237                                 byPassChipOffset=-1;
00238                                 }
00239                          if(line.matches("^#token\\s+r_tkn\\s+token\\s+r_tkn$")) byPassSection=0;
00240                          if(byPassSection<0) break;
00241                           
00242                          if(byPassChipOffset!=-1) {
00243                            String[] dataLine = (byPassSection==1) ? line.split("\\t+") : line.split("\\s+");
00244                            if(dataLine.length!=4) break;
00245                            int colOffset = byPassSection*2;
00246                            // remove any " from comments
00247                            dataBlock.add((byPassChipOffset*2),0+colOffset,dataLine[0].replaceAll("\"","")); 
00248                            dataBlock.add((byPassChipOffset*2),1+colOffset,dataLine[1].replaceAll("\"",""));   
00249                            dataBlock.add((byPassChipOffset*2)+1,0+colOffset,dataLine[2].replaceAll("\"","")); 
00250                            dataBlock.add((byPassChipOffset*2)+1,1+colOffset,dataLine[3].replaceAll("\"",""));                        
00251                            }
00252                          byPassChipOffset=-1;
00253                          for(int offset=0;offset<6;offset++) {
00254                              if(line.matches(fullBypassChipPattern[offset])) {
00255                                    byPassChipOffset=offset;
00256                                    break;
00257                                    }
00258                              }
00259                          break;
00260 
00261                     case TEST_STROBEDELAY:
00262                          if(nextLineIsLink0Data || nextLineIsLink1Data) {
00263                            String[] dataLine = line.split("\\s+");
00264                            if(dataLine.length!=6) break;
00265                            for(int j=0;j<dataLine.length;j++) {
00266                                       int index = nextLineIsLink1Data ? j+6 : j;
00267                                       dataBlock.add(index,0,dataLine[j]);
00268                                       }
00269                            }
00270                           nextLineIsLink0Data = line.startsWith("#M0");
00271                           nextLineIsLink1Data = line.startsWith("#M8");
00272                           break;
00273                     case TEST_MARKSPACERATIO:
00274                          if(nextLineIsMarkSpaceRatio) {
00275                            String[] dataLine = line.split("\\s+");
00276                            if(dataLine.length!=1) {
00277                               System.err.println("SctGUI::SummaryReader.Reader - data length="+dataLine.length+" for MarkSpaceRatio test");
00278                               break;
00279                               }
00280                            for(int j=0;j<12;j++) dataBlock.add(j,0,dataLine[0]);
00281                            }
00282                           nextLineIsMarkSpaceRatio = line.startsWith("%Optimum");
00283                           break;
00284                     case TEST_3PTGAIN:
00285                     case TEST_NPTGAIN:
00286                          if(line.startsWith("#LoopA")) {
00287                              loopNo++;
00288                              dataBlock = new DataBlock("Fit Parameters",4,testno);
00289                              dataBlock.add(0,"Function");
00290                              dataBlock.add(1,"P0");
00291                              dataBlock.add(2,"P1");
00292                              dataBlock.add(3,"P2");         
00293                              continue;
00294                              }
00295                          if(line.startsWith("#LoopB")) {
00296                              loopNo++;
00297                              if(dataBlock!=null) testObject.add(dataBlock);
00298                              dataBlock = new DataBlock("NPtGain Data",testParameters[testno].length-parameterOffset,testno);
00299                              for(int header=parameterOffset;header<testParameters[testno].length;header++) dataBlock.add(header-parameterOffset,testParameters[testno][header]);
00300                              continue;
00301                              }
00302                          for(int j=0;j<12;j++) {
00303                               if(nextLineIsChipData[j]) {
00304                                 String[] dataLine = line.split("\\s+");
00305                                 if(dataLine.length==4 && loopNo==1) {  // slope data
00306                                          for(int k=1;k<dataLine.length;k++) dataBlock.add(j,k+8,dataLine[k]);  // 9 non-slope data words -1
00307                                          }
00308                                 else {
00309                                          for(int k=0;k<dataLine.length;k++) dataBlock.add(j,k,dataLine[k]);
00310                                      }
00311                                 }
00312                               nextLineIsChipData[j] = (line.matches(chipNames[j]));
00313                           }
00314                           break;
00315                     case TEST_TRIM:
00316                          for(int j=0;j<12;j++) {
00317                             if(nextLineIsChipData[j]) {
00318                                 String[] dataLine = line.split("\\s+");
00319                                 try {  // subtract 128 from Ntrimmed to turn it into Nuntrimmed
00320                                           int thisData = Integer.parseInt(dataLine[2]);
00321                                           thisData=128-thisData;
00322                                           dataLine[2]=Integer.toString(thisData);
00323                                 }catch(Exception e2){};
00324                                 for(int k=0;k<dataLine.length;k++) dataBlock.add(j,k,dataLine[k]);
00325                                 }
00326                              nextLineIsChipData[j] = (line.matches(chipNames[j]));
00327                              }
00328                           break;
00329                     case TEST_NOISE:
00330                           for(int j=0;j<12;j++) {
00331                             if(nextLineIsChipData[j]) {
00332                                 matcher2 = opeToolPattern.matcher(line);
00333                                 if(matcher2.matches()) line=line.substring(matcher2.start(1),matcher2.end(1));
00334                                 String[] dataLine = line.split("\\s+");
00335                                 for(int k=0;k<dataLine.length;k++) {
00336                                         try {
00337                                           if(k==1 || k==2) dataLine[k]= (new java.text.DecimalFormat("0.##E0")).format(Double.parseDouble(dataLine[k]));
00338                                         }catch(Exception ne){dataLine[k]="0.";} // if not a number, save as 0. for now...
00339                                         if(dataLine.length==4) dataBlock.add(j,k,dataLine[k]);
00340                                         else if(dataLine.length==2) dataBlock.add(j,k+4,dataLine[k]);
00341                                         else {System.err.println("SctGUI SummaryReader::Reader - Invalid data in summaryWriter String");}
00342                                         }
00343                                 }
00344                              nextLineIsChipData[j] = (line.matches(chipNames[j]));
00345                              }
00346                           break;
00347                     case TEST_DOUBLETRIGGERNOISE:
00348                           for(int j=0;j<12;j++) {
00349                             if(nextLineIsChipData[j]) {
00350                                 String[] dataLine = line.split("\\s+");
00351                                 if(dataLine.length!=4) {
00352                                    System.out.println("SctGUI - invalid data in DOUBLETRIGGERNOISE summary file.");
00353                                    continue;
00354                                    }
00355                                 for(int k=0;k<dataLine.length;k++) {
00356                                         try {
00357                                           dataLine[k]= (new java.text.DecimalFormat("0.##E0")).format(Double.parseDouble(dataLine[k]));
00358                                         }catch(Exception ne){dataLine[k]="0.";} // if not a number, save as 0. for now...
00359                                         dataBlock.add(j,k,dataLine[k]);
00360                                         }
00361                                 }
00362                              nextLineIsChipData[j] = (line.matches(chipNames[j]));
00363                              }
00364                           break;
00365                     case TEST_TIMEWALK:
00366                          if(line.startsWith("#TW")) parameterIndex=0;     // 0 = TimeWalk data; 1 = TCal data
00367                          if(line.startsWith("#TCAL")) parameterIndex=1;
00368 //                         if(parameterIndex!=parameterType) break;
00369                          if(nextLineIsLink0Data || nextLineIsLink1Data) {
00370                            String[] dataLine = line.split("\\s+");
00371                            if(dataLine.length!=6) break;
00372                            for(int j=0;j<dataLine.length;j++) {
00373                                       int index = nextLineIsLink1Data ? j+6 : j;
00374                                       dataBlock.add(index,parameterIndex,dataLine[j]);
00375                                       }
00376                            }
00377                           nextLineIsLink0Data = line.startsWith("#M0");
00378                           nextLineIsLink1Data = line.startsWith("#M8");
00379                           break;
00380                     case TEST_RXTHRESHOLD:
00381                          if(nextLineIsData) {
00382                            Matcher matcher = bocPattern.matcher(line);
00383                            if(matcher.matches()) {
00384                               String s = line.substring(matcher.start(1),matcher.end(1));
00385                               linkInfo.add(0,s);
00386                               s = line.substring(matcher.start(2),matcher.end(2));
00387                               linkInfo.add(1,s);
00388                               }
00389                             }
00390                           nextLineIsData = line.startsWith("#Thresholds");
00391                           break;
00392                     case TEST_RXTHRESHOLDBASEDONCONFIGREGISTER:
00393                         matcher = linkInfoPattern.matcher(line);
00394                         if(matcher.matches()) {
00395                             linkData = Integer.parseInt(line.substring(matcher.start(1),matcher.end(1)));
00396                             if(linkData<0 || linkData>1) {
00397                                System.err.println("sctGUI:: Invalid link number in summaryWriter string");
00398                                linkData=-1;
00399                                }
00400                             }
00401                         if(linkData!=-1) {
00402                            Matcher matcher = rxthrconfigDataPattern.matcher(line);
00403                            if(matcher.matches()) {
00404                               for(int match=0;match<3;match++) {
00405                               String value = line.substring(matcher.start(match+1),matcher.end(match+1));
00406                               linkInfo.add(linkData,match,value);
00407                               }
00408                             linkData=-1;
00409                             }
00410                           }
00411                           break;
00412                     case TEST_TXCURRENT:
00413                         matcher = linkInfoPattern.matcher(line);
00414                         if(matcher.matches()) {
00415                             linkData = Integer.parseInt(line.substring(matcher.start(1),matcher.end(1)));
00416                             if(linkData<0 || linkData>1) {
00417                                System.err.println("sctGUI:: Invalid link number in summaryWriter string");
00418                                linkData=-1;
00419                                }
00420                             }
00421                         if(linkData!=-1) {
00422                            Matcher matcher = txcurrentDataPattern.matcher(line);
00423                            if(matcher.matches()) {
00424                               for(int match=0;match<3;match++) {
00425                               String value = line.substring(matcher.start(match+1),matcher.end(match+1));
00426                               linkInfo.add(linkData,match,value);
00427                               }
00428                             linkData=-1;
00429                             }
00430                           }
00431                           break;
00432 
00433                     case TEST_RXDELAY:
00434                          if(nextLineIsData) {
00435                            Matcher matcher = bocPattern.matcher(line);
00436                            if(matcher.matches()) {
00437                               String s = line.substring(matcher.start(1),matcher.end(1));
00438                               linkInfo.add(0,s);
00439                               s = line.substring(matcher.start(2),matcher.end(2));
00440                               linkInfo.add(1,s);
00441                               }
00442                             }
00443                           nextLineIsData = line.startsWith("#Delays");
00444                           break;
00445                     default:
00446                     }     
00447           if(nextLineIsScanPoints) {
00448              if(line.startsWith("%") || line.startsWith("#")) {
00449                   nextLineIsScanPoints=false;
00450                   continue;
00451                   }
00452              try {
00453                 String[] scanPoints = line.split("\\s+");
00454                 for(int k=0;k<scanPoints.length;k++) {
00455                        scanInfo.setScanPoint(scanCount+k,scanPoints[k]);
00456                        }
00457                  scanCount+=scanPoints.length;
00458                  continue;
00459              }catch(Exception e3){}
00460           }
00461 
00462           matcher = defectNamePattern.matcher(line);
00463           if(matcher.matches()) {
00464              defectInfo = new DefectInfo();
00465              defectInfo.setName(line.substring(matcher.start(1),matcher.end(1)));
00466              continue;
00467              }
00468           matcher = defectNameDefect0.matcher(line);
00469           if(matcher.matches()) {
00470              defectInfo.setFirstChannel(line.substring(matcher.start(1),matcher.end(1)));
00471              continue;
00472              }
00473           matcher = defectNameDefect1.matcher(line);
00474           if(matcher.matches()) {
00475              defectInfo.setLastChannel(line.substring(matcher.start(1),matcher.end(1)));
00476              testObject.add(defectInfo);
00477              continue;
00478              }
00479 
00480          if(nextLineIsComment) {
00481              matcher = commentsPattern.matcher(line);
00482              if(matcher.matches()) testObject.addComment(line.substring(matcher.start(1),matcher.end(1)));
00483              }
00484 
00485              
00486           if(nextLineIsVersion) daqInfo.put(DAQInfo.VERSION,line);
00487           if(nextLineIsTime) daqInfo.put(DAQInfo.TIME,line.replaceAll("\"",""));
00488           if(nextLineIsHost) daqInfo.put(DAQInfo.HOST,line.replaceAll("\"",""));
00489           if(nextLineIsScanType) scanInfo.setType(line);
00490           if(nextLineIsNoScans) scanInfo.setPoints(line);
00491 
00492           if(nextLineIsT0T1) {
00493             String[] data = line.split("[\\s\\r\\n]");
00494             if(data.length==2) {
00495               if(dcsInfo==null) dcsInfo=new DCSInfo();
00496               try {
00497                 dcsInfo.put(DCSInfo.T0,nf.format(Double.parseDouble(data[0])));
00498                 dcsInfo.put(DCSInfo.T1,nf.format(Double.parseDouble(data[1])));
00499                 }catch(Exception e){}
00500               }
00501             } 
00502           if(nextLineIsVCCICC) {
00503             String[] data = line.split("[\\s\\r\\n]");
00504             if(data.length==2) {
00505               if(dcsInfo==null) dcsInfo=new DCSInfo();
00506               try {
00507                 dcsInfo.put(DCSInfo.VCC,nf.format(Double.parseDouble(data[0])));
00508                 dcsInfo.put(DCSInfo.ICC,nf.format(Double.parseDouble(data[1])));
00509                 }catch(Exception e){}
00510               }
00511             } 
00512           if(nextLineIsVDDIDD) {
00513             String[] data = line.split("[\\s\\r\\n]");
00514             if(data.length==2) {
00515               if(dcsInfo==null) dcsInfo=new DCSInfo();
00516               try {
00517                 dcsInfo.put(DCSInfo.VDD,nf.format(Double.parseDouble(data[0])));
00518                 dcsInfo.put(DCSInfo.IDD,nf.format(Double.parseDouble(data[1])));
00519                 }catch(Exception e){}
00520               }
00521             } 
00522           if(nextLineIsVDETIDET) {
00523             String[] data = line.split("[\\s\\r\\n]");
00524             if(data.length==2) {
00525               if(dcsInfo==null) dcsInfo=new DCSInfo();
00526               try {
00527                 dcsInfo.put(DCSInfo.VDET,nf.format(Double.parseDouble(data[0])));
00528                 dcsInfo.put(DCSInfo.IDET,nf.format( Double.valueOf(data[1]).doubleValue()/1000. )); // convert to uA from nA
00529                 }catch(Exception e){}
00530               }
00531             } 
00532  
00533           nextLineIsVersion = line.matches("^[\\s#]?VERSION.*");
00534           nextLineIsTime = line.matches("^#TIME$");
00535           nextLineIsHost = line.matches("^#HOST$");      
00536           nextLineIsScanType = line.matches("^#POINT_TYPE$");
00537           nextLineIsNoScans = line.matches("^#N_POINTS$");    
00538           nextLineIsScanPoints = line.matches("^#POINTS$");
00539           nextLineIsComment = line.matches("^%Comment$");
00540           nextLineIsT0T1 = line.matches("^#T0\\s+T1.*");
00541           nextLineIsVDETIDET = line.matches("^#VDET\\s+IDET.*");
00542           nextLineIsVCCICC = line.matches("^#VCC\\s+ICC.*");
00543           nextLineIsVDDIDD = line.matches("^#VDD\\s+IDD.*");
00544 
00545 
00546           }
00547        if(dataBlock!=null) testObject.add(dataBlock);
00548        if(ivData!=null) testObject.add(ivData);
00549        if(dcsInfo!=null) testObject.add(dcsInfo);
00550        if(linkInfo!=null) testObject.add(linkInfo);
00551        testObject.add(testInfo);
00552        testObject.add(daqInfo);
00553        testObject.add(scanInfo);
00554    }
00555 
00556   private Map getTestMapping() {
00557       Map mapping = new HashMap();
00558       StringBuffer testregExpr = new StringBuffer();
00559       int count=0;
00560       for(int i=0;i<resultFileKeyNames.length;i++) {
00561          if(!resultFileKeyNames[i].equals("")) {
00562             mapping.put(resultFileKeyNames[i],new Integer(i));
00563             if(count>0) testregExpr.append("|");
00564             testregExpr.append("%"+resultFileKeyNames[i]);
00565             count++;
00566             }
00567        }
00568        String theTestRegex = "("+testregExpr.toString()+")";
00569 //       System.out.println("testregex="+theTestRegex);
00570        testregex=Pattern.compile(theTestRegex);
00571       return mapping;
00572 }
00573 
00574      
00575 
00576 
00577 
00578 }
00579
Generated on Mon Feb 6 14:12:16 2006 for SCT DAQ/DCS Software - Java by  doxygen 1.4.6