package atlantis.utils;
 
 import java.util.ArrayList;
 
 /**
  * This class contains methods for extracting various properties from the 32 bit
  * identifiers used for hits. It works very similarly to the IdHelpers in Athena,
  * hence its name.
  *
  * @author Eric Jansen
  */
 public class AIdHelper {
 
     // These and all the other numbers in this class have been taken from Athena.
     private static final int MAX_BIT = 0x80000000;
     private static final int PIXEL_MASK = 0x000000FF;
     private static final int[] SUBDETECTOR = {2, 4, 5, 7, 10};
     private static final int[] LAR_PART = {-3, -2, -1, 1, 2, 3, 4, 5};
     private static final int[] LAR_BARREL_ENDCAP = {-3, -2, -1, 1, 2, 3};
     private static final int[] LAR_POS_NEG = {-2, 2};
     private static final String[] STATION_NAME = {"BIL", "BIS", "BML", "BMS", "BOL", "BOS", "BEE", "BIR",
                                                   "BMF", "BOF", "BOG", "EIL", "EEL", "EES", "EML", "EMS",
                                                   "EOL", "EOS", "T1F", "T1E", "T2F", "T2E", "T3F", "T3E",
                                                   "T4F", "T4E", "EIS", "CSS", "CSL", "BIM"};
     private static final int[] CSC_ETA = {-1, 1};
     private static final int[] TGC_ETA = {-5, -4, -3, -2, -1, 1, 2, 3, 4, 5};
     private static final int[] SCT_BARREL_ENDCAP = {-2, 0, 2};
     private static final int[] TRT_BARREL_ENDCAP = {-2, -1, 1, 2};
     
     
     
 
     /**
      * Returns the decoded athena identifier (id) as a string, resp. an
      * array of strings: first item is the full id expanded (decoded) and
      * particular subparts are separated by "/" in one sting, further
      * interesting subparts of the decoded id are provided in the following
      * items of the array with an explanation given.
      * So far (2009-01-20), this is implemented only for LAr and Tile, for
      * other subsystems only first array item is returned with the expanded
      * id.
      * @param id int compact identifier
      * @return String decoded identifier
      */
     public static final String[] getFullIdentifier(int id)
     {
         // more than 10 items should not be necessary
         ArrayList<String> r = new ArrayList<String>(10);
         String s = null;
 
         try 
         {
             switch (subDetector(id))
             {
                 case 2:
                     switch (indetPart(id))
                     {
                         case 1:
                             // Pixel identifiers are complicated and we don't use them anyway.
                             throw new AAtlantisException("Pixel identifiers not implemented: " + id);
                         case 2:
                             s = "2/2/" + sctBarrelEndcap(id) + "/" +
                                 sctLayerDisk(id) + "/" + sctPhiModule(id) + "/" +
                                 sctEtaModule(id) + "/" + sctPhiIndex(id) + "/" +
                                 sctEtaIndex(id); 
                             r.add(s);
                             return r.toArray(new String[r.size()]);
                         case 3:
                             
                             int part = 3;
                             int barrelEndcap = trtBarrelEndcap(id);
                             int layerWheel = trtLayerWheel(id);
                             int phiModule = trtPhiModule(id);
                             int strawLayer = trtStrawLayer(id);
                             int straw = trtStraw(id);
                                    
                             s = "2" + "/" + part + "/" + barrelEndcap + "/" +
                                 layerWheel + "/" + phiModule + "/" + strawLayer +
                                 "/" + straw;
                             r.add(s);
                             r.add("barrel-endcap: " + barrelEndcap);
                             r.add("layer wheel: " + layerWheel);
                             r.add("phi module: " + phiModule);
                             r.add("straw layer: " + strawLayer);
                             r.add("straw: " + straw);
                             return r.toArray(new String[r.size()]);
                             
                         default:
                             throw new AAtlantisException("Invalid identifier: " + id);
                     }
                 case 4:
                     int part = larPart(id);
                     int sampling = larSampling(id);
                     int eta = larEta(id);
                     int phi = larPhi(id);
                     
                     if(part == 1) // LAr barrel, LAr endcap
                     {
                         int barrelEndcap = larBarrelEndcap(id);
                         int region = larRegion(id);
                         s = "4/" + part + "/" + barrelEndcap + "/" +
                             sampling + "/" + region + "/" + eta + "/" + phi;
                         r.add(s);
                         if(barrelEndcap == 1)
                         {
                             r.add("barrel A");
                         }
                         else if(barrelEndcap == -1)
                         {
                             r.add("barrel C");
                         }
                         else if(barrelEndcap == 2 || barrelEndcap == 3)
                         {
                             r.add("endcap A");
                         }
                         else if(barrelEndcap == -2 || barrelEndcap == -3)
                         {
                             r.add("endcap C");
                         }
                     }
                     else if(part == 2) // HEC
                     {
                         int posNeg = larPosNeg(id);
                         int region = larRegion(id);
                         s = "4/" + part + "/" + posNeg + "/" + sampling + "/" +
                             region + "/" + eta + "/" + phi;
                         r.add(s);
                         if(posNeg == 2)
                         {
                             r.add("endcap A");
                         }
                         else if(posNeg == -2)
                         {
                             r.add("endcap C");
                         }
                     }
                     else if(part == 3) // FCAL
                     {
                         int posNeg = larPosNeg(id);
                         s = "4/" + part + "/" + posNeg + "/" + sampling + "/" +
                             eta + "/" + phi;
                         r.add(s);
                         if(posNeg == 2)
                         {
                             r.add("endcap A");
                         }
                         else if(posNeg == -2)
                         {
                             r.add("endcap C");
                         }                        
                     }
                     else
                     {
                         throw new AAtlantisException("Invalid identifier: " + id);
                     }
                     
                     r.add("sampling: " + sampling); // sampling remains          
                     
                     return r.toArray(new String[r.size()]);
                     
                 case 5:
                     // tile calorimeter (first number of full id is 5)
                     int section = tileSection(id);
                     int side = tileSide(id);
                     int module = tileSide(id);
                     int tower = tileTower(id);
                     sampling = tileSampling(id);
                     int pmt = tilePmt(id);
                     int adc = tileAdc(id);
                     
                     s = "5/" + section + "/" + side + "/" + module + "/" + 
                         tower + "/" + sampling + "/" + pmt + "/" + adc;
                     r.add(s);
                     
                     r.add("section: " + section);
                     r.add("side: " + side);
                     r.add("module: " + module);
                     r.add("tower: " + tower);
                     r.add("sampling: " + sampling);
                     r.add("PMT: " + pmt);
                     r.add("ADC: " + adc);
                     
                     return r.toArray(new String[r.size()]);
                     
                 case 7:
                     String technology = technology(id);
                     if (technology == "MDT") 
                     {
                         s = "7/" + stationName(id) + "/" + stationEta(id) +
                             "/" + stationPhi(id) + "/" + "MDT/" +
                             mdtMultiLayer(id) + "/" + mdtTubeLayer(id) + "/" +
                             mdtTube(id);
                         r.add(s);
                         return r.toArray(new String[r.size()]);
                     }
                     else if (technology == "RPC")
                     {
                         s = "7/" + stationName(id) + "/" + stationEta(id) + "/" +
                             stationPhi(id) + "/" + "RPC/" + rpcDoubletR(id) + "/" +
                             rpcDoubletZ(id) + "/" + rpcDoubletPhi(id) + "/" +
                             rpcGasGap(id) + "/" + rpcMeasuresPhi(id) + "/" +
                             rpcStrip(id);
                         r.add(s);
                         return r.toArray(new String[r.size()]);
                     }
                     else if (technology == "TGC")
                     {
                         s = "7/" + stationName(id) + "/" + stationEta(id) +
                             "/" + stationPhi(id) + "/" + "TGC/" + tgcGasGap(id) +
                             "/" + tgcIsStrip(id) + "/" + tgcChannel(id);
                         r.add(s);
                         return r.toArray(new String[r.size()]);                        
                     }
                     else if (technology == "CSC")
                     {
                         s = "7/" + stationName(id) + "/" + stationEta(id) + "/" +
                             stationPhi(id) + "/" + "CSC/" + cscChamberLayer(id) +
                             "/" + cscWireLayer(id) + "/" + cscMeasuresPhi(id) +
                             "/" + cscStrip(id);
                         r.add(s);
                         return r.toArray(new String[r.size()]);                                                
                     }
                     else
                     {
                         throw new AAtlantisException("Invalid identifier: " + id);
                     }
                 default:
                     throw new AAtlantisException("Not yet implemented for identifier: " + id);
             }
         } 
         catch (AAtlantisException e) 
         {
             s = id + " (unable to decode: " + e.getMessage() + ")";
             r.add(s);
             return r.toArray(new String[r.size()]);                                                
         }
         
     } // getFullIdentifier() ------------------------------------------------
 
     
     
     /**
      * Extracts the subdetector field.
      * @param id int compact identifier
      * @return int subdetector identifier
      * @throws AAtlantisException
      */
     public static final int subDetector(int id) throws AAtlantisException {
         int subDetectorIndex = id >> 29 & 7;
         if (subDetectorIndex >= SUBDETECTOR.length) {
             throw new AAtlantisException("Invalid subdetector field in identifier: " + id);
         }
         return SUBDETECTOR[subDetectorIndex];
     }
 
     public static final int indetPart(int id) throws AAtlantisException {
         if (subDetector(id) != 2) {
             throw new AAtlantisException("Not an InDet identifier: " + id);
         }
         if ((id & MAX_BIT) == MAX_BIT && (id & PIXEL_MASK) > 0) {
             return 1;
         } else {
             return (id >> 27 & 3) + 1;
         }
     }
 
     public static final int trtBarrelEndcap(int id) throws AAtlantisException {
         if (indetPart(id) != 3) {
             throw new AAtlantisException("Not a TRT identifier: " + id);
         }
         int trtBarrelEndcapIndex = id >> 25 & 3;
         if (trtBarrelEndcapIndex >= TRT_BARREL_ENDCAP.length) {
             throw new AAtlantisException("Invalid barrelEndcap field in identifier: " + id);
         }
         return TRT_BARREL_ENDCAP[trtBarrelEndcapIndex];
     }
 
 
     public static final int trtLayerWheel(int id) throws AAtlantisException {
         if (indetPart(id) != 3) {
             throw new AAtlantisException("Not a TRT identifier: " + id);
         }
         return id >> 15 & 31;
     }
 
     public static final int trtPhiModule(int id) throws AAtlantisException {
         if (indetPart(id) != 3) {
             throw new AAtlantisException("Not a TRT identifier: " + id);
         }
         return id >> 20 & 31;
     }
 
     public static final int trtStrawLayer(int id) throws AAtlantisException {
         if (indetPart(id) != 3) {
             throw new AAtlantisException("Not a TRT identifier: " + id);
         }
         return id >> 10 & 31;
     }
 
     public static final int trtStraw(int id) throws AAtlantisException {
         if (indetPart(id) != 3) {
             throw new AAtlantisException("Not a TRT identifier: " + id);
         }
         return id >> 5 & 31;
     }
 
     public static final int sctBarrelEndcap(int id) throws AAtlantisException {
          if (indetPart(id) != 2) {
              throw new AAtlantisException("Not an SCT identifier: " + id);
          }
          int sctBarrelEndcapIndex = id >> 25 & 3;
          if (sctBarrelEndcapIndex >= SCT_BARREL_ENDCAP.length) {
              throw new AAtlantisException("Invalid barrelEndcap field in identifier: " + id);
          }
          return SCT_BARREL_ENDCAP[sctBarrelEndcapIndex];
     }
 
     public static final int sctLayerDisk(int id) throws AAtlantisException {
         if (indetPart(id) != 2) {
             throw new AAtlantisException("Not an SCT identifier: " + id);
         }
         return id >> 21 & 15;
     }
 
     public static final int sctPhiModule(int id) throws AAtlantisException {
         if (indetPart(id) != 2) {
             throw new AAtlantisException("Not an SCT identifier: " + id);
         }
         return id >> 15 & 63;
     }
 
     public static final int sctEtaModule(int id) throws AAtlantisException {
         if (indetPart(id) != 2) {
             throw new AAtlantisException("Not an SCT identifier: " + id);
         }
         return (id >> 11 & 15) - 6;
     }
 
     public static final int sctPhiIndex(int id) throws AAtlantisException {
         if (indetPart(id) != 2) {
             throw new AAtlantisException("Not an SCT identifier: " + id);
         }
         return id >> 10 & 1;
     }
 
     public static final int sctEtaIndex(int id) throws AAtlantisException {
         if (indetPart(id) != 2) {
             throw new AAtlantisException("Not an SCT identifier: " + id);
         }
         return id & 1023;
     }
 
     public static final int larPart(int id) throws AAtlantisException {
         if (subDetector(id) != 4) {
             throw new AAtlantisException("Not a LAr identifier: " + id);
         }
         int larPartIndex = id >> 26 & 7;
         if(larPartIndex >= LAR_PART.length) {
             throw new AAtlantisException("Invalid part field in identifier: " + id);
         }
         return LAR_PART[larPartIndex];
     }
 
     public static final int larBarrelEndcap(int id) throws AAtlantisException {
         if (subDetector(id) != 4) {
             throw new AAtlantisException("Not a LAr identifier: " + id);
         }
         int larBarrelEndcapIndex = id >> 23 & 7;
         if(larBarrelEndcapIndex >= LAR_BARREL_ENDCAP.length) {
             throw new AAtlantisException("Invalid barrel-endcap field in identifier: " + id);
         }
         return LAR_BARREL_ENDCAP[larBarrelEndcapIndex];
     }
 
     public static final int larPosNeg(int id) throws AAtlantisException {
         if (larPart(id) < 2) {
             throw new AAtlantisException("Not a LAr HEC/FCAL identifier: " + id);
         }
         int larPosNegIndex = id >> 25 & 1;
         if(larPosNegIndex >= LAR_POS_NEG.length) {
             throw new AAtlantisException("Invalid pos-neg field in identifier: " + id);
         }
         return LAR_POS_NEG[larPosNegIndex];
     }
 
     public static final int larSampling(int id) throws AAtlantisException {
         switch (larPart(id)) {
             case 1:
                 return id >> 21 & 3;
             case 2:
             case 3:
                 return id >> 23 & 3;
             default:
                 throw new AAtlantisException("Not a LAr EM/HEC identifier: " + id);
         }
     }
 
     public static final int larRegion(int id) throws AAtlantisException {
         switch (larPart(id)) {
             case 1:
                 return id >> 18 & 7;
             case 2:
                 return id >> 22 & 1;
             default:
                 throw new AAtlantisException("Not a LAr EM/HEC identifier: " + id);
         }
     }
 
     public static final int larEta(int id) throws AAtlantisException {
         switch (larPart(id)) {
             case 1:
                 return id >> 9 & 511;
             case 2:
                 return id >> 18 & 15;
             case 3:
                 return id >> 17 & 63;
             default:
                 throw new AAtlantisException("Not a LAr EM/HEC/FCAL identifier: " + id);
         }
     }
 
     public static final int larPhi(int id) throws AAtlantisException {
         switch (larPart(id)) {
             case 1:
                 return id >> 1 & 255;
             case 2:
                 return id >> 12 & 63;
             case 3:
                 return id >> 13 & 15;
             default:
                 throw new AAtlantisException("Not a LAr EM/HEC/FCAL identifier: " + id);
         }
     }
 
     public static final int larModule(int id) throws AAtlantisException {
         if (larPart(id) != 3) {
             throw new AAtlantisException("Not an FCAL identifier: " + id);
         }
         return id >> 21 & 3;
     }
 
 
     public static final boolean larIsBarrel(int id) throws AAtlantisException
     {
         switch(Math.abs(larBarrelEndcap(id)))
         {
             case 1:
                 return true;  // yes, it's barrel
             case 2:
                 return false; // is endcap
             case 3:
                 return false; // is endcap
             default:
                 throw new AAtlantisException("Not a LAr identifier: " + id);
         }
     }
 
 
     public static final int tileSection(int id) throws AAtlantisException {
         if (subDetector(id) != 5) {
             throw new AAtlantisException("Not a TILE identifier: " + id);
         }
         return id >> 26 & 7;
     }
 
     public static final int tileSide(int id) throws AAtlantisException {
         if (subDetector(id) != 5) {
             throw new AAtlantisException("Not a TILE identifier: " + id);
         }
         return (id >> 22 & 15) - 1;
     }
 
     public static final int tileModule(int id) throws AAtlantisException {
         if (subDetector(id) != 5) {
             throw new AAtlantisException("Not a TILE identifier: " + id);
         }
         return id >> 14 & 255;
     }
 
     public static final int tileTower(int id) throws AAtlantisException {
         if (subDetector(id) != 5) {
             throw new AAtlantisException("Not a TILE identifier: " + id);
         }
         return id >> 8 & 63;
     }
 
     public static final int tileSampling(int id) throws AAtlantisException {
         if (subDetector(id) != 5) {
             throw new AAtlantisException("Not a TILE identifier: " + id);
         }
         return id >> 4 & 15;
     }
 
     public static final int tilePmt(int id) throws AAtlantisException {
         if (subDetector(id) != 5) {
             throw new AAtlantisException("Not a TILE identifier: " + id);
         }
         return id >> 2 & 3;
     }
 
     public static final int tileAdc(int id) throws AAtlantisException {
         if (subDetector(id) != 5) {
             throw new AAtlantisException("Not a TILE identifier: " + id);
         }
         return id & 3;
     }
 
 
     /**
      * Decodes Athena 32-bit ID to following form (5 is Tile):
      * 5/section/side/module/tower/sampling/pmt/adc - official identifier
      *
      * Identifier used by TileCal collaboration, conversion is clear from the
      * code and is explained in Sasha Solodkov's email on 2006-09-18
      *
      * @param id int
      * @return String
      */
     public static final String getDecodedTileIndentifier(int id)
     {
         try
         {
             int sec = tileSection(id);
             int side = tileSide(id);
             int mod = tileModule(id);
             int tow = tileTower(id);
             int samp = tileSampling(id);
 
             // section/side/module into decoded form
             String secSideMod = "\n[could not work out section/side]";
             mod++;
             if(sec == 1 && side == 1)  secSideMod = "LBA" + mod;
             if(sec == 1 && side == -1) secSideMod = "LBC" + mod;
             if(sec == 2 && side == 1)  secSideMod = "EBA" + mod;
             if(sec == 3 && side == 1)  secSideMod = "EBA" + mod;
             if(sec == 2 && side == -1) secSideMod = "EBC" + mod;
             if(sec == 3 && side == -1) secSideMod = "EBC" + mod;
 
             // sampling/tower into decoded form
             String sampTow = "\n[could not work out sampling/tower]";
             if(samp == 0) sampTow = "A" + (int)(tow + 1);
             if(samp == 1) sampTow = "B" + (int)(tow + 1);
             if(samp == 2) sampTow = "D" + (int)(tow/2);
             if(samp == 3)
             {
                 if(tow == 10) sampTow = "E1";
                 if(tow == 11) sampTow = "E2";
                 if(tow == 13) sampTow = "E3";
                 if(tow == 15) sampTow = "E4";
             }
 
             return secSideMod + " " + sampTow;
         }
         catch (AAtlantisException e)
         {
             return id + " (unable to decode: " + e.getMessage() + ")";
         }
     }
 
 
     /**
      * Extracts the station name for a muon station.
      * @param id int compact identifier
      * @return String station name
      * @throws AAtlantisException
      */
     public static final String stationName(int id) throws AAtlantisException {
         if (subDetector(id) != 7) {
             throw new AAtlantisException("Invalid subdetector field in identifier: " + id);
         }
         int stationNameIndex = id >> 24 & 31;
         if (stationNameIndex >= STATION_NAME.length) {
             throw new AAtlantisException("Invalid stationName field in identifier: " + id);
         }
         return STATION_NAME[stationNameIndex];
     }
 
     /**
      * Extracts the technology (MDT, RPC, TGC, CSC) for a muon station.
      * @param id int compact identifier
      * @return String technology
      * @throws AAtlantisException
      */
     public static final String technology(int id) throws AAtlantisException {
         String stationName = stationName(id);
         switch (stationName.charAt(0)) {
             case 'T':
                 return "TGC";
             case 'C':
                 return "CSC";
             default:
                 int technologyIndex = id >> 15 & 1;
                 switch (technologyIndex) {
                     case 0:
                         return "MDT";
                     case 1:
                         return "RPC";
                     default:
                         throw new AAtlantisException("Invalid technology field in identifier: " + id);
                 }
         }
     }
 
     /**
      * Extracts the eta index for a muon station.
      * @param id int compact identifier
      * @return int eta index
      * @throws AAtlantisException
      */
     public static final int stationEta(int id) throws AAtlantisException {
         int etaIndex;
         String technology = technology(id);
 
         if (technology.equals("MDT") || technology.equals("RPC")) {
             return (id >> 19 & 31) - 8;
         } else if (technology.equals("TGC")) {
             etaIndex = id >> 20 & 15;
             if (etaIndex >= TGC_ETA.length) {
                 return 0;
             } else {
                 return TGC_ETA[etaIndex];
             }
         } else if (technology.equals("CSC")) {
             etaIndex = id >> 23 & 1;
             if (etaIndex >= CSC_ETA.length) {
                 return 0;
             } else {
                 return CSC_ETA[etaIndex];
             }
         } else {
             throw new AAtlantisException("Invalid stationEta field in identifier: " + id);
         }
     }
 
     /**
      * Extracts the phi index for a muon station.
      * @param id int compact identifier
      * @return int phi index
      * @throws AAtlantisException
      */
     public static final int stationPhi(int id) throws AAtlantisException {
         String technology = technology(id);
         if (technology.equals("MDT") || technology.equals("RPC")) {
             return (id >> 16 & 7) + 1;
         } else if (technology.equals("TGC")) {
             return (id >> 14 & 63) + 1;
         } else if (technology.equals("CSC")) {
             return (id >> 20 & 7) + 1;
         } else {
             throw new AAtlantisException("Invalid technology field in identifier: " + id);
         }
     }
 
     /**
      * Extracts the MDT multilayer index from an MDT identifier.
      * @param id int compact identifier
      * @return int multilayer index
      * @throws AAtlantisException
      */
     public static final int mdtMultiLayer(int id) throws AAtlantisException {
         if (!technology(id).equals("MDT")) {
             throw new AAtlantisException("Not an MDT identifier: " + id);
         }
         return (id >> 14 & 1) + 1;
     }
 
     /**
      * Extracts the MDT tubelayer index from an MDT identifier.
      * @param id int compact identifier
      * @return int tubelayer index
      * @throws AAtlantisException
      */
     public static final int mdtTubeLayer(int id) throws AAtlantisException {
         if (!technology(id).equals("MDT")) {
             throw new AAtlantisException("Not an MDT identifier: " + id);
         }
         return (id >> 12 & 3) + 1;
     }
 
     /**
      * Extracts the tube number from an MDT identifier.
      * @param id int compact identifier
      * @return int tube number
      * @throws AAtlantisException
      */
     public static final int mdtTube(int id) throws AAtlantisException {
         if (!technology(id).equals("MDT")) {
             throw new AAtlantisException("Not an MDT identifier: " + id);
         }
         return (id >> 5 & 127) + 1;
     }
 
     /**
      * Extracts the RPC doublet index in r.
      * @param id int compact identifier
      * @return int RPC r doublet index
      * @throws AAtlantisException
      */
     public static final int rpcDoubletR(int id) throws AAtlantisException {
         if (!technology(id).equals("RPC")) {
             throw new AAtlantisException("Not an RPC identifier: " + id);
         }
         return (id >> 14 & 1) + 1;
     }
 
     /**
      * Extracts the RPC doublet index in z.
      * @param id int compact identifier
      * @return int RPC z doublet index
      * @throws AAtlantisException
      */
     public static final int rpcDoubletZ(int id) throws AAtlantisException {
         if (!technology(id).equals("RPC")) {
             throw new AAtlantisException("Not an RPC identifier: " + id);
         }
         return (id >> 12 & 3) + 1;
     }
 
     /**
      * Extracts the RPC doublet index in phi.
      * @param id int
      * @return int
      * @throws AAtlantisException
      */
     public static final int rpcDoubletPhi(int id) throws AAtlantisException {
         if (!technology(id).equals("RPC")) {
             throw new AAtlantisException("Not an RPC identifier: " + id);
         }
         return (id >> 11 & 1) + 1;
     }
 
     /**
      * Extract the RPC gas gap index.
      * @param id int compact identifier
      * @return int gas gap index
      * @throws AAtlantisException
      */
     public static final int rpcGasGap(int id) throws AAtlantisException {
         if (!technology(id).equals("RPC")) {
             throw new AAtlantisException("Not an RPC identifier: " + id);
         }
         return (id >> 10 & 1) + 1;
     }
 
     /**
      * Extracts if this elment measures phi or not.
      * @param id int compact identifier
      * @return int true (1) or false (0)
      * @throws AAtlantisException
      */
     public static final int rpcMeasuresPhi(int id) throws AAtlantisException {
         if (!technology(id).equals("RPC")) {
             throw new AAtlantisException("Not an RPC identifier: " + id);
         }
         return id >> 9 & 1;
     }
 
     /**
      * Extracts the RPC strip number.
      * @param id int compact identifier
      * @return int strip number
      * @throws AAtlantisException
      */
     public static final int rpcStrip(int id) throws AAtlantisException {
         if (!technology(id).equals("RPC")) {
             throw new AAtlantisException("Not an RPC identifier: " + id);
         }
         return (id >> 2 & 127) + 1;
     }
 
     /**
      * Extracts the RGC gas gap index
      * @param id int compact identifier
      * @return int gas gap index
      * @throws AAtlantisException
      */
     public static final int tgcGasGap(int id) throws AAtlantisException {
         if (!technology(id).equals("TGC")) {
             throw new AAtlantisException("Not a TGC identifier: " + id);
         }
         return (id >> 11 & 3) + 1;
     }
 
     /**
      * Extract if this element is a strip or not.
      * @param id int compact identifier
      * @return int true (1) or false (0)
      * @throws AAtlantisException
      */
     public static final int tgcIsStrip(int id) throws AAtlantisException {
         if (!technology(id).equals("TGC")) {
             throw new AAtlantisException("Not a TGC identifier: " + id);
         }
         return id >> 10 & 1;
     }
 
     /**
      * Extracts the TGC channel number.
      * @param id int compact identifier
      * @return int channel number
      * @throws AAtlantisException
      */
     public static final int tgcChannel(int id) throws AAtlantisException {
         if (!technology(id).equals("TGC")) {
             throw new AAtlantisException("Not a TGC identifier: " + id);
         }
         return (id >> 3 & 127) + 1;
     }
 
     /**
      * Extracts the chamber layer for a CSC.
      * @param id int compact identifier
      * @return int chamber layer
      * @throws AAtlantisException
      */
     public static final int cscChamberLayer(int id) throws AAtlantisException {
         if (!technology(id).equals("CSC")) {
             throw new AAtlantisException("Not a CSC identifier: " + id);
         }
         return (id >> 18 & 1) + 1;
     }
 
     /**
      * Extracts the wire layer for a CSC
      * @param id int compact identifier
      * @return int wire layer
      * @throws AAtlantisException
      */
     public static final int cscWireLayer(int id) throws AAtlantisException {
         if (!technology(id).equals("CSC")) {
             throw new AAtlantisException("Not a CSC identifier: " + id);
         }
         return (id >> 16 & 3) + 1;
     }
 
     /**
      * Extracts if this CSC element measures phi or not.
      * @param id int compact identifier
      * @return int true (1) or false (0)
      * @throws AAtlantisException
      */
     public static final int cscMeasuresPhi(int id) throws AAtlantisException {
         if (!technology(id).equals("CSC")) {
             throw new AAtlantisException("Not a CSC identifier: " + id);
         }
         return id >> 15 & 1;
     }
 
     /**
      * Extracts the CSC strip number.
      * @param id int compact identifier
      * @return int strip number
      * @throws AAtlantisException
      */
     public static final int cscStrip(int id) throws AAtlantisException {
         if (!technology(id).equals("CSC")) {
             throw new AAtlantisException("Not a CSC identifier: " + id);
         }
         return (id >> 7 & 255) + 1;
     }
 }

Due to the LXR bug, the updates fail sometimes to remove references to deleted files. The Saturday's full rebuilds fix these problems
This page was automatically generated by the LXR engine.