DBPlotManager.java

Go to the documentation of this file.

package cedar.jetweb.db;

import cedar.jetweb.JetWebConfig;
import cedar.jetweb.JetWebException;
import cedar.jetweb.model.RunSeries;
import cedar.jetweb.model.Model;
import cedar.jetweb.generator.Generator;
import cedar.jetweb.model.paper.*;
import cedar.jetweb.model.plots.*;
import cedar.jetweb.job.CutCollection;

import java.io.File;

import java.sql.*;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Vector;
import java.util.HashMap;
import java.util.TreeMap;
import java.util.Collection;


public abstract class DBPlotManager {

    public static final String REAL = "data_point";

    public static final String PREDICTED = "predicted_point";

    public static final String FITTED = "fitted_point";

    private static PreparedStatement insertRealData_;
    private static PreparedStatement insertPredictedData_; 
    private static PreparedStatement insertFittedData_; 
    private static PreparedStatement retrieveRealPaper_;
    private static PreparedStatement selectPlotsForPaper_;
    private static boolean initialisedData_ = false;
    private static boolean initialisedRetrievePaper_ = false;


    private static void initData(){

    if(initialisedData_)return;
    initialisedData_ = true;

    try{
    insertRealData_ = 
        DBConfig.getConnection().prepareStatement
        ("INSERT INTO data_point"+
         "(csn_id,pnt_no,x,y,dy_up,dy_down,bin_width) VALUES" + 
         "(?,?,?,?,?,?,?)");

    insertPredictedData_ = 
        DBConfig.getConnection().prepareStatement
        ("INSERT INTO predicted_point" +
         "(runseries_id,csn_id,pnt_no,x,y,dy_up,dy_down,bin_width) "+
         "VALUES" + 
         "(?,?,?,?,?,?,?,?)");
     
    insertFittedData_ = 
        DBConfig.getConnection().prepareStatement
        ("INSERT INTO fitted_point" + 
         "(fit_id,chi2,csn_id,pnt_no,x,y,dy_up,dy_down,bin_width) VALUES" +
         "(?,?,?,?,?,?,?,?,?)");
    }catch(SQLException err){
        System.out.println
        ("Error: cannot initialse prepared statements "+
         "for inserting data in DB");
        System.out.println(err.getMessage());
        err.printStackTrace();
    }
     return;
    }
    private static void initRetrievePaper(){
    if(initialisedRetrievePaper_) return;
    initialisedRetrievePaper_ = true;
    try{
        retrieveRealPaper_ = 
        DBConfig.getConnection().prepareStatement
        ("SELECT * FROM paper WHERE paper_id=?");

        selectPlotsForPaper_ = 
        DBConfig.getConnection().prepareStatement
        ("SELECT * FROM cross_section where paper_id=?");

    }catch(SQLException err){
        System.out.println
        ("Error: cannot initialise prepared statements " +
         "for retrieving real papers from DB");
        System.out.println(err.getMessage());
        err.printStackTrace();
    }
    }

    private static void checkInserts(){
    
    boolean start = initialisedData_;
    initData();
    if(start!=initialisedData_) return;

    //Just a test because sometimes we drop the preparedstatement
    //if we lose the connection to the DB
    try{
        try{
        insertRealData_.setInt(1, 1);
        }catch(NullPointerException err){
        //presume DB connection is lost if we get here :(
        System.out.println
            ("Lost DB connection!  Getting new PreparedStatements");
        insertRealData_.close();
        insertPredictedData_.close();
        insertFittedData_.close();
        initialisedData_ = false;
        initData();
        }
    }catch(SQLException sqlErr){
        System.out.println
        ("DBPlotManager: unable to check status of DB connection");
        System.out.println(sqlErr.getMessage());
        sqlErr.printStackTrace();
    }
    return;
    }

    public static synchronized Collection<RealPaper> getRealPapers()
    throws JetWebException{
    Vector<RealPaper> papers = new Vector<RealPaper>();
    String selectString = "SELECT * FROM paper";
    try{

        Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet dbrs = stmt.executeQuery(selectString);

            while (dbrs.next()) {
                RealPaper paper = new RealPaper();
                fill(paper, dbrs);
                papers.add(paper);
            }

            dbrs.close();
            stmt.close();

    } catch (SQLException E) {
            System.out.println("SQLException: " + E.getMessage());
            System.out.println("SQLState:     " + E.getSQLState());
            System.out.println("VendorError:  " + E.getErrorCode());
            throw new JetWebDBException(E, selectString, "");
        }

    return papers;
    }

    public static synchronized Collection<Paper> getPapers()
        throws JetWebException {
        Vector<Paper> papers = new Vector<Paper>();
        String selectString = "SELECT * from paper";

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet dbrs = stmt.executeQuery(selectString);

            while (dbrs.next()) {
                Paper paper = new Paper(true);
                fill(paper, dbrs);
                papers.add(paper);
            }

            dbrs.close();
            stmt.close();
        } catch (SQLException E) {
            System.out.println("SQLException: " + E.getMessage());
            System.out.println("SQLState:     " + E.getSQLState());
            System.out.println("VendorError:  " + E.getErrorCode());
            throw new JetWebDBException(E, selectString, "");
        }

        return papers;
    }

    public static synchronized void fillRealPaper(RealPaper paper)
    throws JetWebException{
    
    initRetrievePaper();
    boolean filled = false;

    try{
        retrieveRealPaper_.setInt(1, paper.getId());
        ResultSet dbrs = retrieveRealPaper_.executeQuery();
        while(dbrs.next()){
        fill(paper, dbrs);
        filled = true;
        }
        dbrs.close();
        retrieveRealPaper_.clearParameters();
    }catch(SQLException err){
        System.out.println("SQLException: " + err.getMessage());
            System.out.println("SQLState:     " + err.getSQLState());
            System.out.println("VendorError:  " + err.getErrorCode());
            throw new JetWebDBException(err, ((Integer)paper.getId()).toString(), "");
    }

    if(!filled){
        throw new JetWebException("Paper not filled."," ");
    }
    return;
    }

    public static synchronized void fillPaper(Paper paper)
        throws JetWebException {
        String selectString = "SELECT * from paper where paper_id=" + paper.getId();
        boolean filled = false;

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet dbrs = stmt.executeQuery(selectString);

            while (dbrs.next()) {
                fill(paper, dbrs);
                filled = true;
            }

            dbrs.close();
            stmt.close();
        } catch (SQLException E) {
            System.out.println("SQLException: " + E.getMessage());
            System.out.println("SQLState:     " + E.getSQLState());
            System.out.println("VendorError:  " + E.getErrorCode());
            throw new JetWebDBException(E, selectString, "");
        }

        if (!filled) {
            throw new JetWebException("Paper not filled.", " ");
        }
    }

    public static synchronized int getPaperId(String dirName)
        throws JetWebException {
        int paperId = -1;
        String query = "SELECT paper_id FROM paper WHERE directory='" + dirName + "'";

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(query);

            if (rs.next()) {
                paperId = rs.getInt("paper_id");
            }

            rs.close();
            stmt.close();
        } catch (SQLException e) {
            System.out.println("Failed to select paperId for dirname:" + dirName + "error:" + e);
            throw new JetWebDBException(e, query, "Directory:" + dirName);
        }

        return paperId;
    }

    private static void fill(RealPaper paper, ResultSet dbrs)
    throws SQLException, JetWebException{
    paper.setAccelerator(dbrs.getString("accelerator"));
    paper.setDirName(dbrs.getString("directory"));
    paper.setReference(dbrs.getString("reference"));
    paper.setTitle(dbrs.getString("title"));
    paper.setId(dbrs.getInt("paper_id"));
    paper.setCollaboration(dbrs.getString("collaboration"));
    paper.setCodeAuthor(dbrs.getString("code_author"));
    paper.setCodeContact(dbrs.getString("code_contact"));
    paper.setIRN(dbrs.getInt("spires_id"));
    fillPlots(paper);
    return;
    }

    private static void fill(Paper paper, ResultSet dbrs)
        throws SQLException, JetWebException {
        if (paper.isReal()) {
            paper.setAccelerator(dbrs.getString("accelerator"));
            paper.setDirName(dbrs.getString("directory"));
            paper.setReference(dbrs.getString("reference"));
            paper.setTitle(dbrs.getString("title"));
            paper.setID(dbrs.getInt("paper_id"));
            paper.setCollaboration(dbrs.getString("collaboration"));
            paper.setCodeAuthor(dbrs.getString("code_author"));
            paper.setContact(dbrs.getString("code_contact"));
            paper.setIRN(dbrs.getInt("spires_id"));

            // Now the plots.
            fillPlots(paper);
        } else {
            throw new JetWebDBException("Attempt to fill MC Paper from DB is not valid",
                "PaperId:" + paper.getId());
        }
    }

    public static synchronized void fillPlots(RealPaper paper)
    throws JetWebException{
    initRetrievePaper();
    try{
        selectPlotsForPaper_.setInt(1, paper.getId());
        ResultSet csrs = selectPlotsForPaper_.executeQuery();
        while(csrs.next()){
        RealPlot plot = new RealPlot();
        fill(plot, csrs);
        paper.addPlot(plot);
        }
        selectPlotsForPaper_.clearParameters();
    }catch(SQLException E){
        System.out.println("SQLException: " + E.getMessage());
            System.out.println("SQLState:     " + E.getSQLState());
            System.out.println("VendorError:  " + E.getErrorCode());
            throw new JetWebDBException(E, "SELECT", 
                    "PaperId:" + paper.getId());
    }
    }

    public static synchronized void fillPlots(Paper paper)
        throws JetWebException {
        // Run a query looking for all plots in the cross_section table which
        // match this paper_id.
        String query = "SELECT * from cross_section where paper_id=" +
            Integer.toString(paper.getId());

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet csrs = stmt.executeQuery(query);

            while (csrs.next()) {
                RealPlot plot = new RealPlot();

                //System.out.println("plot got");
                fill(plot, csrs);
                paper.addPlot(plot);
            }

            csrs.close();
            stmt.close();
        } catch (SQLException E) {
            System.out.println("SQLException: " + E.getMessage());
            System.out.println("SQLState:     " + E.getSQLState());
            System.out.println("VendorError:  " + E.getErrorCode());
            throw new JetWebDBException(E, query, "PaperId:" + paper.getId());
        }
    }

    public static synchronized void fromDB(String ConName, RealPlot plot)
        throws JetWebException {
        // Run a query looking for all plots in the cross_section table which
        // match this paper_id.
        String query = "SELECT * from cross_section where csn_id=" +
            Integer.toString(plot.getId());

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet csrs = stmt.executeQuery(query);

            while (csrs.next()) {
                //System.out.println("plot got");
                fill(plot, csrs);
            }

            csrs.close();
            stmt.close();
        } catch (SQLException E) {
            System.out.println("SQLException: " + E.getMessage());
            System.out.println("SQLState:     " + E.getSQLState());
            System.out.println("VendorError:  " + E.getErrorCode());
            throw new JetWebDBException(E, query, "PlotId:" + plot.getId());
        }
    }

    public static synchronized void fromDB(RealPlot plot)
        throws JetWebException {
        // Run a query looking for all plots in the cross_section table which
        // match this paper_id.
        String query = "SELECT * from cross_section where csn_id=" +
            Integer.toString(plot.getId());

        try {
        Statement stmt = DBConfig.getConnection().createStatement();
        //Statement stmt = DBConfig.getDBConnectionManager().
        //getConnection("hepdata").createStatement();
            ResultSet csrs = stmt.executeQuery(query);

            while (csrs.next()) {
                //System.out.println("plot got");
                fill(plot, csrs);
            }

            csrs.close();
            stmt.close();
        } catch (SQLException E) {
            System.out.println("SQLException: " + E.getMessage());
            System.out.println("SQLState:     " + E.getSQLState());
            System.out.println("VendorError:  " + E.getErrorCode());
            throw new JetWebDBException(E, query, "PlotId:" + plot.getId());
        }
    }

    public static synchronized boolean addRealPaper(RealPaper paper)
    throws JetWebException{
    boolean paperExisted = false;

    String query = "";

    if(paper.getId()>0){
        paperExisted = true;
        query = "SELECT * FROM paper WHERE paper_id="+paper.getId();
    
        try{
        Statement stmt = DBConfig.getConnection().createStatement();
        ResultSet pprrs = stmt.executeQuery(query);
        while(pprrs.next()){
            Statement stmt2 = 
            DBConfig.getConnection().createStatement();
            String mod = "UPDATE paper set title='" + 
            paper.getTitle() + "', " + 
            "reference='" + paper.getReference()+"', " + 
            "directory='" + paper.getDirName()+"', " + 
            "collaboration='" + paper.getCollaboration() + "', " +
            "code_author='" + paper.getCodeAuthor() + "', " +
            "code_contact='" + paper.getCodeContact() + "', " + 
            "accelerator='" + paper.getAccelerator() + "'," + 
            "spires_id='" + paper.getIRN() + "', " + 
            "WHERE paper_id=" + paper.getId();
            Integer rowsChanged = stmt2.executeUpdate(mod);
            stmt2.close();
            
        }
        pprrs.close();
        stmt.close();

        }catch(SQLException err){
        System.out.println("SQLException: " + err.getMessage());
                System.out.println("SQLState:     " + err.getSQLState());
                System.out.println("VendorError:  " + err.getErrorCode());
                throw new JetWebDBException(err, query, 
                        "PaperId:" + paper.getId());
        }
    }else{
        String ins =
                "Insert into paper " + 
        "(title, reference, directory, collaboration, " + 
        "accelerator, code_contact, code_author, spires_id)" +
                "values('" + paper.getTitle() + "','" + 
        paper.getReference() + "','" +
                paper.getDirName() + "','" + 
        paper.getCollaboration() + "','" +
                paper.getAccelerator() + "','" + 
        paper.getCodeContact() + "','" +
                paper.getCodeAuthor() + "," + 
        paper.getIRN()+"')";

            try {
                Statement stmt = DBConfig.getConnection().createStatement();
                int rowsChanged = stmt.executeUpdate(ins);
                stmt.close();
            } catch (SQLException E) {
                System.out.println("SQLException: " + E.getMessage());
                System.out.println("SQLState:     " + E.getSQLState());
                System.out.println("VendorError:  " + E.getErrorCode());
                throw new JetWebDBException(E, ins, "PaperId:" + paper.getId());
            }
        }
    
    return paperExisted;
    }


    public static synchronized boolean addPaper(Paper paper)
        throws JetWebException {
        boolean paperExisted = false;

        if (paper.getId() > 0) {
            paperExisted = true;

            String query = "SELECT * from paper where paper_id=" + paper.getId();

            try {
                Statement stmt = DBConfig.getConnection().createStatement();
                ResultSet pprrs = stmt.executeQuery(query);

                while (pprrs.next()) {
                    Statement stmt2 = DBConfig.getConnection().createStatement();
                    String mod = "UPDATE paper SET title='" + paper.getTitle() + "',reference='" +
                        paper.getReference() + "', directory='" + paper.getDirName() +
                        "', collaboration='" + paper.getCollaboration() + "', code_author='" +
                        paper.getCodeAuthor() + "', code_contact='" + paper.getContact() +
                        "', accelerator='" + paper.getAccelerator() + 
                        "', spires_id='" + paper.getIRN() + "' where paper_id=" +
                        paper.getId();
                    int rowsChanged = stmt2.executeUpdate(mod);
                    stmt2.close();
                }

                pprrs.close();
                stmt.close();
            } catch (SQLException E) {
                System.out.println("SQLException: " + E.getMessage());
                System.out.println("SQLState:     " + E.getSQLState());
                System.out.println("VendorError:  " + E.getErrorCode());
                throw new JetWebDBException(E, query, "PaperId:" + paper.getId());
            }
        } else {
            String ins =
                "Insert into paper (title, reference, directory, collaboration, accelerator, code_contact, code_author, spires_id)" +
                "values('" + paper.getTitle() + "','" + paper.getReference() + "','" +
                paper.getDirName() + "','" + paper.getCollaboration() + "','" +
                paper.getAccelerator() + "','" + paper.getContact() + "','" +
                paper.getCodeAuthor() + ","+paper.getIRN()+"')";

            try {
                Statement stmt = DBConfig.getConnection().createStatement();
                int rowsChanged = stmt.executeUpdate(ins);
                stmt.close();
            } catch (SQLException E) {
                System.out.println("SQLException: " + E.getMessage());
                System.out.println("SQLState:     " + E.getSQLState());
                System.out.println("VendorError:  " + E.getErrorCode());
                throw new JetWebDBException(E, ins, "PaperId:" + paper.getId());
            }
        }

        return paperExisted;
    }

    private static void fill(RealPlot plot, ResultSet csrs)
        throws SQLException, JetWebException {
        plot.setPaperId(csrs.getInt("paper_id"));
        plot.setNumber(csrs.getInt("plot_number"));
        plot.setTitle(csrs.getString("title"));
        plot.setXLabel(csrs.getString("x_axis_title"));
        plot.setYLabel(csrs.getString("y_axis_title"));
        plot.setId(csrs.getInt("csn_id"));
        plot.setShape(csrs.getInt("is_shape") == 1);
    
    Integer cutId = csrs.getInt("cut_collection_id");
    if(cutId!=null){
        CutCollection cuts = new CutCollection(cutId);
        plot.setCutCollection(cuts);
    }

        if (csrs.getInt("in_default") >= 1) {
            plot.setDefaultSum(true);
        }

        if (csrs.getInt("in_default") == 2) {
            plot.setDefaultFit(true);
        }

        if (csrs.getString("y_axis_type").equals("log")) {
            plot.setLogarithmic(true);
        } else {
            plot.setLogarithmic(false);
        }

        plot.setSysScale(csrs.getFloat("scale_factor"));

        plot.setCollisionId(csrs.getInt("collision_id"));

        if (!plot.populateDBData()) {
            System.out.println("WARNING: datapoints not filled for DataPlot " + plot.getNumber());
        }
    }

    public static synchronized Vector<DataPoint> getDataPoints(DataPlot plot)
        throws JetWebException {
        //select records from appropriate table for this cross_section
        String queryString = getQueryString(plot);
    System.out.println(queryString);
        Vector<DataPoint> dataPoints = new Vector<DataPoint>();
    HashMap<Integer, DataPoint> pointMap = 
        new HashMap<Integer, DataPoint>();

    HashMap<Integer, Boolean> isInCuts = null;

    if(plot instanceof PredictedPlot){
        isInCuts = new HashMap<Integer, Boolean>();
    }
     

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet dsrs = stmt.executeQuery(queryString);

            while (dsrs.next()) {

        //check that the runseries for this data_point 
        //generates data in the correct region.

        boolean inCuts = true;

        if(plot instanceof PredictedPlot){

            Integer rsid = dsrs.getInt("runseries_id");

            Boolean foundInCuts = isInCuts.get(rsid);

            if(foundInCuts==null){

            String selectCuts = 
                "SELECT cut_collection_id FROM runseries WHERE " + 
                "runseries_id = " + dsrs.getInt("runseries_id");

            System.out.println(selectCuts);
            
            Statement cutstmt = 
                DBConfig.getConnection().createStatement();
            ResultSet rs = cutstmt.executeQuery(selectCuts);
            
            while(rs.next()){
                CutCollection runCuts = 
                new CutCollection(rs.getInt(1));
                inCuts = plot.getCutCollection().isWithin(runCuts);
            }

            isInCuts.put(rsid, inCuts);

            }else{
            inCuts = foundInCuts;
            }
        }

        if(inCuts){
            //add a new DataPoint 
            DataPoint point = new DataPoint();
            point.setX(dsrs.getFloat("x"));
            point.setY(dsrs.getFloat("y"));
            point.setYUp(dsrs.getFloat("dy_up"));
            point.setYDown(dsrs.getFloat("dy_down"));
            point.setBinWidth(dsrs.getFloat("bin_width"));
            point.setNumber(dsrs.getInt("pnt_no"));
            //0,x 1,y, 2,ye 3,ye 4, bin width 5, chi2
            if (plot instanceof FittedPlot){
            point.setChi2(dsrs.getFloat("chi2"));
            }
        
            //System.out.println("Read datapoint for plot " + 
            //         plot.getId() + 
            //         point.toString());


            //Integer pointNumber = dsrs.getInt("pnt_no");
            Integer pointNumber = point.getNumber();

            DataPoint existingPoint = 
            pointMap.get(pointNumber);
    
            if(existingPoint != null ){

            System.out.println("Found existing point: " +
                       existingPoint.toString());

            point.add(existingPoint);
            }

            pointMap.put(pointNumber, point);

            //dataPoints.add(point);
        }

            }

        dataPoints = new Vector<DataPoint>(pointMap.values());

        

            dsrs.close();
            stmt.close();
        } catch (SQLException e) {
            System.out.println("Error reading data points " + e);
            throw new JetWebDBException(e, queryString, "DataPlot.id:" + plot.getId());
        }

    Collections.sort(dataPoints);

        return dataPoints;
    }

    public static synchronized HashMap<Integer, Paper> 
    getPredictedPapers(Model model) throws JetWebException{
    
    HashMap<Integer, Paper> foundPapers = 
        new HashMap<Integer, Paper>();

    try{
        PreparedStatement pstmt = 
        DBConfig.getConnection().prepareStatement
        ("select cross_section.paper_id, " + 
         "cross_section.cut_collection_id, " + 
         "predicted_point.runseries_id, " + 
         "runseries.cut_collection_id, " + 
         "cross_section.csn_id from " + 
         "cross_section, predicted_point, model, " + 
         "runseries_collection, runseries where " + 
         "runseries.runseries_id = " + 
         "runseries_collection.runseries_id and " + 
         "runseries_collection.runseries_collection_id =" + 
         "model.runseries_collection_id and " + 
         "runseries_collection.runseries_id =" + 
         "predicted_point.runseries_id and " + 
         "predicted_point.csn_id =cross_section.csn_id and " + 
         "model.mdl_id =?");

        pstmt.setInt(1, model.getId());
        ResultSet rs = pstmt.executeQuery();
            
        HashMap<Integer, PredictedPlot> foundPlots = 
        new HashMap<Integer, PredictedPlot>();
        
        HashMap<Integer, CutCollection> paperCuts = 
        new HashMap<Integer, CutCollection>();
        
        HashMap<Integer, CutCollection> rsCuts = 
        new HashMap<Integer, CutCollection>();
        
        HashMap<Integer, RunSeries> foundRunSeries = 
        new HashMap<Integer, RunSeries>();

        PreparedStatement paperStmt = 
        DBConfig.getConnection().prepareStatement
        ("SELECT * FROM paper where paper_id=?");
        
        PreparedStatement plotStmt = 
        DBConfig.getConnection().prepareStatement
        ("SELECT * FROM cross_section WHERE csn_id=?");

        while(rs.next()){
        Integer paperId = rs.getInt(1);
        Paper mcpaper;
        Integer paperCutsId = rs.getInt(2);
        Integer rsId = rs.getInt(3);
        Integer rsCutsId = rs.getInt(4);
        Integer plotId = rs.getInt(5);
        
        CutCollection paperCut = paperCuts.get(paperCutsId);
        CutCollection rsCut = rsCuts.get(rsCutsId);
        
        if(paperCut==null){
            paperCut = new CutCollection(paperCutsId);
            paperCuts.put(paperCutsId, paperCut);
        }
        
        if(rsCut==null){
            rsCut = new CutCollection(rsCutsId);
            rsCuts.put(rsCutsId, rsCut);
        }
        
        boolean inCuts = paperCut.isWithin(rsCut);
        if(inCuts){
            if(!foundPapers.containsKey(paperId)){
            
            mcpaper = new Paper(false);
            
            paperStmt.setInt(1, paperId);
            ResultSet paperRs = paperStmt.executeQuery();
            
            if(paperRs.next()){
                mcpaper.setAccelerator(paperRs.getString("accelerator"));
                mcpaper.setDirName(paperRs.getString("directory"));
                mcpaper.setReference(paperRs.getString("reference"));
                mcpaper.setTitle(paperRs.getString("title"));
                mcpaper.setID(paperId);
                mcpaper.setCollaboration
                (paperRs.getString("collaboration"));
                mcpaper.setCodeAuthor(paperRs.getString("code_author"));
                mcpaper.setContact(paperRs.getString("code_contact"));
                mcpaper.setIRN(paperRs.getInt("spires_id"));
                foundPapers.put(paperId, mcpaper);
            }
            
            }else{
            mcpaper = foundPapers.get(paperId);
            }
            
            PredictedPlot plot = foundPlots.get(plotId);

            if(plot==null){
            RealPlot compPlot = new RealPlot();
            
            plotStmt.setInt(1, plotId);
            
            ResultSet plotRs = plotStmt.executeQuery();
            if(plotRs.next()){
                fill(compPlot, plotRs);

                RunSeries runseries = foundRunSeries.get(rsId);
                if(runseries==null){
                runseries = RunSeries.Maker(rsId);
                }

                plot = new PredictedPlot(compPlot, runseries);
                foundPlots.put(plotId, plot);
            }
            mcpaper.addPlot(plot);
            }
        }
        }
    }catch(SQLException err){
        throw new JetWebException(err);
    }
    return foundPapers; 
    }


    private static String getQueryString(DataPlot plot) {
        String rtn = "";
    
        if (plot instanceof PredictedPlot) {
        /*
            rtn = "SELECT * FROM " + PREDICTED + " where csn_id=" + plot.getId() +
                " and runseries_id=" + ((PredictedPlot) plot).getRunSeriesId();
    */
        rtn = "SELECT " + PREDICTED + ".* FROM " + 
        PREDICTED + ", runseries_collection " +
        "WHERE " + PREDICTED + ".csn_id = " + plot.getId() + 
        " AND " + PREDICTED + 
        ".runseries_id=runseries_collection.runseries_id AND " + 
        "runseries_collection.runseries_collection_id =  " + 
        "(SELECT runseries_collection_id FROM runseries_collection " + 
        "WHERE runseries_id = " + 
        ((PredictedPlot) plot).getRunSeriesId() + ")";


        } else if (plot instanceof RealPlot) {
            rtn = "SELECT * FROM " + REAL + " where csn_id=" + plot.getId();
        } else if (plot instanceof FittedPlot) {
            rtn = "SELECT * FROM " + FITTED + " where csn_id=" + plot.getId() + " and fit_id=" +
                ((FittedPlot) plot).getFit().getId();
        }
    //System.out.println(rtn);
        return rtn;
    }

    public static synchronized void updateCrossSectionPoints(DataPlot plot)
        throws JetWebException {
        String sqlString = getDeleteString(plot);

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            int rtn = stmt.executeUpdate(sqlString);
            stmt.close();
        } catch (SQLException e) {
            System.out.println("DB access error in updateCross_Section (delete data points):" + e);
            System.out.println("SQL was:" + sqlString);
            throw new JetWebDBException(e, sqlString, "DataPlot.id:" + plot.getId());
        }

        try {
            insertData(plot);
        } catch (JetWebException j) {
            // insertDataPlot throws an exception if it failed. If we
            // did not manage to insert the data, we should tidy up by
            // deleting any other data for this plot.
            try {
                sqlString = getDeleteString(plot);

                Statement stmt = DBConfig.getConnection().createStatement();
                int rtn = stmt.executeUpdate(sqlString);
                stmt.close();
            } catch (SQLException e) {
                System.out.println("DB access error in updateCrossSection (delete data points):" +
                    e);
                System.out.println("SQL was:" + sqlString);
                throw new JetWebDBException(e, sqlString, "DataPlot.id:" + plot.getId());
            }
        }
    }

    private static String getDeleteString(DataPlot plot) {
        String rtn = "";

        if (plot instanceof PredictedPlot) {
            rtn = "DELETE FROM " + PREDICTED + " WHERE csn_id=" + plot.getId() +
                " and runseries_id=" + ((PredictedPlot) plot).getRunSeriesId();
        } else if (plot instanceof FittedPlot) {
            rtn = "DELETE FROM " + FITTED + " WHERE csn_id=" + plot.getId() + " and fitted_id=" +
                ((FittedPlot) plot).getFit().getId();
        } else if (plot instanceof RealPlot) {
            rtn = "DELETE FROM " + REAL + " WHERE csn_id=" + plot.getId();
        }

        return rtn;
    }

    public static synchronized void insertData(DataPlot plot)
        throws JetWebException {

    //System.out.println("Inserting data for plot " + plot.getId());

    //initData();

    checkInserts();

        Enumeration<DataPoint> unsortedPoints = plot.getDataPoints().elements();
        int pointNo = 0;

    TreeMap<Double, DataPoint> sortedPoints = 
        new TreeMap<Double, DataPoint>();

    while(unsortedPoints.hasMoreElements()){
        DataPoint pt = unsortedPoints.nextElement();
        sortedPoints.put(pt.getX(), pt);
    }

    PreparedStatement pstmt = insertRealData_;

    boolean isFitted = false;

    Integer startIndex = 1;
    try{
        if(plot instanceof PredictedPlot){
        pstmt = insertPredictedData_;
        pstmt.setInt(1, ((PredictedPlot) plot).getRunSeriesId());
        startIndex = 2;
        }else if(plot instanceof FittedPlot){
        pstmt = insertFittedData_;
        pstmt.setInt(1, ((FittedPlot) plot).getFit().getId());
        startIndex = 3;
        }
        pstmt.setInt(startIndex, plot.getId());
    }catch(SQLException err){
        System.out.println("Error: DBPlotManager.insertData(DataPlot) "+
                   "unable to set plot data in PreparedStatement");
        err.printStackTrace();
        throw new JetWebException(err);
    }
    ++startIndex;
    
        //while (points.hasMoreElements()) {

    //System.out.println("Number of data points to add = " + 
    //   sortedPoints.size());

    for(DataPoint point: sortedPoints.values()){
            pointNo++;

            //DataPoint point = points.nextElement();
        
        Integer pIndex = startIndex;
        try{

        if(plot instanceof FittedPlot){
            pstmt.setDouble(2, point.getChi2());
        }

        pstmt.setInt(pIndex, pointNo);
        ++pIndex;
        pstmt.setDouble(pIndex, point.getX());
        ++pIndex;
        pstmt.setDouble(pIndex, point.getY());
        ++pIndex;
        pstmt.setDouble(pIndex, point.getYUp());
        ++pIndex;
        pstmt.setDouble(pIndex, point.getYDown());
        ++pIndex;
        pstmt.setDouble(pIndex, point.getBinWidth());
        pstmt.executeUpdate();
                
        }catch(SQLException err){
        System.out.println("insertDataPlot failed: " + err);
        System.out.println("Data: pIndex = "+pIndex);
        throw new JetWebException(err);
        }
        }
    try{
        pstmt.clearParameters();
        //pstmt.close();
    }catch(SQLException err){
        System.out.println
        ("DBPlotManager.insertData: " + 
         "unable to clear prepared statement");
        System.out.println("Data: "+pstmt);
      
        throw new JetWebException(err);
    }
    return;
    }

    public static synchronized void insertCrossSection(String ConName, 
                               RealPlot plot, int paperId)
        throws JetWebException {
        int inDefault = 0;

        if (plot.isDefaultSum()) {
            inDefault += 1;
        }

        if (plot.isDefaultFit()) {
            inDefault += 1;
        }

        String yAxisType = "lin";

        if (plot.isLogarithmic()) {
            yAxisType = "log";
        }

        int shape = 0;

        if (plot.isShape()) {
            shape = 1;
        }

    Integer cutId=-1;

    if(plot.getCutCollection()!=null){
        plot.getCutCollection().store();
        cutId = plot.getCutCollection().getId();
    }

        String sqlString = 
        "INSERT INTO cross_section " +
            "(paper_id," +
        "title,x_axis_title," + 
        "y_axis_title," + 
        "in_default," + 
        "plot_number," + 
        "scale_factor," + 
        "y_axis_type," + 
        "is_shape," + 
        "collision_id," +
        "cut_collection_id)" +
            " VALUES (" + paperId + ",'" + plot.getTitle() + "','" + plot.getXLabel() + "','" +
            plot.getYLabel() + "'," + inDefault + "," + plot.getNumber() + "," +
            plot.getSysScale() + ",'" + yAxisType + "'," + shape + "," + 
        plot.getCollisionId() +
        "," + cutId +
            ")";

    System.out.println(sqlString);

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            int rtn = stmt.executeUpdate(sqlString);
        stmt.close();
        } catch (SQLException e) {
            System.out.println("DB access error in insertCrossSection" + e);
            System.out.println("SQL String was: " + sqlString);
            throw new JetWebDBException(e, sqlString,
                "plotId:" + plot.getId() + " paperId:" + paperId);
        }

        // Now get the new ID.
        plot.setId(getPlotId(paperId, plot.getNumber()));

        // Now add the plot switches.
        plot.storeSwitches();
    }

    public static synchronized void insertCrossSection(RealPlot plot, int paperId)
    throws JetWebException {
    insertCrossSection(DBConfig.JETWEB, plot, paperId);
    }

    public static synchronized void updateCrossSectionLabels(RealPlot plot)
        throws JetWebException {
        int inDefault = 0;

        if (plot.isDefaultSum()) {
            inDefault += 1;
        }

        if (plot.isDefaultFit()) {
            inDefault += 1;
        }

        String yAxisType = "lin";

        if (plot.isLogarithmic()) {
            yAxisType = "log";
        }

        int shape = 0;

        if (plot.isShape()) {
            shape = 1;
        }

    int cutId = -1;

    if(plot.getCutCollection()!=null){
        plot.getCutCollection().store();
        cutId = plot.getCutCollection().getId();
    }

        String sqlString = 
        "UPDATE cross_section SET paper_id='" + plot.getPaperId() + 
        "',title='" + plot.getTitle() + 
        "',x_axis_title='" + plot.getXLabel() + 
        "',y_axis_title='" + plot.getYLabel() + 
        "',in_default='" + inDefault + 
        "',plot_number='" + plot.getNumber() +
            "',scale_factor='" + plot.getSysScale() + 
        "',y_axis_type='" + yAxisType +
            "',is_shape='" + shape + 
        "',collision_id='" + plot.getCollisionId() +
        "',cut_collection_id=" + cutId +
            " where csn_id=" + plot.getId();

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            int rtn = stmt.executeUpdate(sqlString);
        stmt.close();
        } catch (SQLException e) {
            System.out.println("DB access error in updateCrossSectionLabels" + e);
            System.out.println("SQL String was: " + sqlString);
            throw new JetWebDBException(e, sqlString,
                "plotId:" + plot.getId() + " paperId:" + plot.getPaperId());
        }

        // Now add/update the plot switches.
        plot.storeSwitches();
    }

    public static synchronized void insertFittedPrediction(FittedPlot plot)
        throws JetWebException {
        String ins1 = "INSERT INTO fitted_prediction (fit_id,csn_id,chi2,dof) VALUES(" +
            plot.getFit().getId() + "," + plot.getId() + "," + plot.getChi2()[0] + "," +
            plot.getChi2()[1] + ")";

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            stmt.executeUpdate(ins1);
        stmt.close();
        } catch (SQLException e) {
            System.out.println("insertFittedPrediction failed: " + e);
            throw new JetWebDBException(e, ins1, "FittedPlot.id:" + plot.getId());
        }
    }

    public static synchronized int getPlotId(String ConName, int paperId, int plotNumber)
        throws JetWebException {
        int csnId = -1;
        String sqlString = "SELECT csn_id FROM cross_section WHERE paper_id=" + paperId +
            " AND plot_number=" + plotNumber;

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(sqlString);

            if (rs.next()) {
                csnId = rs.getInt("csn_id");
            }

            rs.close();
            stmt.close();
        } catch (SQLException e) {
            System.out.println("DB access error in getPlotId:" + e);
            System.out.println("SQL was: " + sqlString);

            throw new JetWebDBException(e, sqlString,
                "PaperId:" + paperId + "plotNumber:" + plotNumber);
        }

        return csnId;
    }

    public static synchronized int getPlotId(int paperId, int plotNumber)
        throws JetWebException {
        int csnId = -1;
        String sqlString = "SELECT csn_id FROM cross_section WHERE paper_id=" + paperId +
            " AND plot_number=" + plotNumber;

    System.out.println(sqlString);

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(sqlString);

            if (rs.next()) {
                csnId = rs.getInt("csn_id");
            }

            rs.close();
            stmt.close();
        } catch (SQLException e) {
            System.out.println("DB access error in getPlotId:" + e);
            System.out.println("SQL was: " + sqlString);

            throw new JetWebDBException(e, sqlString,
                "PaperId:" + paperId + "plotNumber:" + plotNumber);
        }

        return csnId;
    }

    public static synchronized List<Integer> getCSSIds(int csnId, boolean sorted)
        throws JetWebException {
        List<Integer> sets = new ArrayList<Integer>();

        //get all cross section sets for a cross section
        String queryString = "SELECT csn_set_id FROM cross_section_set WHERE csn_id=" + csnId;

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(queryString);

            while (rs.next()) {
                sets.add(new Integer(rs.getInt("csn_set_id")));
            }

            rs.close();
            stmt.close();
        } catch (SQLException e) {
            System.out.println("Error reading cross_section_set table " + e);
            throw new JetWebDBException(e, queryString, "CrossSectionId:" + csnId);
        }

        if (sorted) {
            Collections.sort(sets);
        }

        return sets;
    }

    public static synchronized List<Integer> getCsnIds(int cssId, 
                               boolean sorted)
        throws JetWebException {
        List<Integer> csns = new ArrayList<Integer>();

        //find all csns belonging to this set
        String queryString = "SELECT csn_id FROM cross_section_set WHERE csn_set_id=" + cssId;

        //+" ORDER BY csn_id";
        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(queryString);

            while (rs.next()) {
                csns.add(new Integer(rs.getInt("csn_id")));
            }

            rs.close();
            stmt.close();
        } catch (SQLException e) {
            System.out.println("Error reading cross_section_set table " + e);
            throw new JetWebDBException(e, queryString, "CrossSectionSetId:" + cssId);
        }

        if (sorted) {
            Collections.sort(csns);
        }

        return csns;
    }

    public static synchronized int getMaxCssId() throws JetWebException {
        int cssId = 0;
        String query = "SELECT MAX(csn_set_id) FROM cross_section_set";

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(query);

            if (rs.next()) {
                cssId = rs.getInt(1);
            }

            rs.close();
            stmt.close();
        } catch (SQLException e) {
            System.out.println("Error reading cross_section_set table " + e);
            throw new JetWebDBException(e, query, "");
        }

        return cssId;
    }

    public static synchronized void insertCrossSectionSet(Iterator<Integer> plotIds, int cssId)
        throws JetWebException {
        String ins = "";

        try {
            Statement stmt = DBConfig.getConnection().createStatement();

            while (plotIds.hasNext()) {
                ins = "INSERT INTO cross_section_set (csn_id,csn_set_id) VALUES(" +
                    (plotIds.next()).toString() + "," + cssId + ")";

                int i = stmt.executeUpdate(ins);
            }

            stmt.close();
        } catch (SQLException e) {
            System.out.println("Error inserting data into cross_section_set table ");
            System.out.println(e);
            System.out.println("SQL was: " + ins);
            throw new JetWebDBException(e, ins, "CrossSectionSetId:" + cssId);
        }
    }

    public static synchronized boolean plotExists(DataPlot plot, RunSeries runSeries)
        throws JetWebException {
        int plotId = plot.getId();
        int runSeriesId = runSeries.getId();
        boolean exists = false;
        String queryString = "";

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            queryString = "SELECT COUNT(runseries_id) count_plots " +
                "FROM predicted_point WHERE runseries_id=" + runSeriesId + " AND csn_id=" + plotId;

            ResultSet rs = stmt.executeQuery(queryString);

            if (rs.next()) {
                int n = rs.getInt("count_plots");

                if (n > 0) {
                    exists = true;
                }
            }

            rs.close();
            stmt.close();
        } catch (SQLException e) {
            System.out.println("Error reading predicted_points table ");
            System.out.println(e);
            System.out.println("SQL was: " + queryString);
            throw new JetWebDBException(e, queryString,
                "PlotId:" + plotId + " runSeriesId:" + runSeriesId);
        }

        return exists;
    }

    public static synchronized void populateSelection(PlotSelection selection)
        throws JetWebException {

        String queryString = "";
        int cssId = -1;
    selection.clearFitPlots();

        try {
            cssId = selection.getId();

            Statement stmt = DBConfig.getConnection().createStatement();
            queryString = "SELECT csn_id " + "FROM cross_section_set WHERE csn_set_id=" + cssId;

            ResultSet rs = stmt.executeQuery(queryString);

            while (rs.next()) {
                selection.addFitPlot(PaperBank.getPlot(rs.getInt("csn_id")));
            }

            rs.close();
            stmt.close();
        } catch (SQLException e) {
            System.out.println("Error reading predicted_points table ");
            System.out.println(e);
            System.out.println("SQL was: " + queryString);
            throw new JetWebDBException(e, queryString, "CssId=" + cssId);
        } catch (JetWebException e) {
            throw e;
        }
    }

    public static double[] getChi2(int plotId, int fitId) {
        String queryString = "";
        double[] chi2 = { 0.0, 0.0 };

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            queryString = "SELECT * FROM fitted_prediction WHERE fit_id=" + fitId + " AND csn_id=" +
                plotId;

            ResultSet rs = stmt.executeQuery(queryString);

            while (rs.next()) {
                chi2[0] = rs.getFloat("chi2");
                chi2[1] = rs.getFloat("dof");
            }

            rs.close();
            stmt.close();
        } catch (SQLException e) {
            System.out.println("Error reading fitted_prediction table ");
            System.out.println(e);
            System.out.println("SQL was: " + queryString);

            //throw new JetWebDBException(e,queryString,"CssId="+cssId);
            //  } catch (JetWebException e) {
            //      throw e;
        }

        return chi2;
    }

    public static void selectPlotSwitch(PlotSwitch plotSwitch)
        throws JetWebException {
        // Get all PlotSwitches for a cross section
        String queryString = "SELECT * FROM cross_section_switches WHERE switch_id=" +
            plotSwitch.getId();

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(queryString);

            while (rs.next()) {
                plotSwitch.setGeneratorName(rs.getString("generator_name"));

                plotSwitch.setGeneratorVersion(rs.getFloat("generator_version"));

                plotSwitch.setParameterName(rs.getString("parameter_name"));

                //Double tmp = rs.getFloat("parameter_value_high");
        Double tmp = rs.getDouble("parameter_value_high");
        String stringTmp = rs.getString("parameter_value_high");
                  
                if (rs.wasNull() || stringTmp.equals("null")) {
                    plotSwitch.setParameterValueHigh(Double.POSITIVE_INFINITY);

                } else {
                    plotSwitch.setParameterValueHigh(tmp);
                }

                //tmp = rs.getFloat("parameter_value_low");
        tmp = rs.getDouble("parameter_value_low");
        stringTmp = rs.getString("parameter_value_low");

                if (rs.wasNull()||stringTmp.equals("null")) {
                    plotSwitch.setParameterValueLow(Double.NEGATIVE_INFINITY);

                } else {
                    plotSwitch.setParameterValueLow(tmp);
                }

                plotSwitch.setMCProcessTypeId(rs.getInt("process_id"));

                plotSwitch.setPlotId(rs.getInt("csn_id"));
            }

            rs.close();
            stmt.close();
        } catch (SQLException e) {
            System.out.println("Error reading cross_section_switches table " + e);
            throw new JetWebDBException(e, queryString, "Switch Id :" + plotSwitch.getId());
        }
    }

    public static HashSet<PlotSwitch> getSwitches(int plotId) 
    throws JetWebException {
        HashSet<PlotSwitch> switches = new HashSet<PlotSwitch>();

        // Get all PlotSwitches for a cross section
        String queryString = "SELECT switch_id FROM cross_section_switches WHERE csn_id=" + plotId;

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet rs = stmt.executeQuery(queryString);

            while (rs.next()) {
                switches.add(new PlotSwitch(rs.getInt("switch_id")));
            }

            rs.close();
            stmt.close();
        } catch (SQLException e) {
            System.out.println("Error reading cross_section_switches table " + e);
            throw new JetWebDBException(e, queryString, "CrossSectionId:" + plotId);
        }

        return switches;
    }

    public static int getProcId(int runSeriesId) throws JetWebException {
        int procId;

        String selectString = "SELECT process_id from runseries WHERE runseries_id=" + runSeriesId;

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet dbrs = stmt.executeQuery(selectString);
            dbrs.next();
            procId = dbrs.getInt("process_id");
            dbrs.close();
            stmt.close();
        } catch (SQLException E) {
            System.out.println("SQLException: " + E.getMessage());
            System.out.println("SQLState:     " + E.getSQLState());
            System.out.println("VendorError:  " + E.getErrorCode());
            throw new JetWebDBException(E, selectString, "");
        }

        return procId;
    }

    public static void update(PlotSwitch ps) throws JetWebException {

    // first delete it.
    String deleteIt = "DELETE FROM cross_section_switches WHERE switch_id='"
        +ps.getId()+"'";

        StringBuffer ud = new StringBuffer("INSERT INTO cross_section_switches SET process_id='" 
        + ps.getMCProcessTypeId());

        if (ps.getParameterName() != null) {
            ud.append("',parameter_name='" + ps.getParameterName());

        if (ps.getParameterValueHigh() != Double.POSITIVE_INFINITY) {
        ud.append("', parameter_value_high='" + ps.getParameterValueHigh());
        }

        if (ps.getParameterValueLow() != Double.NEGATIVE_INFINITY) {
        ud.append("', parameter_value_low='" + ps.getParameterValueLow());
        }

    }
    if (ps.getGeneratorName() != null) {
        ud.append("', generator_name='" + ps.getGeneratorName());
    }

    ud.append("', generator_version='" + ps.getGeneratorVersion() + "',switch_id='" + ps.getId());
    ud.append("', csn_id='"+ps.getPlotId()+"'");


    //System.out.println(ud.toString());
        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            int rowsChanged = stmt.executeUpdate(deleteIt);
            rowsChanged = stmt.executeUpdate(ud.toString());
            stmt.close();
        } catch (SQLException E) {
            System.out.println("SQLException: " + E.getMessage());
            System.out.println("SQLState:     " + E.getSQLState());
            System.out.println("VendorError:  " + E.getErrorCode());
            throw new JetWebDBException(E, ud.toString(), "oh dear");
        }
    }

    public static void add(PlotSwitch ps) throws JetWebException {
        String ins1 = "Insert into cross_section_switches (csn_id, process_id, ";
        String ins2 = "values('" + ps.getPlotId() + "','" 
        + ps.getMCProcessTypeId() + "','";

        if (ps.getParameterName() != null) {
            ins1 = ins1 + " parameter_name,";
            ins2 = ins2 + ps.getParameterName() + "','";
        }

        if (ps.getParameterValueHigh() != Double.POSITIVE_INFINITY) {
            ins1 = ins1 + " parameter_value_high,";
            ins2 = ins2 + ps.getParameterValueHigh() + "','";
        }

        if (ps.getParameterValueLow() != Double.NEGATIVE_INFINITY) {
            ins1 = ins1 + " parameter_value_low,";
            ins2 = ins2 + ps.getParameterValueLow() + "','";
        }

        if (ps.getGeneratorName() != null) {
            ins1 = ins1 + " generator_name,";
            ins2 = ins2 + ps.getGeneratorName() + "','";
        }

        ins1 = ins1 + " generator_version)";
        ins2 = ins2 + ps.getGeneratorVersion() + "')";

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            int rowsChanged = stmt.executeUpdate(ins1 + ins2);
            stmt.close();
        } catch (SQLException E) {
            System.out.println("SQLException: " + E.getMessage());
            System.out.println("SQLState:     " + E.getSQLState());
            System.out.println("VendorError:  " + E.getErrorCode());
            throw new JetWebDBException(E, ins1 + ins2, "oh dear");
        }
    }

    public static synchronized void delete(PlotSwitch ps)
        throws JetWebException {
        String deleteString = "DELETE FROM cross_section_switches WHERE switch_id=" + ps.getId();

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            stmt.executeUpdate(deleteString);
            stmt.close();
        } catch (SQLException e) {
            System.out.println("Error deleting PlotSwitch");
            throw new JetWebDBException(e, deleteString, "PlotSwitchId:" + ps.getId());
        }
    }


    public static synchronized void delete(RealPlot plot)
        throws JetWebException {

    try {
        Connection con = DBConfig.getConnection();
        con.setAutoCommit(false);
            Statement stmt = con.createStatement();
            stmt.executeUpdate("DELETE FROM data_point WHERE csn_id="+plot.getId());
            stmt.executeUpdate("DELETE FROM predicted_point WHERE csn_id="+plot.getId());
            stmt.executeUpdate("DELETE FROM fitted_point WHERE csn_id="+plot.getId());
            stmt.executeUpdate("DELETE FROM cross_section_switches WHERE csn_id="+plot.getId());
            stmt.executeUpdate("DELETE FROM cross_section WHERE csn_id="+plot.getId());
            stmt.executeUpdate("DELETE FROM cross_section_set WHERE csn_id="+plot.getId());
            stmt.close();
        con.commit();
        } catch (SQLException e) {
            System.out.println("Error deleting plot");
            throw new JetWebDBException(e, "lots of SQL", "CsnId:" + plot.getId());
        }
    plot=null;
    }
    public static synchronized void delete(Paper paper)
        throws JetWebException {

    try {
        Connection con = DBConfig.getConnection();
            Statement stmt = con.createStatement();
            stmt.executeUpdate("DELETE FROM paper WHERE paper_id="+paper.getId());
            stmt.close();
        } catch (SQLException e) {
            System.out.println("Error deleting plot");
            throw new JetWebDBException(e, "lots of SQL", "PaperId:" + paper.getId());
        }
    paper=null;
    }

    public static Vector<PlotSwitch> getMatchedSwitches(int plotId, Generator gen)
        throws JetWebException {
        Vector<PlotSwitch> list = new Vector<PlotSwitch>();

        String selectString = 
        "SELECT switch_id from cross_section_switches where csn_id=" +
            plotId + 
        " and generator_name='" + gen.getName() + 
        "' and generator_version='" + gen.getVersion() + "'";

        try {
            Statement stmt = DBConfig.getConnection().createStatement();
            ResultSet dbrs = stmt.executeQuery(selectString);

            while (dbrs.next()) {
                PlotSwitch ps = new PlotSwitch(dbrs.getInt("switch_id"));
                list.add(ps);
            }

            dbrs.close();
            stmt.close();

            if (list.size() == 0) {
                selectString = "SELECT switch_id from cross_section_switches where csn_id=" +
                    plotId + " and generator_name='" + gen.getName() + "'";

                stmt = DBConfig.getConnection().createStatement();
                dbrs = stmt.executeQuery(selectString);

                while (dbrs.next()) {
                    PlotSwitch ps = new PlotSwitch(dbrs.getInt("switch_id"));
                    list.add(ps);
                }

                dbrs.close();
                stmt.close();
            }

            if (list.size() == 0) {
                selectString = "SELECT switch_id from cross_section_switches where csn_id=" +
                    plotId;

                stmt = DBConfig.getConnection().createStatement();
                dbrs = stmt.executeQuery(selectString);

                while (dbrs.next()) {
                    PlotSwitch ps = new PlotSwitch(dbrs.getInt("switch_id"));
                    list.add(ps);
                }

                dbrs.close();
                stmt.close();
            }

            return list;
        } catch (SQLException E) {
            System.out.println("SQLException: " + E.getMessage());
            System.out.println("SQLState:     " + E.getSQLState());
            System.out.println("VendorError:  " + E.getErrorCode());
            throw new JetWebDBException(E, selectString, "");
        }
    }
}

Generated Wed Jan 17 09:14:27 GMT 2007