package triggertool.XML;
 
 import java.io.File;
 import java.sql.SQLException;
 import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Vector;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.logging.Logger;
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;
 
 import triggertool.L1Links.L1TM_TT;
 import triggertool.L1Links.L1TM_TTM;
 import triggertool.L1Records.L1Bunch;
 import triggertool.L1Records.L1BunchGroup;
 import triggertool.L1Records.L1BunchGroupSet;
 import triggertool.L1Records.L1CaloInfo;
 import triggertool.L1Records.L1CtpFiles;
 import triggertool.L1Records.L1CtpSmx;
 import triggertool.L1Records.L1Deadtime;
 import triggertool.L1Records.L1Item;
 import triggertool.L1Records.L1Master;
 import triggertool.L1Records.L1Menu;
 import triggertool.L1Records.L1MuctpiInfo;
 import triggertool.L1Records.L1MuonThresholdSet;
 import triggertool.L1Records.L1Prescale;
 import triggertool.L1Records.L1PrescaledClock;
 import triggertool.L1Records.L1Random;
 import triggertool.L1Records.L1Threshold;
 import triggertool.L1Records.L1ThresholdValue;
 
 ///Read L1 XML file and save to database.
 /**
  * Functionality to read a L1 XML file and convert, and save it to the database.
  * 
  * @author Simon Head
  */
 public class L1_XMLtoDB {
 
     ///Message Log.
     protected static Logger logger = Logger.getLogger(L1_XMLtoDB.class.getName());
     ///Used when parsing XML.
     private NodeList sections;
     ///Used by XML parser.
     private Document document;
     ///Hold the priority set.
     private String[] priority_array = new String[256];
     ///These are all the thresholds 
     private Hashtable<String, Integer> threshold_ids = new Hashtable<String, Integer>();
     ///forced thresholds
     private Hashtable<String, Integer> forcedthreshold_ids = new Hashtable<String, Integer>();
     ///List of threshold IDs.
     private Vector<Integer> threshold_id_list = new Vector<Integer>();
     ///Map of Thresholds that are "InternalTriggers" and have been loaded & saved
     private Map<String, L1Threshold> internaltrigthresholdsLoaded = null;
     ///Vector of L1 TM to TT links - required for cables.
     private Vector<L1TM_TT> cables_to_save = new Vector<L1TM_TT>();
     ///Threshold counter for when we combine thresholds into an item.
     private int mThresholdCounter = 0;
     ///A vector of the problems encountered before the upload.
     private Vector<String> faults = new Vector<String>();
     ///to store the new LVL1 prescale key.
     private int newLVL1PrescaleKey = 0;
     ///to store the new LVL1 bunch group key
     //private int newLVL1BGKey = 0;
     
     ///Constructor takes the filename of the L1 XML file to read only.
     /**
      * Constructor takes the filename.  The XML file is parsed and the information contained
      * within it is written to the database 
      * 
      * @param filename Path and filename of the L1 XML file to read in
      */
     public int readXML(String filename, String configname) {
         logger.info("In LVL1 read XML to DB, filename: " + filename);
         internaltrigthresholdsLoaded = new HashMap<String, L1Threshold>(100);
         
         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
         factory.setIgnoringComments(true);
         factory.setCoalescing(true);
         factory.setNamespaceAware(false);
         factory.setValidating(false);
 
         for (int i = 0; i < 256; ++i) {
             priority_array[i] = "";
         }
 
         DocumentBuilder parser;
 
         int l1_id = -1;
 
         try {
             parser = factory.newDocumentBuilder();
             document = parser.parse(new File(filename));
 
             check_xml();
 
             if (faults.size() == 0) {
                 logger.fine("Passed all checks, will start upload");
 
                 logger.fine("Reading Priority Set");
                 priority_set();
 
                 logger.fine("Reading Threshold List");
                 trigger_threshold_list();
 
                 logger.fine("Reading Random");
                 int rand_id = random();
 
                 logger.fine("Reading Deadtime");
                 int dt_id = deadtime();
 
                 logger.fine("Reading Prescaled Clock");
                 int pc_id = prescaled_clock();
 
                 logger.fine("Reading MUCTPI info");
                 int mu_id = muctpi_info();
 
                 logger.fine("Reading Calorimeter Info");
                 int ci_id = calo_info();
 
                 //PJB need to read PS and BGS before menu
                 logger.fine("Reading Bunch Groups");
                 int bg_id = bunch_group_set();
 
                 logger.fine("Reading Prescale Set");
                 newLVL1PrescaleKey = prescale_set(configname);
 
                 logger.fine("Reading Trigger Menu");
                 int menu_id = trigger_menu(configname);
                 
                 logger.fine("Reading CTP Monitor counters");
                 mon_counters(menu_id, bg_id);
 
                 logger.fine("Making a muon threshold set table");
                 int mts_id = muon_threshold_set();
                 
                 logger.fine("Making a L1 master " + menu_id + " " 
                                                   + dt_id + " "
                                                   + mu_id + " "
                                                   + rand_id + " "
                                                   + pc_id + " "
                                                   + ci_id + " "
                                                   + mts_id);
                 
                 l1_id = trigger_master(menu_id, dt_id, mu_id, rand_id, pc_id, ci_id, mts_id, configname);
 
                 logger.info("Finished uploading L1" +
                             "\n\tL1 Master ID =     " + l1_id);
             } else {
                 logger.warning("XML file has errors");
 
                 int i = 1;
                 for (String line : faults) {
                     logger.warning(i + " " + line);
                     ++i;
                 }
             }
         } catch (Exception e) {
             logger.warning(e.getMessage());
             e.printStackTrace();
         }
 
         return l1_id;
     }
 
     ///Get the prescale ID.
     /**
      * If this has made a new key, return the ID with this.
      * 
      * @return Integer ID of the prescale key.
      */
     public int getLVLPrescaleSetKey() {
         return newLVL1PrescaleKey;
     }
 
     ///Get the BG ID.
     /**
      * If this has made a new key, return the ID with this.
      * 
      * @return Integer ID of the BG key.
      */
     //public int getLVLBGSetKey() {
     //    return newLVL1BGKey;
     //}
     
     ///Read the CTP monitoring information from the XML file.
     private void mon_counters(int menu_id, int bgs_id) throws SQLException {
         sections = document.getElementsByTagName("TriggerCounterList");
 
         if (sections.getLength() == 1) {
             Element section = (Element) sections.item(0);
 
             logger.fine(section.getNodeName());
 
             NodeList counterlist = section.getElementsByTagName("TriggerCounter");
             for (int i = 0; i < counterlist.getLength(); ++i) {
                 Element thiscounter = (Element) counterlist.item(i);
 
                 String threshold = thiscounter.getAttribute("triggerthreshold");
                 logger.fine("Counter " + thiscounter.getAttribute("name") + ", " + threshold + ", " + thiscounter.getAttribute("multi") + ", " + thiscounter.getAttribute("type"));
 
                 int saved_threshold_id = threshold_ids.get(threshold);
                 //logger.info("Adding to set threshold " + threshold + " at id " + saved_threshold_id);
 
                 L1TM_TTM db_counter = new L1TM_TTM(-1);
                 db_counter.set_menu_id(menu_id);
                 db_counter.set_threshold_id(saved_threshold_id);
                 db_counter.set_bunch_group_id(-1);
                 db_counter.set_counter_name(thiscounter.getAttribute("name"));
                 db_counter.set_multiplicity(Integer.parseInt(thiscounter.getAttribute("multi")));
                 db_counter.set_type(thiscounter.getAttribute("type"));
 
                 db_counter.save();
                 logger.fine("Counter save ok");
             }
         } else {
             logger.warning("Probably no TRIGGERCOUNTERLIST NODE in this xml");
         }
     }
 
     ///Read the priority set node.
     /**
      * Deal with the priority set in the XML.  Here we just want to read them
      * in to memory because they're stored as part of an item.  Which we are
      * creating later.
      */
     private void priority_set() {
         sections = document.getElementsByTagName("PrioritySet");
 
         if (sections.getLength() == 1) {
             Element section = (Element) sections.item(0);
 
             NodeList priority = section.getElementsByTagName("Priority");
             for (int i = 0; i < priority.getLength(); ++i) {
                 Element thispriority = (Element) priority.item(i);
                 priority_array[Integer.parseInt(thispriority.getAttribute("ctpid").trim())] = thispriority.getTextContent().trim();
                 logger.fine("  " + thispriority.getNodeName() + "- ctpid=" + thispriority.getAttribute("ctpid") + ", value=" + thispriority.getTextContent().trim());
             }
         } else {
             logger.warning("TOO MANY PRIORITYSET NODES IN XML");
         }
     }
 
     ///Read a threshold value.
     /**
      * Reads the L1 threshold value node and converts it into the object used
      * by the trigger tool.  Also saves to the database.
      * 
      * @param ttv_node The XML TriggerThresholdValue node.
      * @return The ID of the trigger threshold value.
      */
     private L1ThresholdValue threshold_value(Element ttv_node) throws SQLException {
         logger.fine("Threshold value name " + ttv_node.getAttribute("name"));
         L1ThresholdValue newThresholdV = new L1ThresholdValue(-1);
         newThresholdV.set_name(ttv_node.getAttribute("name"));
         newThresholdV.set_em_isolation(ttv_node.getAttribute("em_isolation"));
         newThresholdV.set_eta_max(Integer.parseInt(ttv_node.getAttribute("etamax")));
         newThresholdV.set_eta_min(Integer.parseInt(ttv_node.getAttribute("etamin")));
         newThresholdV.set_phi_min(Integer.parseInt(ttv_node.getAttribute("phimin")));
         newThresholdV.set_phi_max(Integer.parseInt(ttv_node.getAttribute("phimax")));
         newThresholdV.set_priority(Integer.parseInt(ttv_node.getAttribute("priority")));
         newThresholdV.set_window(Integer.parseInt(ttv_node.getAttribute("window")));
         newThresholdV.set_had_veto(ttv_node.getAttribute("had_veto"));
         newThresholdV.set_had_isolation(ttv_node.getAttribute("had_isolation"));
         newThresholdV.set_pt_cut(ttv_node.getAttribute("thresholdval"));
         newThresholdV.set_type(ttv_node.getAttribute("type"));
 
         if (newThresholdV.get_type().equals("BG")) {
             newThresholdV.set_type(L1Threshold.BG_TYPE);
         }
 
         if (newThresholdV.get_type().equals("RND")) {
             newThresholdV.set_type(L1Threshold.RND_TYPE);
         }
 
         newThresholdV.save();
 
         return newThresholdV;
     }
 
     ///Read a threhold.
     /**
      * Read a threshold from the XML file.  If the old style XML notation is
      * used for Bunch Group or Random (type=BG or RND) replace it with the
      * new style notation as defined in L1Threshold.
      * 
      * @param threshold XML node for the element.
      * @return ID of the trigger threshold.
      * @throws java.sql.SQLException Stop on SQL problems.
      */
     private int trigger_threshold(Element threshold) throws SQLException {
         int id = -1;
 
         L1Threshold needthis = new L1Threshold(-1);
         needthis.set_name(threshold.getAttribute("name"));
         needthis.set_bitnum(Integer.parseInt(threshold.getAttribute("bitnum")));
         needthis.set_type(threshold.getAttribute("type"));
 
         //CATCH when we've used the old style notation and change to the official threshold types
         if (needthis.get_type().equals("BG")) {
             needthis.set_type(L1Threshold.BG_TYPE);
         }
 
         if (needthis.get_type().equals("RND")) {
             needthis.set_type(L1Threshold.RND_TYPE);
         }
 
         int map = 0;
         try {
             map = Integer.parseInt(threshold.getAttribute("mapping"));
         } catch (NumberFormatException ex) {
             map = 0;
         }
 
         needthis.set_mapping(map);
 
         NodeList List_thresholds = threshold.getElementsByTagName("TriggerThresholdValue");
 
         logger.fine("Threshold " + needthis.get_name());
 
         for (int j = 0; j < List_thresholds.getLength(); ++j) {
             Element ttv_node = (Element) List_thresholds.item(j);
             L1ThresholdValue ttv = threshold_value(ttv_node);
             logger.fine("  Adding threshold value " + ttv.get_name() + " ? ");
             needthis.getThresholdValues().add(ttv);
         }
 
         id = needthis.save();
         threshold_ids.put(needthis.get_name(), id);
 
         logger.fine("Saved L1 Threshold name " + needthis.get_name() + " with id " + id);
 
         NodeList cables = threshold.getElementsByTagName("Cable");
 
         for (int j = 0; j < cables.getLength(); ++j) {
             Element cable_node = (Element) cables.item(j);
             cable(cable_node, id);
         }
 
         return id;
     }
 
     ///Read the trigger threshold list.
     /**
      * Go through the trigger threshold list in the XML and write to the 
      * database.
      */
     private void trigger_threshold_list() throws SQLException {
         sections = document.getElementsByTagName("TriggerThresholdList");
 
         if (sections.getLength() == 1) {
             Element thresholdlist = (Element) sections.item(0);
 
             NodeList thresholds = thresholdlist.getElementsByTagName("TriggerThreshold");
             for (int i = 0; i < thresholds.getLength(); ++i) {
                 Element threshold = (Element) thresholds.item(i);
                 logger.finer("  " + threshold.getNodeName() + "- bitnum=" + threshold.getAttribute("bitnum") + ", id=" + threshold.getAttribute("id") + ", name=" + threshold.getAttribute("name") + ", type=" + threshold.getAttribute("type") + ", version=" + threshold.getAttribute("version") + ", active=" + threshold.getAttribute("active") + ", mapping=" + threshold.getAttribute("mapping"));
 
                 threshold_id_list.addElement(trigger_threshold(threshold));
             }
             //now set forced thresholds to contain all thresholds
             //forcedthreshold_ids = threshold_ids; cant do this!
 
         } else {
             logger.warning("TOO MANY TRIGGERMENU NODES IN XML");
         }
     }
 
     ///Read the cable information for a single cable.
     private void cable(Element cable_node, int threshold_id) {
         String name = cable_node.getAttribute("name");
         String ctpin = cable_node.getAttribute("ctpin");
         String connector = cable_node.getAttribute("connector");
 
         String start = "";
         String end = "";
 
         NodeList signals = cable_node.getElementsByTagName("Signal");
         for (int k = 0; k < signals.getLength(); ++k) {
             Element signal = (Element) signals.item(k);
             logger.fine("      " + signal.getNodeName() + "- range_begin=" + signal.getAttribute("range_begin") + ", range_end=" + signal.getAttribute("range_end"));
             start = signal.getAttribute("range_begin");
             end = signal.getAttribute("range_end");
         }
 
         logger.fine("cable part 1 " + name + ", " + ctpin + ", " + connector);
         logger.fine("cable part 2 " + start + ", " + end);
 
         Hashtable<String, Object> check_me = new Hashtable<String, Object>();
         check_me.put("CABLE_NAME", name);
         check_me.put("CABLE_CTPIN", ctpin);
         check_me.put("CABLE_CONNECTOR", connector);
         check_me.put("CABLE_START", start);
         check_me.put("CABLE_END", end);
 
         L1TM_TT link = new L1TM_TT();
         link.set_threshold_id(threshold_id);
         link.set_cable_name(name);
         link.set_cable_ctpin(ctpin);
         link.set_cable_connector(connector);
         link.set_cable_start(Integer.parseInt(start));
         link.set_cable_end(Integer.parseInt(end));
 
         cables_to_save.addElement(link);
     }
 
     ///Read Bunch Group information.
     /** 
      * Check and insert a Bunch Group (and bunches) if required.
      * Called by BunchGroupSet
      * 
      * \verbatim
      * <BunchGroup internalNumber="1" name="col_Bunch" version="1">
      *  which contains <Bunch>
      * </BunchGroup>
      * \endverbatim
      * 
      * @param bg_node the XML node we want to parse
      * @return the id for the bunch group
      */
     private L1BunchGroup bunch_group(Element bg_node) throws SQLException {
         String bg_name = bg_node.getAttribute("name");
         int num = Integer.parseInt(bg_node.getAttribute("internalNumber"));
         //logger.info("bunch group: " + bg_name);
 
         NodeList List_bunches = bg_node.getElementsByTagName("Bunch");
 
         L1BunchGroup bg = new L1BunchGroup(-1);
         bg.set_name(bg_name);
         bg.set_internal_number(num);
 
         for (int i = 0; i < List_bunches.getLength(); ++i) {
             Element b_node = (Element) List_bunches.item(i);
             int bn = Integer.parseInt(b_node.getAttribute("bunchNumber"));
 
             L1Bunch b = new L1Bunch(-1);
             b.set_bunch_number(bn);
             bg.getBunches().addElement(b);
         }
 
         bg.save();
 
         return bg;
     }
 
     ///Read a bunch group set.
     /**
      * Check for the bunch group set and insert one if required.
      * 
      * \verbatim
      * <BunchGroupSet name="bg_set1" version="bg_set1">
      *   Contains <BunchGroup> which contains <Bunch>
      * </BunchGroupSet>
      * \endverbatim
      * 
      * @return id of the bunch group set
      */
     private int bunch_group_set() throws SQLException {
         sections = document.getElementsByTagName("BunchGroupSet");
 
         int bgs_id = -1;
 
         if (sections.getLength() == 1) {
             Element section = (Element) sections.item(0);
 
             NodeList List_groups = section.getElementsByTagName("BunchGroup");
 
             L1BunchGroupSet needthis = new L1BunchGroupSet(-1);
             needthis.set_name(section.getAttribute("name"));
 
             for (int i = 0; i < List_groups.getLength(); ++i) {
                 Element bg_node = (Element) List_groups.item(i);
                 needthis.getBunchGroups().add(bunch_group(bg_node));
             }
 
             bgs_id = needthis.save();
         }
         return bgs_id;
     }
 
     ///Read Deadtime from the XML.
     /**
      * Read a deadtime node from the XML.
      * 
      * \verbatim
      * <Deadtime complex1_level="111" complex1_rate="1" complex2_level="1" complex2_rate="1" name="sdt01" version="1" simple="1"/>
      * \endverbatim
      * 
      * @return ID of the deadtime record.
      */
     private int deadtime() throws SQLException {
         int id = -1;
         sections = document.getElementsByTagName("Deadtime");
 
         if (sections.getLength() == 1) {
             Element section = (Element) sections.item(0);
 
             L1Deadtime deadtime = new L1Deadtime(-1);
             deadtime.set_name(section.getAttribute("name"));
             deadtime.set_simple(Integer.parseInt(section.getAttribute("simple")));
             deadtime.set_complex1_level(Integer.parseInt(section.getAttribute("complex1_level")));
             deadtime.set_complex1_rate(Integer.parseInt(section.getAttribute("complex1_rate")));
             deadtime.set_complex2_level(Integer.parseInt(section.getAttribute("complex2_level")));
             deadtime.set_complex2_rate(Integer.parseInt(section.getAttribute("complex2_rate")));
 
             id = deadtime.save();
         } else {
             logger.warning("TOO MANY DEADTIME NODES IN XML");
         }
 
         return id;
     }
 
     ///Read the random node from the XML.
     /**
      * Read the random node from the XML.  The version is ignored by the upload 
      * script.
      * 
      * \verbatim
      * <Random name="rand01" version="1" rate1="20" seed1="1" rate2="1000" seed2="123" />
      * \endverbatim
      * 
      * @return id for the random record
      */
     private int random() throws SQLException {
         sections = document.getElementsByTagName("Random");
         int id = -1;
 
         if (sections.getLength() == 1) {
             Element section = (Element) sections.item(0);
 
             L1Random random = new L1Random(-1);
 
             random.set_name(section.getAttribute("name"));
             random.set_rate1(Integer.parseInt(section.getAttribute("rate1")));
             random.set_rate2(Integer.parseInt(section.getAttribute("rate2")));
             random.set_seed1(Integer.parseInt(section.getAttribute("seed1")));
             random.set_seed2(Integer.parseInt(section.getAttribute("seed2")));
 
             if (random.get_seed1() <= 0) {
                 random.set_autoseed1(1);
             } else {
                 random.set_autoseed1(0);
             }
 
             if (random.get_seed2() <= 0) {
                 random.set_autoseed2(1);
             } else {
                 random.set_autoseed2(0);
             }
 
             id = random.save();
         } else {
             logger.warning("Too many Random nodes in XML");
         }
 
         return id;
     }
 
     ///Read Muctpi Info.
     /**
      * Read the MuctpiInfo node.
      * 
      * \verbatim
      * <MuctpiInfo name="muctpi01" version="1">
      *    <low_pt>2</low_pt>
      *    <high_pt>6</high_pt>
      *    <max_cand>13</max_cand>
      * </MuctpiInfo>
      * \endverbatim
      *
      * @return id for the muctpi info table (uploaded or existing)
      */
     private int muctpi_info() throws SQLException {
         sections = document.getElementsByTagName("MuctpiInfo");
         int id = -1;
 
         if (sections.getLength() == 1) {
             Element section = (Element) sections.item(0);
 
             String low_pt = section.getElementsByTagName("low_pt").item(0).getTextContent().trim();
             String high_pt = section.getElementsByTagName("high_pt").item(0).getTextContent().trim();
             String max_cand = section.getElementsByTagName("max_cand").item(0).getTextContent().trim();
 
             L1MuctpiInfo newInfo = new L1MuctpiInfo(-1);
             newInfo.set_name(section.getAttribute("name"));
             newInfo.set_low_pt(Integer.valueOf(low_pt));
             newInfo.set_high_pt(Integer.valueOf(high_pt));
             newInfo.set_max_cand(Integer.valueOf(max_cand));
             id = newInfo.save();
         } else {
             logger.warning("TOO MANY MUCTPI NODES IN XML");
         }
 
         return id;
     }
 
     ///Read the prescaled clock node.
     /** 
      * Read the prescaled clock node from the XML.  
      * 
      * It is expected to look like this, and there is only one:
      * 
      * \verbatim
      * <PrescaledClock name="psc01" version="1" clock1="10" clock2="100"/>
      * \endverbatim
      * 
      * @return id for the prescaled clock table (uploaded or existing)
      */
     private int prescaled_clock() throws SQLException {
         sections = document.getElementsByTagName("PrescaledClock");
         int id = -1;
 
         if (sections.getLength() == 1) {
             Element section = (Element) sections.item(0);
 
             L1PrescaledClock pc = new L1PrescaledClock(-1);
             pc.set_name(section.getAttribute("name"));
             pc.set_clock1(Integer.valueOf(section.getAttribute("clock1")));
             pc.set_clock2(Integer.valueOf(section.getAttribute("clock2")));
             id = pc.save();
         } else {
             logger.warning("TOO MANY PRESCALED CLOCK NODES IN XML");
         }
 
         return id;
     }
 
     ///Read the Calo Info node.
     /**
      * Read a CaloInfo node
      * 
      * \verbatim
      * <CaloInfo name="standard" version="1" global_scale="4.0">
      *    <JetWeight num="1"> 10 </JetWeight>
      *    ...
      *    <JetWeight num="12"> 10 </JetWeight>
      * </CaloInfo>
      * \endverbatim
      */
     private int calo_info() throws SQLException {
         sections = document.getElementsByTagName("CaloInfo");
         int id = -1;
 
         if (sections.getLength() == 1) {
             Element section = (Element) sections.item(0);
 
             Integer[] weightArray = new Integer[12];
 
             for (int i = 0; i < 12; ++i) {
                 weightArray[i] = 0;
             }
 
             NodeList weights = section.getElementsByTagName("JetWeight");
             for (int i = 0; i < weights.getLength(); ++i) {
                 Element weight = (Element) weights.item(i);
                 weightArray[Integer.parseInt(weight.getAttribute("num").trim()) - 1] = Integer.parseInt(weight.getTextContent().trim());
             //logger.info("  " + weight.getNodeName() + "- " + weight.getAttribute("num") + " - " + weight.getTextContent());
             }
 
             L1CaloInfo newInfo = new L1CaloInfo(-1);
             newInfo.set_name(section.getAttribute("name"));
             newInfo.set_global_scale(section.getAttribute("global_scale"));
 
             for (int i = 0; i < 12; ++i) {
                 newInfo.set_jet_weight(i + 1, weightArray[i]);
             }
 
             id = newInfo.save();
         } else {
             logger.warning("TOO MANY CALOINFO NODES IN XML");
         }
 
         return id;
     }
 
     ///Read a prescale set.
     /**
      * Read a prescale_set from XML and write to the database.
      * 
      * @return ID of the Prescale Set
      */
     private int prescale_set(String name) throws SQLException {
         int id = -1;
         sections = document.getElementsByTagName("PrescaleSet");
 
         if (sections.getLength() == 1) {
             Element section = (Element) sections.item(0);
             //String name = section.getAttribute("name");
             String version = section.getAttribute("version");
 
             logger.fine(section.getNodeName() + "- name=" + name + ", version=" + version);
 
             //ctp id counts from 0 to 255 in xml...
             int[] prescaleArray = new int[256];
             for (int i = 0; i < 256; i++) {
                 prescaleArray[i] = -1;
             }
 
             //...but prescale vals are 1 to 256 in db
             //The xml always has 256 prescales, even if fewer items that this
             //For empty items, want value to be -1.
             //Have to read some of the menu here!
             Vector<Integer> ctpids_v = new Vector<Integer>();
             Element menu = (Element) document.getElementsByTagName("TriggerMenu").item(0);
             NodeList List_items = menu.getElementsByTagName("TriggerItem");
             for (int i = 0; i < List_items.getLength(); ++i) {
                 Element item_node = (Element) List_items.item(i);
                 ctpids_v.add(Integer.parseInt(item_node.getAttribute("ctpid")));
             }
             
             NodeList prescales = section.getElementsByTagName("Prescale");
             for (int i = 0; i < prescales.getLength(); i++) {
                 Element prescale = (Element) prescales.item(i);
                 //only those with items
                 if(ctpids_v.contains(Integer.parseInt(prescale.getAttribute("ctpid").trim()))){
                     prescaleArray[Integer.parseInt(prescale.getAttribute("ctpid").trim())] = Integer.parseInt(prescale.getTextContent().trim());
                 }else{
                     prescaleArray[Integer.parseInt(prescale.getAttribute("ctpid").trim())] = -1;
                 }
                 //logger.info("  " + prescale.getNodeName() + ": ctpid = " + prescale.getAttribute("ctpid") + ", value = " + prescaleArray[Integer.parseInt(prescale.getAttribute("ctpid").trim())]);
             }
 
             L1Prescale newInfo = new L1Prescale(-1);
             newInfo.set_name(name);
             
             for (int i = 0; i <= 255; i++) {
                 newInfo.set_val(i+1, prescaleArray[i]);
             }
 
             id = newInfo.save();
         } else {
             logger.warning("TOO MANY PRESCALESET NODES IN XML");
         }
 
         return id;
     }
 
     ///Read all the trigger items.
     /**
      * Write the trigger item table to the database.
      * 
      * @param item_node the node in the XML for the trigger item.
      * @return ID for the trigger item in the database.
      */
     private L1Item trigger_item(Element item_node) throws SQLException {
         L1Item ti = new L1Item(-1);
         ti.set_ctp_id(Integer.parseInt(item_node.getAttribute("ctpid")));
         ti.set_name(item_node.getAttribute("name"));
 
         //System.out.println("L1 Trigger Item: " + ti.get_name());
 
         //int ttype = 0;
         //try {
         //    ttype = Integer.parseInt(item_node.getAttribute("trigger_type"), 2);
         //} catch (NumberFormatException e) {
         //    ttype = 0;
         //}
         String ttype = "";
         ttype = item_node.getAttribute("trigger_type");
         ti.set_trigger_type(ttype);
 
         if (item_node.getAttribute("comment").equals("")) {
             ti.set_comment("~");
         } else {
             ti.set_comment(item_node.getAttribute("comment"));
         }
 
         int group = 0;
         try {
             group = Integer.parseInt(item_node.getAttribute("group"));
         } catch (NumberFormatException e) {
             group = 0;
         }
 
         ti.set_group(group);
         ti.set_priority(priority_array[ti.get_ctp_id()]);
 
         //work out the logic
         mThresholdCounter = 1;
         String def_string = read(item_node);
 
         if (def_string.equals("")) {
             def_string = "(1)";
         }
 
         ti.set_definition(def_string);
 
         NodeList List_conditions = item_node.getElementsByTagName("*");
         int position_counter = 1;
 
         for (int i = 0; i < List_conditions.getLength(); ++i) {
             Element condition_node = (Element) List_conditions.item(i);
 
             logger.fine((i + 1) + " TagName: " + condition_node.getTagName());
 
             if (condition_node.getTagName().equals("InternalTrigger")) {
                 String name = condition_node.getAttribute("name");
                 L1Threshold threshold = null;
                 /// See if we already loaded this threshold
                 String test = new String(name);
                 test += "_p";
                 test += position_counter;
                 if(internaltrigthresholdsLoaded.containsKey(test)) {
                     threshold = internaltrigthresholdsLoaded.get(test); //get from the map
                 }
                 else { /// need to load from xml
                     threshold = new L1Threshold(-1);
                     threshold.set_position(position_counter);
                     threshold.set_multiplicity(1);
                     threshold.set_name(name);
 
                     String type = "";
 
                     if (name.contains(L1Threshold.BG_TYPE)) {
                         type = L1Threshold.BG_TYPE;
                     } else if (name.contains(L1Threshold.RND_TYPE)) {
                         type = L1Threshold.RND_TYPE;
                     } else if (name.contains(L1Threshold.PSC_TYPE)) {
                         type = L1Threshold.PSC_TYPE;
                     }
 
                     threshold.set_type(type);
                     threshold.save();
                     // add threshold to the loaded list
                     internaltrigthresholdsLoaded.put(test, threshold);
                 }
                 
                 //System.out.println("  " + threshold.get_position() + " Internal  " + threshold.get_multiplicity() + "x " + threshold.get_name());
 
                 ti.getThresholds().add(threshold);
                 ++position_counter;
             } else if (condition_node.getTagName().equals("TriggerCondition")) {
                 String me = condition_node.getAttribute("triggerthreshold");
                 int multi = Integer.parseInt(condition_node.getAttribute("multi"));
 
                 L1Threshold threshold = new L1Threshold(threshold_ids.get(me));
                 logger.fine("Recovering threshold " + threshold_ids.get(me) + " name=" + threshold.get_name());
                 threshold.set_multiplicity(multi);
                 threshold.set_position(position_counter);
 
                 //System.out.println("  " + threshold.get_position() + " Condition " + threshold.get_multiplicity() + "x " + threshold.get_name());
 
                 //when we add the thresholds, add them to forced thresholds
                 //diff between ft and t sets are actually the fts!
                 ti.getThresholds().add(threshold);
                 forcedthreshold_ids.remove(threshold.get_name());
                 
                 ++position_counter;
             }
         }
 
         ti.save();
         return ti;
     }
 
     ///Master key needs a L1 muon prescale set to point at
     /**
      * Load empty L1 muon prescale set
      * 
      * @return ID of the l1 muon prescale set
      */
     private int muon_threshold_set() throws SQLException {
         int id = -1;
 
         L1MuonThresholdSet l1mts = new L1MuonThresholdSet(-1);
         l1mts.set_name("Unassigned");
         id = l1mts.save();
         
         return id;
     }
     
     ///Read the trigger menu from the XML file.
     /**
      * Load a trigger menu from XML.
      * 
      * @return ID of the trigger menu.
      */
     private int trigger_menu(String configname) throws SQLException {
         int id = -1;
 
         sections = document.getElementsByTagName("TriggerMenu");
 
         L1Menu needthis = new L1Menu(-1);
 
         if (sections.getLength() == 1) {
             
             //put all thresholds into forced thresholds
             forcedthreshold_ids.putAll(threshold_ids);
             
             Element menu = (Element) sections.item(0);
 
             //needthis.set_name(menu.getAttribute("name"));
             //set the name as supplied
             needthis.set_name(configname);
             needthis.set_phase(menu.getAttribute("phase"));
 
             L1CtpSmx l1CtpSmx = new L1CtpSmx(-1);
             l1CtpSmx.set_name("Empty");
             needthis.set_ctp_smx(l1CtpSmx);
             needthis.set_ctp_smx_id(l1CtpSmx.save());
 
             L1CtpFiles l1CtpFiles = new L1CtpFiles(-1);
             l1CtpFiles.set_name("Empty");
             needthis.set_ctp_files(l1CtpFiles);
             needthis.set_ctp_files_id(l1CtpFiles.save());
 
             NodeList List_items = menu.getElementsByTagName("TriggerItem");
             for (int i = 0; i < List_items.getLength(); ++i) {
                 Element item_node = (Element) List_items.item(i);
                 needthis.getItems().add(trigger_item(item_node));
             }
         
             //Now forced thresholds should contain all thresholds not in items
             //System.out.println("FORCED THRESHOLDS: " + forcedthreshold_ids.toString());
             //...if there are any forced thresholds we need to save them!
             if(forcedthreshold_ids.size()>0){
                 //System.out.println("Found " + forcedthreshold_ids.size() + " forced thresholds - will append to menu");
                 for (Enumeration e= forcedthreshold_ids.keys(); e.hasMoreElements();){
                     Integer ftid = forcedthreshold_ids.get(e.nextElement());
                     //System.out.println("Forced threshold id: " + ftid);
                     needthis.getForcedThresholds().add(new L1Threshold(ftid));
                 }
             }
         }
      
         for (L1TM_TT cable : cables_to_save) {
             logger.fine(cable.get_cable_name());
             cable.set_menu_id(id);
             needthis.getTMTT().add(cable);
         }
      
         
         //add prescales
         logger.fine("PJB adding to l1 menu the l1 ps with id " + newLVL1PrescaleKey);
         needthis.getPrescaleSets().add(new L1Prescale(newLVL1PrescaleKey));
         
         //add bgs
         //logger.info("PJB adding to l1 menu the l1 bgs with id " + newLVL1BGKey);
         //needthis.getBunchGroupSets().add(new L1BunchGroupSet(newLVL1BGKey));
         
         id = needthis.save();
 
         return id;
     }
 
     ///Write the master table to the database.
     /**
      * Now write the L1 Master Table
      * 
      * @param menu_id menu ID
      * @param ps_id Prescale Set ID
      * @param dt_id Deadtime ID
      * @param mu_id MU CTP ID
      * @param rand_id Random ID
      * @param pc_id Prescaled Clock ID
      * @param bgs_id Bunch Group Set ID
      * @param ci_id Calo Info ID
      */
     private int trigger_master(int menu_id, int dt_id, int mu_id, int rand_id, int pc_id, int ci_id, int mts_id, String configname) throws SQLException {
         sections = document.getElementsByTagName("LVL1Config");
 
         int l1m_id = -1;
         if (sections.getLength() == 1) {
             
             //Set the name as supplied
             //Element menu = (Element) sections.item(0);
             //String name = menu.getAttribute("name");
             String name = configname;
             
             L1Master master = new L1Master(-1);
             master.set_name(name);
             master.set_menu_id(menu_id);
             master.set_muon_threshold_set_id(mts_id);
             master.set_deadtime_id(dt_id);
             master.set_muctpi_info_id(mu_id);
             master.set_random_id(rand_id);
             master.set_prescaled_clock_id(pc_id);
             //master.set_bunch_group_set_id(bgs_id);
             master.set_calo_info_id(ci_id);
             logger.info("Calling save of L1 master...");
             l1m_id = master.save();
             logger.info("Save of L1 master finished");
         }
         return l1m_id;
     }
 
     ///Logic between thresholds from the old trigger tool.
     public String read(Element e) {
         String mLogicString = read(e, "");
         if (mLogicString.length() > 0 && !mLogicString.contains("(")) {
             mLogicString = "(" + mLogicString + ")";
         }
         return mLogicString;
     }
 
     ///Logic class taken from the old trigger tool.
     private String read(Element e, String insert_symbol) {
         String OPEN = "(";
         String CLOSE = ")";
 
         String logic_string = "";
         Node node = null;
         Element e_next = null;
         String tag = "";
         NodeList nodes = e.getChildNodes();
         int elem_counter = 0;
         //String s_multi;
 
         for (int i = 0; i < nodes.getLength(); ++i) {
             node = nodes.item(i);
             if (node.getNodeType() != Node.ELEMENT_NODE) {
                 continue;
             }
             e_next = (Element) node;
             tag = node.getNodeName();
 
             if (elem_counter > 0) {
                 logic_string += insert_symbol;
             }
             if (tag.equals("AND")) {
                 logic_string += OPEN;
                 logic_string += read(e_next, "&");
                 logic_string += CLOSE;
             } else if (tag.equals("OR")) {
                 logic_string += OPEN;
                 logic_string += read(e_next, "|");
                 logic_string += CLOSE;
             } else if (tag.equals("NOT")) {
                 logic_string += "!";
                 logic_string += read(e_next, "");
             } else if (tag.equals("TriggerCondition") || tag.equals("InternalTrigger")) {
                 logic_string += String.valueOf(mThresholdCounter++);
             //mThresholdNames.add(e_next.getAttribute(LVL1ConfigModel.ktriggerthreshold));
             //s_multi = e_next.getAttribute(LVL1ConfigModel.kmulti);
             //mMultiplicities.add(Integer.valueOf(s_multi));
             }
             elem_counter++;
         }
         return logic_string;
     }
 
     
     ///Perform a check on a file to see if the basic xml is valid.
     private void check_xml() {
         //check all the sections are ok
 
         //deadtime
         int count = document.getElementsByTagName("Deadtime").getLength();
         if (count != 1) {
             if (count < 1) {
                 faults.add("Deadtime XML node missing");
             } else {
                 faults.add("Too many Deadtime XML nodes.  Should have 1, found " + count);
             }
         } else {
             Element dt = (Element) document.getElementsByTagName("Deadtime").item(0);
 
             if (dt.getAttribute("complex1_level").length() == 0) {
                 faults.add("Deadtime node needs complex1_level=\"a_number\"");
             }
 
             if (dt.getAttribute("complex1_rate").length() == 0) {
                 faults.add("Deadtime node needs complex1_rate=\"a_number\"");
             }
 
             if (dt.getAttribute("complex2_level").length() == 0) {
                 faults.add("Deadtime node needs complex2_level=\"a_number\"");
             }
 
             if (dt.getAttribute("complex2_rate").length() == 0) {
                 faults.add("Deadtime node needs complex2_rate=\"a_number\"");
             }
 
             if (dt.getAttribute("simple").length() == 0) {
                 faults.add("Deadtime node needs simple=\"a_number\"");
             }
 
             if (dt.getAttribute("name").length() == 0) {
                 faults.add("Deadtime node needs name=\"a_string\"");
             }
         }
 
         //random
         count = document.getElementsByTagName("Random").getLength();
         if (count != 1) {
             if (count < 1) {
                 faults.add("Random XML node missing");
             } else {
                 faults.add("Too many Random XML nodes.  Should have 1, found " + count);
             }
         } else {
             Element dt = (Element) document.getElementsByTagName("Random").item(0);
 
             if (dt.getAttribute("name").length() == 0) {
                 faults.add("Random node needs name=\"a_string\"");
             }
 
             if (dt.getAttribute("rate1").length() == 0) {
                 faults.add("Random node needs rate1=\"a_number\"");
             }
 
             if (dt.getAttribute("rate2").length() == 0) {
                 faults.add("Random node needs rate2=\"a_number\"");
             }
 
             if (dt.getAttribute("seed1").length() == 0) {
                 faults.add("Random node needs seed1=\"a_number\"");
             }
 
             if (dt.getAttribute("seed2").length() == 0) {
                 faults.add("Random node needs seed2=\"a_number\"");
             }
         }
 
         //PrescaledClock
         count = document.getElementsByTagName("PrescaledClock").getLength();
         if (count != 1) {
             if (count < 1) {
                 faults.add("PrescaledClock XML node missing");
             } else {
                 faults.add("Too many PrescaledClock XML nodes.  Should have 1, found " + count);
             }
         } else {
             Element dt = (Element) document.getElementsByTagName("PrescaledClock").item(0);
 
             if (dt.getAttribute("name").length() == 0) {
                 faults.add("PrescaledClock node needs name=\"a_string\"");
             }
 
             if (dt.getAttribute("clock1").length() == 0) {
                 faults.add("PrescaledClock node needs clock1=\"a_number\"");
             }
 
             if (dt.getAttribute("clock2").length() == 0) {
                 faults.add("PrescaledClock node needs clock2=\"a_number\"");
             }
         }
 
         count = document.getElementsByTagName("MuctpiInfo").getLength();
         if (count != 1) {
             if (count < 1) {
                 faults.add("MuctpiInfo XML node missing");
             } else {
                 faults.add("Too many MuctpiInfo XML nodes.  Should have 1, found " + count);
             }
         } else {
             Element mi = (Element) document.getElementsByTagName("MuctpiInfo").item(0);
 
             if (mi.getAttribute("name").length() == 0) {
                 faults.add("MuctpiInfo node needs name=\"a_string\"");
             }
             if (mi.getElementsByTagName("low_pt").getLength() != 1) {
                 faults.add("Need 1 <low_pt>int</low_pt> in <PrescaledClock></PrescaledClock>");
             }
             if (mi.getElementsByTagName("high_pt").getLength() != 1) {
                 faults.add("Need 1 <high_pt>int</high_pt> in <PrescaledClock></PrescaledClock>");
             }
             if (mi.getElementsByTagName("max_cand").getLength() != 1) {
                 faults.add("Need 1 <max_cand>int</max_cand> in <PrescaledClock></PrescaledClock>");
             }
         }
 
         count = document.getElementsByTagName("CaloInfo").getLength();
         if (count != 1) {
             if (count < 1) {
                 faults.add("CaloInfo XML node missing");
             } else {
                 faults.add("Too many CaloInfo XML nodes.  Should have 1, found " + count);
             }
         } else {
             Element ci = (Element) document.getElementsByTagName("CaloInfo").item(0);
 
             if (ci.getAttribute("name").length() == 0) {
                 faults.add("CaloInfo node needs name=\"a_string\"");
             }
 
             if (ci.getAttribute("global_scale").length() == 0) {
                 faults.add("CaloInfo node needs global_scale=\"an_integer\"");
             }
 
         }
 
         sections = document.getElementsByTagName("LVL1Config");
         if (sections.getLength() == 1) {
             Element menu = (Element) sections.item(0);
 
             if (menu.getAttribute("name").length() == 0) {
                 faults.add("<LVL1Config> tag needs name=\"a_string\" adding");
             }
         }
     }
 }

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.