ConfigurationInterface.java

package DisplayGUI;
import org.omg.CORBA.IntHolder;
import ipc.*;
//import java.util.Hashtable;
//import java.util.Vector;
import java.util.*;
import GuiComponents.System.*;

public class ConfigurationInterface implements displayParams, SCTInfo {
    private static ConfigurationInterface instance = new ConfigurationInterface();
    private int maxWidth=0;
    private int midX=0, midY=0;
    private int moduleCount=0;
    private java.awt.Polygon polygon;

    double[] radius = {0.,0.,0.,0.,0.,0.};
    int[] xPoints = {0,0,0,0};
    int[] yPoints = {0,0,0,0};
    long fillsn=3000;

        public static final int VIEW_CATEGORIES=2;
        public static final int SCT_VIEWS=0;
        public static final int RODCRATE_VIEWS=1;

    // serialnos[viewCategory][sctView][Row][position] for barrel views
        // serialnos[viewCategory][sctView][Quadrant][index] for endcap views
        // serialnos[viewCategory][viewIndex][Slot][channel] for crate views
    private String[][][][] serialnos;
        // map of serial number to ModuleCell
        private Map moduleCellMap;
        // orderedList[viewCategory][viewIndex] is ordered list of serial numbers for viewCategory and viewindex
        private Set[][] orderedList;
        // map of P<partition_no>.C<crate_no> to viewIndex
        private Map viewMap;
    // map of slot number to a serial number in that slot (from which one can retrieve ROD info)
        private Map[] slotMap;

    private boolean dcsAvailable;

    private ConfigurationInterface() {
        Refresh();
        }

    public static ConfigurationInterface getInstance() {
        return instance;
    }

   public void setWindowSize(int maxWidth, int maxHeight) {
        this.maxWidth=maxWidth;
        midX=maxWidth/2;
        midY=maxHeight/2;
        maxWidth*=0.95;
        radius[0]=0.35 * (double)maxWidth/2.;
        radius[1]=0.52 * (double)maxWidth/2.;
        radius[2]= 0.5 * (double)maxWidth/2.;
        radius[3]= 0.76* (double)maxWidth/2.;
        radius[4]= 0.74  * (double)maxWidth/2.;
        radius[5]= maxWidth/2.;
        }

    public void Refresh() {
           orderedList = new TreeSet[VIEW_CATEGORIES][];
           orderedList[SCT_VIEWS] = new TreeSet[sctViews];
       for(int i=0;i<sctViews;i++) orderedList[SCT_VIEWS][i]=new TreeSet();
       serialnos = new String[VIEW_CATEGORIES][][][];
           serialnos[SCT_VIEWS] = new String[sctViews][][];
       moduleCellMap = new HashMap();
           viewMap = new LinkedHashMap();
       dcsAvailable=false;
       moduleCount=0;
     }

        public Map getRodCrateViewMap() {
                return viewMap;
                }

     public boolean isConfigured() {
         return (moduleCount>0);
         }

     public void getConfiguration() {
         getConfiguration(-1);
         }

     public void getConfiguration(int moduleGroup) {
            sctConf.Configuration h = SystemInterface.getInstance().getConfigurationService();
                Sct_SctApi.SctApiIPC sctApi = SystemInterface.getInstance().getSctApi();
        if(h==null) {System.err.println("SctGUI::ConfigurationInterface - null ref to Config service");return;}
                if(sctApi==null) {System.err.println("SctGUI::ConfigurationInterface - null ref to SctApi");return;}
        try {

                    // first define the ROD crate views
            int[] parts = h.listPartitions();
            viewMap = new LinkedHashMap();
                        int viewCount=0;
            for(int p=0; p<parts.length; p++) {
//                System.out.println("Partition " + p + " " + parts[p]);
                int[] crates = h.listCratesInPartition(parts[p]);
                for(int c=0; c<crates.length; c++) {
                                        viewMap.put(getRODCrateKey(parts[p],crates[c]),new Integer(viewCount));
                                        viewCount++;
                        }
                                }

                        if(viewCount>0) {
                                slotMap = new HashMap[viewMap.size()];
                                serialnos[RODCRATE_VIEWS] = new String[viewMap.size()][][];
                                orderedList[RODCRATE_VIEWS] = new TreeSet[viewMap.size()];
                                for(int i=0;i<viewMap.size();i++) {
                                        orderedList[RODCRATE_VIEWS][i]=new TreeSet();
                                        slotMap[i] = new HashMap();
                                        }
                                }

                        // now define the SCT views
            for(int p=0; p<parts.length; p++) {
                int[] crates = h.listCratesInPartition(parts[p]);
                for(int c=0; c<crates.length; c++) {
                    int[] rods = h.listRodsInCrate(parts[p], crates[c]);
                    for(int r=0; r<rods.length; r++) {
//                        System.out.println("Rod " + r + " " + rods[r]);
                        //sct.RodConfig rodConf = h.getRodConfig(parts[p], crates[c], rods[r]);
                        //System.out.println(rodConf.slaves[0].emifFile);

                        int[] MURs = h.listMURSInRod(parts[p], crates[c], rods[r]);
                        for(int mur=0; mur<MURs.length; mur++) {
//                            System.out.println("MUR " + mur + " " + MURs[mur]);
                            String[] modules = h.listModulesInMUR(parts[p], MURs[mur]);

                            for(int m=0; m<modules.length; m++) {
 //                               System.out.println("Module " + m + " " + modules[m]);

                                IntHolder MUR = new IntHolder(), num = new IntHolder();
                                h.translateFromSN(modules[m], MUR, num);

                                IntHolder partition = new IntHolder(), crate = new IntHolder(), rodno=new IntHolder(), channel=new IntHolder() ;
                                h.translateToROD(MUR.value, num.value, partition, crate, rodno, channel);

                                SNInfo snInfo = new SNInfo();
                                snInfo.set(SNInfo.PARTITION,Integer.toString(partition.value));
                                snInfo.set(SNInfo.ROD_CRATE,Integer.toString(crate.value));
                                snInfo.set(SNInfo.ROD_NUMBER,Integer.toString(rodno.value));
                                snInfo.set(SNInfo.ROD_CHANNEL,Integer.toString(channel.value));
                                          snInfo.set(SNInfo.ROD_SLOT,Integer.toString(sctApi.getCrateLegacy(partition.value, crate.value).getRodSlot(rodno.value)));

                                try {
                                    moduleGroup = h.getModuleGroup(modules[m]);
                                }catch(Exception groupE){
                                    System.err.println("SctGUI::ConfigurationInterface - can't retrieve moduleGroup : "+groupE.toString());
                                    moduleGroup=0;
                                    }                 

                                IntHolder barrel = new IntHolder(), row = new IntHolder(), number = new IntHolder();
                                try {
                                  h.translateToBarrel(MUR.value, num.value, barrel, row, number);
                                  defineBarrelModuleGraphicsCell(barrel.value, row.value, number.value, MUR.value, moduleGroup, modules[m],snInfo);
                                } catch(sctConf.ConfigurationException eConfig) {
                                  h.translateToEndcap(MUR.value, num.value, barrel, row, number);
                                  defineEndCapModuleGraphicsCell(barrel.value, row.value, number.value, MUR.value, moduleGroup, modules[m],snInfo);
                                  }
                                try {
                                  h.translateToPowerSupply(MUR.value, num.value,partition,crate,channel);
                                  definePowerSupplyMapping(crate.value,channel.value,modules[m]);
                                }catch(Exception ee) {}
//               System.out.println("Module "+modules[m]+", Barrel " + barrel.value + ", Row " + row.value + ", Number " + number.value+", MUR "+MUR.value);

                            }
                        }
                    }
                }
            }
        } catch(sctConf.ConfigurationException eConfig) {
            System.err.println("Configuration exception retrieving configuration " + eConfig.detail);
            eConfig.printStackTrace();
        } catch(Exception e) {
            System.err.println("Non-configuration exception retrieving configuration ..." + e);
            e.printStackTrace();
        }

     writeLookUpTable();
//        definePowerSupplyMapping(1,5,"20220330200020"); // dummy for test
//        definePowerSupplyMapping(1,6,"20220330200019"); // dummy for test
    }

   public String getRODCrateKey(int partition, int crate) {
                return getRODCrateKey(Integer.toString(partition),Integer.toString(crate));
                }
   public String getRODCrateKey(String partition, String crate) {
        return "Partition"+partition+".Crate"+crate;
                }

   public void definePowerSupplyMapping(int crate, int channel, String sn) {

      dcsAvailable=true;

          ModuleCell thisCell = (ModuleCell)moduleCellMap.get(sn);
      SNInfo snInfo = thisCell.getSNInfo();
      if(snInfo==null) snInfo = new SNInfo();

      String crateString = Integer.toString(crate);
      snInfo.set(SNInfo.DCS_CRATE,crateString);
      String channelString = Integer.toString(channel);
      snInfo.set(SNInfo.DCS_CHANNEL,channelString);

      if(crateString.length()==1) crateString="0"+crateString;
      if(channelString.length()==1) channelString="0"+channelString;
      snInfo.set(SNInfo.DCS_HEADER,"Crate"+crateString+".Channel"+channelString+".");
      snInfo.set(SNInfo.IV_FILE_HEADER,"CRATE"+crateString+"CHAN"+channelString);

      thisCell.addSNInfo(snInfo);
    
      }
   public String getSNInfo(String sn, int index) {
          ModuleCell thisCell = (ModuleCell)moduleCellMap.get(sn);
          if(thisCell==null) return "-1";
      SNInfo snInfo = thisCell.getSNInfo();
      if(snInfo==null) return "-1"; // -1 instead of null for the display indicator
      return snInfo.get(index);
      }

        public String getASerialNumberForSlot(int selection,int slot) {
                return (String)slotMap[selection].get(new Integer(slot));
                }

    public boolean isDCSAvailable() {
      return dcsAvailable;
      }


    public String addModule(int barrel, int row, int number, int MUR, int moduleGroup, String serialNo) {

        for(int i=0;i<sctViews;i++) {
           if(orderedList[SCT_VIEWS][i].contains(serialNo)) return "Module "+serialNo+" is already defined in "+SCTViewNames[i];
           } 

        for (Iterator i=orderedList[SCT_VIEWS][barrel].iterator(); i.hasNext(); ) {
              String thisSerialNo = (String)i.next();
              ModuleCell thisCell = (ModuleCell)moduleCellMap.get(thisSerialNo);
              if(thisCell.getRow()==row && thisCell.getModulePosition()==number) return "That location already taken by "+thisSerialNo;
              }
      int thisSCTView = barrel;

      try {
         moduleGroup = SystemInterface.getInstance().getConfigurationService().getModuleGroup(serialNo);
      }catch(Exception ee){System.err.println("SctGUI::ConfigurationInterface - can't retrieve moduleGroup : "+ee.toString());}

      if(barrel<4) {
            thisSCTView+=3;
            defineBarrelModuleGraphicsCell(thisSCTView, row, number, MUR, moduleGroup, serialNo, new SNInfo());
            }
      else if(barrel>12) {
            thisSCTView-=12;
            defineEndCapModuleGraphicsCell(thisSCTView, row, number, MUR, moduleGroup, serialNo, new SNInfo());
            }
      else {
            thisSCTView-=3;
            thisSCTView*=-1;
            defineEndCapModuleGraphicsCell(thisSCTView, row, number, MUR, moduleGroup, serialNo, new SNInfo());
            }
      return null;
      }

    private void defineBarrelModuleGraphicsCell(int barrel, int row, int number, int MUR, int moduleGroup, String serialNo, SNInfo snInfo) {
        for(int i=0;i<sctViews;i++) {
           if(orderedList[SCT_VIEWS][i].contains(serialNo)) {
              System.out.println("** Module "+serialNo+" defined more than once!");
              return;
              }
           } 
        if(barrel < 3 || barrel > 6) {
            System.out.println("** Module "+serialNo+" reported to be in nonexistant barrel " + barrel + "!");
            return;
        }

        int thisSCTView=barrel-3;
        int moduleIndex = number;
        moduleIndex+=6;   // concert -6 to -1 to 0 thru 5, and 1 to 6 to 7 thru 12
        if(moduleIndex>5) moduleIndex--;  // bring it to 0 thru 11
        int thisRow=row;

                ModuleCell thisCell = new ModuleCell(serialNo,thisSCTView,row,number,MUR,moduleGroup);
                thisCell.addSNInfo(snInfo);
                calculateSCTPolygon(thisSCTView,row,number);
                thisCell.addPolygon(SCT_VIEWS,xPoints,yPoints,4);

                if(serialnos[SCT_VIEWS][thisSCTView]==null) serialnos[SCT_VIEWS][thisSCTView] = new String[barrelRows[thisSCTView]][];
        if(serialnos[SCT_VIEWS][thisSCTView][thisRow]==null) serialnos[SCT_VIEWS][thisSCTView][thisRow] = new String[12];
        serialnos[SCT_VIEWS][thisSCTView][thisRow][moduleIndex] = new String(serialNo);
        orderedList[SCT_VIEWS][thisSCTView].add(serialNo);

                Integer viewIndex = (Integer)viewMap.get(getRODCrateKey(snInfo.get(SNInfo.PARTITION),snInfo.get(SNInfo.ROD_CRATE)));
                if(viewIndex==null) System.err.println("SctGUI::ConfigurationInterface - invalid view index");
                else {
                        int slot = Integer.parseInt(snInfo.get(SNInfo.ROD_SLOT));

                        if(slot>=5) {
                        int channel = Integer.parseInt(snInfo.get(SNInfo.ROD_CHANNEL));

                        if(!slotMap[viewIndex.intValue()].containsKey(new Integer(slot))) slotMap[viewIndex.intValue()].put(new Integer(slot),serialNo);

                        int slotIndex = slot-5;

                        if(serialnos[RODCRATE_VIEWS][viewIndex.intValue()]==null) serialnos[RODCRATE_VIEWS][viewIndex.intValue()] = new String[rodSlots][];
                        if(serialnos[RODCRATE_VIEWS][viewIndex.intValue()][slotIndex]==null) serialnos[RODCRATE_VIEWS][viewIndex.intValue()][slotIndex] = new String[rodChannels];
                serialnos[RODCRATE_VIEWS][viewIndex.intValue()][slotIndex][channel] = new String(serialNo);

                        calculateRodCratePolygon(slot,channel);
                        thisCell.addPolygon(RODCRATE_VIEWS,xPoints,yPoints,4);

                        orderedList[RODCRATE_VIEWS][viewIndex.intValue()].add(serialNo);
                        }

                        }

                moduleCellMap.put(serialNo,thisCell);
        moduleCount++;
    }

    private void defineEndCapModuleGraphicsCell(int disk, int quadrant, int number, int MUR, int moduleGroup, String serialNo, SNInfo snInfo) {
        for(int i=0;i<sctViews;i++) {
           if(orderedList[SCT_VIEWS][i].contains(serialNo)) {
              System.out.println("** Module "+serialNo+" defined more than once!");
              return;
              }   
           } 
// end cap disks -1 to -9 map to sctViews 4 to 12
// end cap disks 1 to 9 map to sctViews 13 to 21
        int thisSCTView = (disk<0) ? 3-disk : 12+disk;
        if(serialnos[SCT_VIEWS][thisSCTView]==null) serialnos[SCT_VIEWS][thisSCTView] = new String[4][];
        if(serialnos[SCT_VIEWS][thisSCTView][quadrant]==null) serialnos[SCT_VIEWS][thisSCTView][quadrant] = new String[33];

                ModuleCell thisCell = new ModuleCell(serialNo,thisSCTView,quadrant,number,MUR,moduleGroup);
                thisCell.addSNInfo(snInfo);
                calculateSCTPolygon(thisSCTView,quadrant,number);
                thisCell.addPolygon(SCT_VIEWS,xPoints,yPoints,4);

                // calculate rodcrate polygon here

        serialnos[SCT_VIEWS][thisSCTView][quadrant][number] = new String(serialNo);
        orderedList[SCT_VIEWS][thisSCTView].add(serialNo);

                Integer viewIndex = (Integer)viewMap.get(getRODCrateKey(snInfo.get(SNInfo.PARTITION),snInfo.get(SNInfo.ROD_CRATE)));
                if(viewIndex==null) System.err.println("SctGUI::ConfigurationInterface - invalid view index");
                else {
                        int slot = Integer.parseInt(snInfo.get(SNInfo.ROD_SLOT));
                        int channel = Integer.parseInt(snInfo.get(SNInfo.ROD_CHANNEL));
                        if(!slotMap[viewIndex.intValue()].containsKey(new Integer(slot))) slotMap[viewIndex.intValue()].put(new Integer(slot),serialNo);
                        int slotIndex=slot-5;
                        if(serialnos[RODCRATE_VIEWS][viewIndex.intValue()]==null) serialnos[RODCRATE_VIEWS][viewIndex.intValue()] = new String[rodSlots][];
                        if(serialnos[RODCRATE_VIEWS][viewIndex.intValue()][slotIndex]==null) serialnos[RODCRATE_VIEWS][viewIndex.intValue()][slotIndex] = new String[rodChannels];
            serialnos[RODCRATE_VIEWS][viewIndex.intValue()][slotIndex][channel] = new String(serialNo);

                        calculateRodCratePolygon(slot,channel);
                        thisCell.addPolygon(RODCRATE_VIEWS,xPoints,yPoints,4);
                        orderedList[RODCRATE_VIEWS][viewIndex.intValue()].add(serialNo);
                        }

                moduleCellMap.put(serialNo,thisCell);
        moduleCount++;
    }

   public int getRodSlotNumber(int selection, java.awt.event.MouseEvent e) {

                if(!isConfigured()) return -1;

                if(selection<0) return -1;
                int x = e.getX();
                int y = e.getY();

                int ww = rcBoxWidth + rcBoxGap;
                int midPoint = midX + rcXOffSet;
                int yIndex = 47 - (y - yOffSet - rcYOffSet)/boxHeight;
                if(yIndex<-1 || yIndex>47) return -1;
                //              int thisXOffSet = midX + rcXOffSet - 8*ww + rcBoxGap;
                int diff = x - midPoint;
                diff += 8*ww;
                int xIndex = diff/ww;
                if(xIndex<0 || xIndex>17) return -1;
                int xdiff = midPoint - 8*(rcBoxWidth+rcBoxGap) + xIndex*(rcBoxWidth+rcBoxGap);
                if(x-xdiff<rcBoxGap) return -1; // in the gap
                if(serialnos[RODCRATE_VIEWS]!=null || serialnos[RODCRATE_VIEWS][selection]!=null && serialnos[RODCRATE_VIEWS][selection][xIndex]!=null) return xIndex+5;
                return -1;
                }

    public ModuleCell getCell(int viewCategory, int sctView, int x, int y) {
// return cell for positition x,y for given barrel
// index    0  1  2  3  4  5  6  7  8  9  10  11
// xIndex  -5 -4 -3 -2 -1  0  1  2  3  4  5   6

                if(viewCategory<0 || sctView<0 || !isConfigured()) return null;

                switch(viewCategory) {
                        case SCT_VIEWS:
                        if(sctView<4) {
                        int yIndex =  ((yOffSetCount[sctView]+barrelRows[sctView])*boxHeight - y + yOffSet)/boxHeight;
                        if(yIndex<0 || yIndex>barrelRows[sctView]-1) return null;
                        int diff = x -maxWidth/2;

                        int xIndex = diff/boxWidth;
                        if(diff>0 && xIndex==0) return null;  // inside middle gap

                                // following 2 lines reverses ordering in x, ie -z on right
                                xIndex*=-1;
                                xIndex+=6;
                                // otherwise uncomment this to revert to -z on left
                                // xIndex+=5; // convert -5 to -0 to 0 thru 5, and 1 to 6 to 6 thru 11

                        if(xIndex<0 || xIndex>11) return null;
                        if(serialnos[SCT_VIEWS]!=null && serialnos[viewCategory][sctView]!=null && serialnos[viewCategory][sctView][yIndex]!=null && serialnos[viewCategory][sctView][yIndex][xIndex]!=null) {
                        return (ModuleCell) moduleCellMap.get(serialnos[viewCategory][sctView][yIndex][xIndex]);
                        }
                        }
                        else {
                        // for endsaps, just enumerate through for the moment.
                        // probably quicker than calculating explicity from x and y?
                        for (Iterator i=orderedList[viewCategory][sctView].iterator(); i.hasNext(); ) {
                                String sn = (String) i.next();
                                ModuleCell thisCell = (ModuleCell)moduleCellMap.get(sn);
                                if(thisCell.getPolygon(viewCategory).contains(x,y)) return thisCell;
                                }
                                }
                                break;
                        case RODCRATE_VIEWS:
                                int ww = rcBoxWidth + rcBoxGap;
                                int midPoint = midX + rcXOffSet;
                                int yIndex = 47 - (y - yOffSet - rcYOffSet)/boxHeight;
                                if(yIndex<0 || yIndex>47) return null;
                                //              int thisXOffSet = midX + rcXOffSet - 8*ww + rcBoxGap;
                                int diff = x - midPoint;
                                diff += 8*ww;
                                int xIndex = diff/ww;
                                if(xIndex<0 || xIndex>16) return null;
                                int xdiff = midPoint - 8*(rcBoxWidth+rcBoxGap) + xIndex*(rcBoxWidth+rcBoxGap);
                                if(x-xdiff<rcBoxGap) return null; // in the gap
                                if(serialnos[RODCRATE_VIEWS]!=null && serialnos[RODCRATE_VIEWS][sctView]!=null && serialnos[viewCategory][sctView][xIndex]!=null && serialnos[viewCategory][sctView][xIndex][yIndex]!=null) {
                        return (ModuleCell) moduleCellMap.get(serialnos[RODCRATE_VIEWS][sctView][xIndex][yIndex]);
                        }
                                break;
                        default:
                        }

          return null;
    }

    public Set getSerialNumberList(int viewCategory, int sctView) {
            if(viewCategory==-1 || sctView==-1 || !isConfigured()) return new TreeSet();
                if(orderedList[viewCategory]==null || orderedList[viewCategory][sctView]==null) {
                        System.out.println("SctGUI::ConfigurationInterface null orderedlist");
                        return new TreeSet();
                        }
        return orderedList[viewCategory][sctView];
        }

        public Set[] buildSerialNumberMap() {
                Set[] serialNumberMap = new HashSet[sctViews];
                for(int i=0;i<sctViews;i++) serialNumberMap[i] = new HashSet(getSerialNumberList(SCT_VIEWS,i));
                return serialNumberMap;
                }

    public int getNumberOfModules(int viewCategory, int sctView) {
        return orderedList[viewCategory][sctView].size();
        }
    public int getTotalNumberOfModules() {
       return moduleCount;
       }
    public ModuleCell getModuleCell(String serialNo) {
      return (ModuleCell)moduleCellMap.get(serialNo);
      }

        public void drawRodCrateViewOutline(java.awt.Graphics2D g2, int selection) {
                g2.setColor(java.awt.Color.lightGray);
                g2.setFont(displayTextFont);
                java.awt.FontMetrics metrics = g2.getFontMetrics();
                int rowNo=0;
        int ww = rcBoxWidth + rcBoxGap;

                int thisXOffSet = midX + rcXOffSet - 8*ww + rcBoxGap;
                int thisYOffSet = yOffSet + rcYOffSet;
                int timX = thisXOffSet+1+8*ww;
                int[] timPolyX = {timX,timX,timX+rcBoxWidth,timX+rcBoxWidth};
                int[] timPolyY = {thisYOffSet,thisYOffSet+48*boxHeight,thisYOffSet+48*boxHeight,thisYOffSet};
                g2.setColor(java.awt.Color.lightGray);
        g2.fill(new java.awt.Polygon(timPolyX,timPolyY,4));
        g2.setColor(java.awt.Color.black);
                String[] letters = {"T","I","M"," ","M","O","D","U","L","E"};
                for(int i=0;i<letters.length;i++) {
                        int letterWidth = metrics.stringWidth(letters[i]);
                        int xlabel = timX+rcBoxWidth/2-letterWidth/2;
                        int ylabel = thisYOffSet+(i+1)*20;
                        g2.drawString(letters[i],xlabel,ylabel);
                        }

                g2.setColor(java.awt.Color.lightGray);
                for(int i=0;i<48;i++) {
                        String rowLabel = Integer.toString(rowNo);
                        int labelWidth = metrics.stringWidth(rowLabel);
                        int xLabel = thisXOffSet - labelWidth - 4;
                        for(int x=5;x<=21;x++) {
                if(x!=13) g2.drawRect(thisXOffSet + (x-5)*ww, thisYOffSet + (47-i)*boxHeight, rcBoxWidth, boxHeight);
                                }
                        g2.drawString(rowLabel,xLabel,thisYOffSet + (47-i)*boxHeight + boxHeight);
                        rowNo++;
                        }
                g2.setColor(java.awt.Color.lightGray);
                // draw overall outline
                g2.drawRect(thisXOffSet, thisYOffSet, rodSlots*ww - rcBoxGap, 48*boxHeight);

                int ylabeloffset = thisYOffSet + 50* boxHeight;

                boolean slots_used=false;
                for(int i=0;i<rodSlots;i++) {
                        boolean slotUsed = (serialnos[RODCRATE_VIEWS]!=null && serialnos[RODCRATE_VIEWS][selection]!=null && serialnos[RODCRATE_VIEWS][selection][i]!=null);
                        java.awt.Color labelColor = slotUsed ? java.awt.Color.black : java.awt.Color.lightGray;
                        if(slotUsed) slots_used=true;
                        g2.setColor(labelColor);
                        String slot = Integer.toString(i+5);
                        int labelWidth = metrics.stringWidth(slot);
                        int xlabeloffset = midX + rcXOffSet - 8*ww + (i+1)*ww - rcBoxWidth/2 - labelWidth/2;
                        g2.drawString(slot, xlabeloffset, ylabeloffset);
                        if(slotUsed) {
                                g2.drawRect(thisXOffSet + i*ww,thisYOffSet,rcBoxWidth,48*boxHeight); // draw ROD outline
                                Integer theSlot = new Integer(i+5);
                                if(slotMap[selection].containsKey(theSlot)) {
                                        String sampleSerialNo = (String)slotMap[selection].get(theSlot);
                                        String rodno = getSNInfo(sampleSerialNo,SNInfo.ROD_NUMBER);
                                        labelWidth = metrics.stringWidth(rodno);
                                        xlabeloffset = midX + rcXOffSet - 8*ww + (i+1)*ww - rcBoxWidth/2 - labelWidth/2;
                                        g2.drawString(rodno,xlabeloffset,ylabeloffset+boxHeight+10);
                                        }
                                }
                        }
                java.awt.Color labelColor = slots_used ? java.awt.Color.black : java.awt.Color.lightGray;
                g2.setColor(labelColor);
                String slotString = "Slot:";
                g2.drawString(slotString,thisXOffSet - 4 - metrics.stringWidth(slotString),ylabeloffset);
                slotString = "ID:";
                g2.drawString(slotString,thisXOffSet - 4 - metrics.stringWidth(slotString),ylabeloffset+boxHeight+10);
                }

        public void drawViewOutline(java.awt.Graphics2D g2,int viewCategory, int selection) {
                switch(viewCategory) {
                        case SCT_VIEWS:
                drawSCTViewOutline(g2,selection);
                                break;
                        case RODCRATE_VIEWS:
                                drawRodCrateViewOutline(g2,selection);
                                break;
                        default:
                        }
                }

    public void drawSCTViewOutline(java.awt.Graphics2D g2, int selection) {
        g2.setColor(java.awt.Color.lightGray);
        g2.setFont(displayTextFont);
        java.awt.FontMetrics metrics = g2.getFontMetrics();
        int rowNo=0;

        switch(selection) {
          case Barrel3:
          case Barrel4:
          case Barrel5:
          case Barrel6:
            int ilow = yOffSetCount[selection];
//            int ilow = 1;
            int ihigh = ilow+barrelRows[selection];
            int midX= maxWidth/2;

//            for(int y=ilow;y<ihigh;y++) {
            for(int y=ihigh-1;y>=ilow;y--) {
              String rowLabel = Integer.toString(rowNo);
              int labelWidth = metrics.stringWidth(rowLabel);
              int xLabel = midX - 6*boxWidth - labelWidth -8;

              int thisRow = rowNo;

              boolean rowUsed = (serialnos[SCT_VIEWS]!=null && serialnos[SCT_VIEWS][selection]!=null && serialnos[SCT_VIEWS][selection][thisRow]!=null);
              g2.setColor(java.awt.Color.lightGray);
              for(int x=-6;x<=6;x++) {
                if(x==0) continue;
                g2.drawRect(midX+(boxWidth*x),yOffSet+(y*boxHeight), boxWidth, boxHeight);
                }
              java.awt.Color labelColor = rowUsed ? java.awt.Color.black : java.awt.Color.lightGray;
              g2.setColor(labelColor);
              g2.drawString(rowLabel,xLabel,yOffSet+y*boxHeight+boxHeight);
              rowNo++;
              }
              g2.setColor(java.awt.Color.lightGray);
              g2.drawRect(midX - 6*boxWidth, yOffSet, 13*boxWidth, 56*boxHeight); //outer line for barrels 3,4,5

                          // the Z arrow...
                        int x1 = midX-100;
                        int x2 = midX+120;
            //          int yy = yOffSetCount[selection];
                //              int yy = ihigh * boxHeight;
                        int y1 = yOffSet + 58*boxHeight;
            //          int y1 = yOffSet +((yy-2)*boxHeight);
                        g2.drawLine(x1,y1,x2,y1);
                        g2.drawLine(x1,y1,x1+5,y1-5);
                        g2.drawLine(x1,y1,x1+5,y1+5);
                        g2.drawLine(x2,y1,x2-5,y1-5);
                        g2.drawLine(x2,y1,x2-5,y1+5);
                        g2.drawString("Z+",x1-20,y1);
                        g2.drawString("Z-",x2+10,y1);
              break;
           case EndCap1a:
           case EndCap1c:
           case EndCap7a:
           case EndCap7c:
           case EndCap8a:
           case EndCap8c:
              for(int quadrant=0;quadrant<4;quadrant++) {
                 for(int number=13;number<23;number++) {
                     calculateSCTPolygon(selection,quadrant,number);
                     if(polygon!=null) {
                        g2.setColor(java.awt.Color.white);
                        g2.fill(polygon);
                        g2.setColor(java.awt.Color.lightGray);
                        g2.draw(polygon);
                        }
                     }
                  }
              for(int quadrant=0;quadrant<4;quadrant++) {
                 for(int number=0;number<13;number++) {
                     calculateSCTPolygon(selection,quadrant,number);
                     if(polygon!=null) {
                        g2.setColor(java.awt.Color.white);
                        g2.fill(polygon);
                        g2.setColor(java.awt.Color.lightGray);
                        g2.draw(polygon);
                        }
                     }
                 }
              break;
           case EndCap2a:
           case EndCap2c:
           case EndCap3a:
           case EndCap3c:
           case EndCap4a:
           case EndCap4c:
           case EndCap5a:
           case EndCap5c:   
           case EndCap6a:
           case EndCap6c:   
              for(int quadrant=0;quadrant<4;quadrant++) {
                 for(int number=13;number<23;number++) {
                     calculateSCTPolygon(selection,quadrant,number);
                     if(polygon!=null) {
                        g2.setColor(java.awt.Color.white);
                        g2.fill(polygon);
                        g2.setColor(java.awt.Color.lightGray);
                        g2.draw(polygon);
                        }
                     }
                  }
              for(int quadrant=0;quadrant<4;quadrant++) {
                 for(int number=0;number<33;number++) {
                     if(number>=13 && number<23) continue;
                     calculateSCTPolygon(selection,quadrant,number);
                     if(polygon!=null) {
                        g2.setColor(java.awt.Color.white);
                        g2.fill(polygon);
                        g2.setColor(java.awt.Color.lightGray);
                        g2.draw(polygon);
                        }
                     }
                 }
              break;     
           case EndCap9a:
           case EndCap9c:
              for(int quadrant=0;quadrant<4;quadrant++) {
                 for(int number=0;number<13;number++) {
                     calculateSCTPolygon(selection,quadrant,number);
                     if(polygon!=null) g2.draw(polygon);
                     }
                 }
              break;
           default:     

            }

 
    }

  private void calculateRodCratePolygon(int slot, int channel) {
                int ww = rcBoxWidth+rcBoxGap;
                int xloc = maxWidth/2 - 8*ww + (slot-5)*ww + rcBoxGap + rcXOffSet;
                int yloc = yOffSet + rcYOffSet + (47-channel)*boxHeight;
                xPoints[0] = xPoints[1] = xloc;
                xPoints[2] = xPoints[3] = xloc+rcBoxWidth;
                yPoints[0] = yPoints[3] = yloc;
                yPoints[1] = yPoints[2] = yloc+boxHeight;
                polygon = new java.awt.Polygon(xPoints,yPoints,4);
                return;
                }

  private void calculateSCTPolygon(int view, int quadrant, int number) {

        if(view<4) {  // barrel 3,4,5 or 6
// uncomment next line to put -z on left
//        int xloc=maxWidth/2 + number*boxWidth;
// and next line to put -z on right
                int xloc=maxWidth/2 - number*boxWidth;
//        int yloc = yOffSet + (yOffSetCount[thisSCTView] + row)*boxHeight;
                int yloc = yOffSet + (yOffSetCount[view] + barrelRows[view] - quadrant - 1)*boxHeight;

//        int yloc = yOffSet + (1 + row)*boxHeight;
                xPoints[0] = xPoints[1] = xloc;
                xPoints[2] = xPoints[3] = xloc+boxWidth;
                yPoints[0] = yPoints[3] = yloc;
                yPoints[1] = yPoints[2] = yloc+boxHeight;
                        polygon = new java.awt.Polygon(xPoints,yPoints,4);
                        return;
                        }

                // everything from here is for endcaps
                double thetaOffset=0.;
        double theta=0.;
        int rindex=0;
        int segment=0;
        int modules=0;
        if(number<13) {
             thetaOffset = Math.PI/52.;
             theta = Math.PI/26.;
             rindex=4;
             segment=number;
             modules=13;
//********************************
// encap 9 disks - module numbering in each MUR is reversed
// ie 0<-->5, 1<-->4 etc
// 6 special case
// 7 <-->12, 8<-->11 etc
//********************************
//
//    CHANGED BY PJD & JV 15/02/05
//    This fix is now done in sctConf/configuration.cc 
//           if((view==EndCap9a || view==EndCap9c) && segment!=6) {
//             if(segment<6) segment = Math.abs(segment-5);
//             else segment = Math.abs(segment-19);
//             }
             }
        else if(number>=13 && number<23) {
             thetaOffset=0.;
             theta = Math.PI/20.;
             rindex=2;
             segment=number-13;
             modules=10;
             }
        else {
             thetaOffset=Math.PI/40.;
             theta = Math.PI/20.;
             rindex=0;
             segment=number-23;
             modules=10;
             }
        segment += quadrant*modules;

        xPoints[0] = midX+(int)(radius[rindex]*Math.sin(segment*theta+thetaOffset));
        xPoints[1] = midX+(int)(radius[rindex]*Math.sin((segment+1)*theta+thetaOffset));
        xPoints[2] = midX+(int)(radius[rindex+1]*Math.sin((segment+1)*theta+thetaOffset));
        xPoints[3] = midX+(int)(radius[rindex+1]*Math.sin(segment*theta+thetaOffset));

        yPoints[0] = midY-(int)(radius[rindex]*Math.cos(segment*theta+thetaOffset));
        yPoints[1] = midY-(int)(radius[rindex]*Math.cos((segment+1)*theta+thetaOffset));
        yPoints[2] = midY-(int)(radius[rindex+1]*Math.cos((segment+1)*theta+thetaOffset));
        yPoints[3] = midY-(int)(radius[rindex+1]*Math.cos(segment*theta+thetaOffset));
        polygon = new java.awt.Polygon(xPoints,yPoints,4);
//        for(int i=0;i<4;i++) System.out.println("Polygon : Quadrant="+quadrant+" number="+number+" XY("+i+") : "+xPoly[i]+","+yPoly[i]);
        }

   public void updateModuleGroups(List cellList) {
       for(int i=0;i<cellList.size();i++) {
           ModuleCell thisCell = (ModuleCell)cellList.get(i);
           try {
              SystemInterface.getInstance().getConfigurationService().setModuleGroup(thisCell.getSerialNo(),(short)thisCell.getModuleGroup());
           }catch(Exception e){System.err.println("Exception setting modulegroup for module "+thisCell.getSerialNo()+" : "+e.toString());}
           }
       }
   private void writeLookUpTable() {
       String directory = Preferences.PreferencesInterface.getInstance().getPreference(Preferences.PreferencesInterface.WEB_LOOKUP_DIR);
       if(directory.equals(Preferences.PreferencesInterface.unDefinedString)) return;

//       Map lookupMap = getLookUpMap(directory);

       for(int i=0;i<SCTViewNames.length;i++) {
          Map lookupMap = new HashMap();
          Set moduleList = getSerialNumberList(SCT_VIEWS,i);
          for (java.util.Iterator m = moduleList.iterator(); m.hasNext(); ) {
             String thisSN=(String)m.next();
             ModuleCell thisCell = getModuleCell(thisSN);
             String desc = SCTViewNames[i]+", Row "+thisCell.getRow()+", Position "+thisCell.getPosition();
             lookupMap.put(thisSN,desc);
             }
             if(lookupMap.size()>0) saveLookUpMap(i,directory,lookupMap);
          }

        }
   private Map getLookUpMap(String directory) {
        Map thisMap = new HashMap();
        java.util.regex.Pattern p = java.util.regex.Pattern.compile("(\\d{14})=(.*)");
        java.io.File lookupFile = new java.io.File(directory,"moduleMap.txt");
        try {
          if(lookupFile.exists()) {
            java.io.BufferedReader in = new java.io.BufferedReader(new java.io.FileReader(lookupFile));
            String line;
            while((line=in.readLine())!=null) {
               java.util.regex.Matcher matcher = p.matcher(line);
               if(matcher.matches()) thisMap.put(line.substring(matcher.start(1),matcher.end(1)),line.substring(matcher.start(2),matcher.end(2)));
               }
            in.close();
           }
         }catch(Exception e){System.err.println("SctGUI::ConfigurationInterface - Exception reading in "+lookupFile.getName()+" - "+e.toString());}
         return thisMap;
         }
   private void saveLookUpMap(int view,String directory,Map thisMap) {
        java.io.File lookupFile = new java.io.File(directory,"moduleMap"+Integer.toString(view)+".txt");
        int lineCount=0;
        try {
          java.io.BufferedWriter out = new java.io.BufferedWriter(new java.io.FileWriter(lookupFile));
          String line;
          for (Iterator i=thisMap.entrySet().iterator(); i.hasNext(); ) {
            Map.Entry e = (Map.Entry) i.next();
            out.write((String)e.getKey()+"="+(String)e.getValue());
            out.newLine();
            lineCount++;
            }
           out.close();
//           System.out.println("SctGUI::ConfigurationInterface - wrote "+lineCount+" records to "+lookupFile.getName());
         }catch(Exception e){System.err.println("SctGUI::ConfigurationInterface - Exception writing to "+lookupFile.getName()+" - "+e.toString());}         
         }
         
          
           


        


}

---