Examples with ExternalDataIdentifier org.vcell.util.document.ExternalDataIdentifier used on opensource projects

Example 6 with ExternalDataIdentifier

use of org.vcell.util.document.ExternalDataIdentifier in project vcell by virtualcell.

the class ClientDocumentManager method saveFieldData.

public ExternalDataIdentifier saveFieldData(FieldDataFileOperationSpec fdos, String fieldDataBaseName) throws DataAccessException {
    FieldDataDBOperationResults fieldDataResults = fieldDataDBOperation(FieldDataDBOperationSpec.createGetExtDataIDsSpec(getUser()));
    ExternalDataIdentifier[] existingExternalIDs = fieldDataResults.extDataIDArr;
    // find available field data name (starting from init).
    for (ExternalDataIdentifier externalID : existingExternalIDs) {
        if (externalID.getName().equals(fieldDataBaseName)) {
            fieldDataBaseName = TokenMangler.getNextEnumeratedToken(fieldDataBaseName);
        }
    }
    FieldDataDBOperationSpec newExtDataIDSpec = FieldDataDBOperationSpec.createSaveNewExtDataIDSpec(getUser(), fieldDataBaseName, "");
    ExternalDataIdentifier eid = fieldDataDBOperation(newExtDataIDSpec).extDataID;
    fdos.specEDI = eid;
    fdos.annotation = "";
    try {
        // Add to Server Disk
        FieldDataFileOperationResults fdor = fieldDataFileOperation(fdos);
        LG.debug(fdor);
    } catch (DataAccessException e) {
        try {
            // try to cleanup new ExtDataID
            fieldDataDBOperation(FieldDataDBOperationSpec.createDeleteExtDataIDSpec(fdos.specEDI));
        } catch (Exception e2) {
        // ignore
        }
        fdos.specEDI = null;
        throw e;
    }
    return eid;
}

Example 7 with ExternalDataIdentifier

use of org.vcell.util.document.ExternalDataIdentifier in project vcell by virtualcell.

the class ExportServiceImpl method fireExportCompleted.

/**
 * Insert the method's description here.
 * Creation date: (4/1/2001 11:20:45 AM)
 * @deprecated
 */
protected ExportEvent fireExportCompleted(long jobID, VCDataIdentifier vcdID, String format, String location, ExportSpecs exportSpecs) {
    User user = null;
    Object object = jobRequestIDs.get(new Long(jobID));
    if (object != null) {
        user = (User) object;
    }
    TimeSpecs timeSpecs = (exportSpecs != null) ? exportSpecs.getTimeSpecs() : (null);
    VariableSpecs varSpecs = (exportSpecs != null) ? exportSpecs.getVariableSpecs() : (null);
    final KeyValue dataKey;
    if (vcdID instanceof VCSimulationDataIdentifier) {
        dataKey = ((VCSimulationDataIdentifier) vcdID).getSimulationKey();
    } else if (vcdID instanceof ExternalDataIdentifier) {
        dataKey = ((ExternalDataIdentifier) vcdID).getSimulationKey();
    } else {
        throw new RuntimeException("unexpected VCDataIdentifier");
    }
    ExportEvent event = new ExportEvent(this, jobID, user, vcdID.getID(), dataKey, ExportEvent.EXPORT_COMPLETE, format, location, null, timeSpecs, varSpecs);
    fireExportEvent(event);
    return event;
}

Example 8 with ExternalDataIdentifier

use of org.vcell.util.document.ExternalDataIdentifier in project vcell by virtualcell.

the class ClientDocumentManager method substituteFieldFuncNames.

public void substituteFieldFuncNames(VCDocument vcDocument, VersionableTypeVersion originalOwner) throws DataAccessException, MathException, ExpressionException {
    Vector<ExternalDataIdentifier> errorCleanupExtDataIDV = new Vector<ExternalDataIdentifier>();
    try {
        if (originalOwner == null || originalOwner.getVersion().getOwner().compareEqual(getUser())) {
            // Substitution for FieldFunc not needed for new doc or if we own doc
            return;
        }
        // Get Objects from Document that might need to have FieldFuncs replaced
        Vector<Object> fieldFunctionContainer_mathDesc_or_simContextV = new Vector<Object>();
        if (vcDocument instanceof MathModel) {
            fieldFunctionContainer_mathDesc_or_simContextV.add(((MathModel) vcDocument).getMathDescription());
        } else if (vcDocument instanceof BioModel) {
            SimulationContext[] simContextArr = ((BioModel) vcDocument).getSimulationContexts();
            for (int i = 0; i < simContextArr.length; i += 1) {
                fieldFunctionContainer_mathDesc_or_simContextV.add(simContextArr[i]);
            }
        }
        // Get original Field names
        Vector<String> origFieldFuncNamesV = new Vector<String>();
        for (int i = 0; i < fieldFunctionContainer_mathDesc_or_simContextV.size(); i += 1) {
            Object fieldFunctionContainer = fieldFunctionContainer_mathDesc_or_simContextV.elementAt(i);
            FieldFunctionArguments[] fieldFuncArgsArr = null;
            if (fieldFunctionContainer instanceof MathDescription) {
                fieldFuncArgsArr = FieldUtilities.getFieldFunctionArguments((MathDescription) fieldFunctionContainer);
            } else if (fieldFunctionContainer instanceof SimulationContext) {
                fieldFuncArgsArr = ((SimulationContext) fieldFunctionContainer).getFieldFunctionArguments();
            }
            for (int j = 0; j < fieldFuncArgsArr.length; j += 1) {
                if (!origFieldFuncNamesV.contains(fieldFuncArgsArr[j].getFieldName())) {
                    origFieldFuncNamesV.add(fieldFuncArgsArr[j].getFieldName());
                }
            }
        }
        if (origFieldFuncNamesV.size() == 0) {
            // No FieldFunctions to substitute
            return;
        }
        FieldDataDBOperationResults copyNamesFieldDataOpResults = fieldDataDBOperation(FieldDataDBOperationSpec.createCopyNoConflictExtDataIDsSpec(getUser(), origFieldFuncNamesV.toArray(new String[0]), originalOwner));
        errorCleanupExtDataIDV.addAll(copyNamesFieldDataOpResults.oldNameNewIDHash.values());
        // Copy Field Data on Data Server FileSystem
        for (String fieldname : origFieldFuncNamesV) {
            KeyValue sourceSimDataKey = copyNamesFieldDataOpResults.oldNameOldExtDataIDKeyHash.get(fieldname);
            if (sourceSimDataKey == null) {
                throw new DataAccessException("Couldn't find original data key for FieldFunc " + fieldname);
            }
            ExternalDataIdentifier newExtDataID = copyNamesFieldDataOpResults.oldNameNewIDHash.get(fieldname);
            getSessionManager().fieldDataFileOperation(FieldDataFileOperationSpec.createCopySimFieldDataFileOperationSpec(newExtDataID, sourceSimDataKey, originalOwner.getVersion().getOwner(), FieldDataFileOperationSpec.JOBINDEX_DEFAULT, getUser()));
        }
        // Finally substitute new Field names
        for (int i = 0; i < fieldFunctionContainer_mathDesc_or_simContextV.size(); i += 1) {
            Object fieldFunctionContainer = fieldFunctionContainer_mathDesc_or_simContextV.elementAt(i);
            if (fieldFunctionContainer instanceof MathDescription) {
                MathDescription mathDesc = (MathDescription) fieldFunctionContainer;
                FieldUtilities.substituteFieldFuncNames(mathDesc, copyNamesFieldDataOpResults.oldNameNewIDHash);
            } else if (fieldFunctionContainer instanceof SimulationContext) {
                SimulationContext simContext = (SimulationContext) fieldFunctionContainer;
                simContext.substituteFieldFuncNames(copyNamesFieldDataOpResults.oldNameNewIDHash);
            }
        }
        fireFieldDataDB(new FieldDataDBEvent(this));
    } catch (Exception e) {
        e.printStackTrace();
        // Cleanup
        for (int i = 0; i < errorCleanupExtDataIDV.size(); i += 1) {
            try {
                fieldDataDBOperation(FieldDataDBOperationSpec.createDeleteExtDataIDSpec(errorCleanupExtDataIDV.elementAt(i)));
            } catch (Exception e2) {
            // ignore, we tried to cleanup
            }
            try {
                fieldDataFileOperation(FieldDataFileOperationSpec.createDeleteFieldDataFileOperationSpec(errorCleanupExtDataIDV.elementAt(i)));
            } catch (Exception e1) {
            // ignore, we tried to cleanup
            }
        }
        throw new RuntimeException("Error copying Field Data \n" + e.getMessage());
    }
}

Example 9 with ExternalDataIdentifier

use of org.vcell.util.document.ExternalDataIdentifier in project vcell by virtualcell.

the class DataSetControllerImpl method fieldFunctionSubstitution.

private Expression fieldFunctionSubstitution(OutputContext outputContext, final VCDataIdentifier vcdID, Expression functionExpression) throws ExpressionException, DataAccessException, IOException, MathException {
    SimResampleInfoProvider simResampleInfoProvider = null;
    Expression origExpression = new Expression(functionExpression);
    if (vcdID instanceof VCSimulationDataIdentifier) {
        simResampleInfoProvider = ((VCSimulationDataIdentifier) vcdID);
    } else if (vcdID instanceof VCSimulationDataIdentifierOldStyle) {
        simResampleInfoProvider = ((VCSimulationDataIdentifierOldStyle) vcdID);
    } else if (vcdID instanceof ExternalDataIdentifier) {
        simResampleInfoProvider = ((ExternalDataIdentifier) vcdID);
    } else {
        return origExpression;
    }
    FieldFunctionArguments[] fieldfuncArgumentsArr = FieldUtilities.getFieldFunctionArguments(origExpression);
    if (fieldfuncArgumentsArr == null || fieldfuncArgumentsArr.length == 0) {
        return origExpression;
    }
    String[] origSymbols = origExpression.getSymbols();
    Vector<SymbolTableEntry> originalSymbolTablEntrryV = new Vector<SymbolTableEntry>();
    for (int i = 0; origSymbols != null && i < origSymbols.length; i++) {
        if (!originalSymbolTablEntrryV.contains(origExpression.getSymbolBinding(origSymbols[i]))) {
            originalSymbolTablEntrryV.add(origExpression.getSymbolBinding(origSymbols[i]));
        }
    }
    Expression exp = new Expression(origExpression);
    // 
    // Handle Field Data Function field(...)
    // 
    double[][] resampledFieldDatas = null;
    HashMap<String, Integer> substSymbolIndexH = new HashMap<String, Integer>();
    // if(fieldfuncArgumentsArr != null && fieldfuncArgumentsArr.length > 0){
    FieldDataIdentifierSpec[] fieldDataIdentifierSpecArr = getFieldDataIdentifierSpecs(fieldfuncArgumentsArr, simResampleInfoProvider.getOwner());
    // Substitute Field Data Functions for simple symbols for lookup-------
    for (int i = 0; i < fieldfuncArgumentsArr.length; i += 1) {
        for (int j = 0; j < fieldDataIdentifierSpecArr.length; j++) {
            if (fieldfuncArgumentsArr[i].equals(fieldDataIdentifierSpecArr[j].getFieldFuncArgs())) {
                String substFieldName = fieldfuncArgumentsArr[i].getFieldName() + "_" + fieldfuncArgumentsArr[i].getVariableName() + "_" + fieldfuncArgumentsArr[i].getTime().evaluateConstant();
                substFieldName = TokenMangler.fixTokenStrict(substFieldName);
                if (exp.hasSymbol(substFieldName)) {
                    throw new DataAccessException("Substitute Field data name is not unique");
                }
                String fieldFuncString = SimulationData.createCanonicalFieldFunctionSyntax(fieldDataIdentifierSpecArr[j].getExternalDataIdentifier().getName(), fieldfuncArgumentsArr[i].getVariableName(), fieldfuncArgumentsArr[i].getTime().evaluateConstant(), fieldfuncArgumentsArr[i].getVariableType().getTypeName());
                exp.substituteInPlace(new Expression(fieldFuncString), new Expression(substFieldName));
                substSymbolIndexH.put(substFieldName, i);
                break;
            }
        }
    }
    // ----------------------------------------------------------------------
    boolean[] bResample = new boolean[fieldDataIdentifierSpecArr.length];
    Arrays.fill(bResample, true);
    writeFieldFunctionData(outputContext, fieldDataIdentifierSpecArr, bResample, getMesh(simResampleInfoProvider), simResampleInfoProvider, getMesh(simResampleInfoProvider).getNumMembraneElements(), FVSolverStandalone.HESM_KEEP_AND_CONTINUE);
    resampledFieldDatas = new double[fieldfuncArgumentsArr.length][];
    for (int i = 0; i < fieldfuncArgumentsArr.length; i += 1) {
        // File resampledFile =
        // new File(getUserDir(vcsdID.getOwner()),
        // vcsdID.getID()+
        // FieldDataIdentifierSpec.getDefaultFieldDataFileNameForSimulation(fieldfuncArgumentsArr[i])
        // );
        // File resampledFile = new File(getPrimaryUserDir(simResampleInfoProvider.getOwner(), true),
        // SimulationData.createCanonicalResampleFileName(
        // simResampleInfoProvider, fieldfuncArgumentsArr[i]));
        File resampledFile = ((SimulationData) getVCData(simResampleInfoProvider)).getFieldDataFile(simResampleInfoProvider, fieldfuncArgumentsArr[i]);
        resampledFieldDatas[i] = DataSet.fetchSimData(fieldfuncArgumentsArr[i].getVariableName(), resampledFile);
    }
    // }
    // Rebind all the symbols
    String[] dependentIDs = exp.getSymbols();
    VariableSymbolTable varSymbolTable = new VariableSymbolTable();
    for (int i = 0; dependentIDs != null && i < dependentIDs.length; i++) {
        SymbolTableEntry newSymbolTableEntry = null;
        for (int j = 0; j < originalSymbolTablEntrryV.size(); j++) {
            if (originalSymbolTablEntrryV.elementAt(j).getName().equals(dependentIDs[i])) {
                newSymbolTableEntry = originalSymbolTablEntrryV.elementAt(j);
                break;
            }
        }
        if (newSymbolTableEntry == null) {
            if (substSymbolIndexH.containsKey(dependentIDs[i])) {
                int resampledDataIndex = substSymbolIndexH.get(dependentIDs[i]).intValue();
                FieldDataParameterVariable fieldDataParameterVariable = new FieldDataParameterVariable(dependentIDs[i], resampledFieldDatas[resampledDataIndex]);
                newSymbolTableEntry = fieldDataParameterVariable;
            }
        }
        if (newSymbolTableEntry == null) {
            throw new DataAccessException("Field Data Couldn't find substituted expression while evaluating function");
        }
        varSymbolTable.addVar(newSymbolTableEntry);
    }
    exp.bindExpression(varSymbolTable);
    return exp;
}

Example 10 with ExternalDataIdentifier

use of org.vcell.util.document.ExternalDataIdentifier in project vcell by virtualcell.

the class DataSetControllerImpl method fieldDataFileOperation.

public FieldDataFileOperationResults fieldDataFileOperation(FieldDataFileOperationSpec fieldDataFileOperationSpec) throws ObjectNotFoundException {
    if (fieldDataFileOperationSpec.opType == FieldDataFileOperationSpec.FDOS_COPYSIM) {
        Vector<File> removeFilesIfErrorV = new Vector<File>();
        try {
            int simJobIndex = fieldDataFileOperationSpec.sourceSimParamScanJobIndex;
            // Determine style so file names can be constructed properly
            VCSimulationDataIdentifier sourceSimDataID = new VCSimulationDataIdentifier(new VCSimulationIdentifier(fieldDataFileOperationSpec.sourceSimDataKey, fieldDataFileOperationSpec.sourceOwner), simJobIndex);
            SimulationData simulationData = (SimulationData) getVCData(sourceSimDataID);
            boolean isOldStyle = (simulationData.getResultsInfoObject() instanceof VCSimulationDataIdentifierOldStyle);
            // 
            // log,mesh,zip,func
            // 
            KeyValue origSimKey = fieldDataFileOperationSpec.sourceSimDataKey;
            File meshFile_orig = simulationData.getMeshFile(false);
            File funcFile_orig = simulationData.getFunctionsFile(false);
            File subdomainFile_orig = simulationData.getSubdomainFile();
            File fdLogFile_orig = simulationData.getLogFile();
            File zipFile_orig = simulationData.getZipFile(false, 0);
            boolean bCopySubdomainFile = subdomainFile_orig.exists();
            // Dont' check subdomainFile_orig
            if (!(meshFile_orig.exists() && funcFile_orig.exists() && fdLogFile_orig.exists() && zipFile_orig.exists())) {
                throw new RuntimeException("Couldn't find all of the files required to copy sim");
            }
            File userDir = getPrimaryUserDir(fieldDataFileOperationSpec.owner, true);
            File meshFile_new = new File(userDir, SimulationData.createCanonicalMeshFileName(fieldDataFileOperationSpec.specEDI.getKey(), 0, false));
            File funcFile_new = new File(userDir, SimulationData.createCanonicalFunctionsFileName(fieldDataFileOperationSpec.specEDI.getKey(), 0, false));
            File subdomainFile_new = new File(userDir, SimulationData.createCanonicalSubdomainFileName(fieldDataFileOperationSpec.specEDI.getKey(), 0, false));
            File fdLogFile_new = new File(userDir, SimulationData.createCanonicalSimLogFileName(fieldDataFileOperationSpec.specEDI.getKey(), 0, false));
            File zipFile_new = new File(userDir, SimulationData.createCanonicalSimZipFileName(fieldDataFileOperationSpec.specEDI.getKey(), 0, 0, false, false));
            if (meshFile_new.exists() || funcFile_new.exists() || fdLogFile_new.exists() || zipFile_new.exists() || (bCopySubdomainFile && subdomainFile_new.exists())) {
                throw new RuntimeException("File names required for new Field Data already exist on server");
            }
            removeFilesIfErrorV.add(funcFile_new);
            removeFilesIfErrorV.add(meshFile_new);
            removeFilesIfErrorV.add(fdLogFile_new);
            // Simple copy of mesh and funcfile because they do not have to be changed
            FileUtils.copyFile(meshFile_orig, meshFile_new, false, false, 8 * 1024);
            FileUtils.copyFile(funcFile_orig, funcFile_new, false, false, 8 * 1024);
            if (bCopySubdomainFile) {
                FileUtils.copyFile(subdomainFile_orig, subdomainFile_new, false, false, 8 * 1024);
            }
            // Copy Log file and replace original simID with ExternalDataIdentifier id
            BufferedWriter writer = null;
            try {
                String origLog = FileUtils.readFileToString(fdLogFile_orig);
                String newLogStr;
                String replace_new = SimulationData.createSimIDWithJobIndex(fieldDataFileOperationSpec.specEDI.getKey(), FieldDataFileOperationSpec.JOBINDEX_DEFAULT, false);
                if (isOldStyle) {
                    String replace_orig = SimulationData.createSimIDWithJobIndex(origSimKey, 0, true);
                    newLogStr = origLog.replaceAll(replace_orig, replace_new);
                } else {
                    String replace_orig = SimulationData.createSimIDWithJobIndex(origSimKey, fieldDataFileOperationSpec.sourceSimParamScanJobIndex, false);
                    newLogStr = origLog.replaceAll(replace_orig, replace_new);
                }
                writer = new BufferedWriter(new FileWriter(fdLogFile_new));
                writer.write(newLogStr);
                writer.close();
            } finally {
                try {
                    if (writer != null) {
                        writer.close();
                    }
                } catch (Exception e) {
                /*ignore*/
                }
                ;
            }
            // 
            // Copy zip file and rename entries
            // 
            int zipIndex = 0;
            while (true) {
                // Loop because there might be more than 1 zip file for large datasets
                zipFile_orig = simulationData.getZipFile(false, zipIndex);
                if (!zipFile_orig.exists()) {
                    // done
                    break;
                }
                zipFile_new = new File(userDir, SimulationData.createCanonicalSimZipFileName(fieldDataFileOperationSpec.specEDI.getKey(), zipIndex, 0, false, false));
                if (zipFile_new.exists()) {
                    throw new DataAccessException("new zipfile name " + zipFile_new.getAbsolutePath() + " already exists");
                }
                removeFilesIfErrorV.add(zipFile_new);
                ZipFile inZipFile = null;
                InputStream zis = null;
                ZipOutputStream zos = null;
                try {
                    inZipFile = new ZipFile(zipFile_orig);
                    ;
                    zos = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(zipFile_new)));
                    Enumeration<? extends ZipEntry> zipEntryEnum = inZipFile.getEntries();
                    while (zipEntryEnum.hasMoreElements()) {
                        ZipEntry zeIN = zipEntryEnum.nextElement();
                        byte[] zdataIN = new byte[(int) zeIN.getSize()];
                        int num = 0;
                        int numTotal = 0;
                        zis = new BufferedInputStream(inZipFile.getInputStream((ZipArchiveEntry) zeIN));
                        // long startTime = System.currentTimeMillis();
                        while ((num = zis.read(zdataIN, numTotal, zdataIN.length - numTotal)) != -1 && numTotal != zdataIN.length) {
                            numTotal += num;
                        }
                        // System.out.println("zipread time="+((System.currentTimeMillis()-startTime)/1000.0));
                        zis.close();
                        String newName;
                        String replace_new = SimulationData.createSimIDWithJobIndex(fieldDataFileOperationSpec.specEDI.getKey(), FieldDataFileOperationSpec.JOBINDEX_DEFAULT, false);
                        if (isOldStyle) {
                            String replace_orig = SimulationData.createSimIDWithJobIndex(origSimKey, 0, true);
                            newName = zeIN.getName().replaceAll(replace_orig, replace_new);
                        } else {
                            String replace_orig = SimulationData.createSimIDWithJobIndex(origSimKey, fieldDataFileOperationSpec.sourceSimParamScanJobIndex, false);
                            newName = zeIN.getName().replaceAll(replace_orig, replace_new);
                        }
                        ZipEntry zeOUT = new ZipEntry(newName);
                        zeOUT.setComment(zeIN.getComment());
                        zeOUT.setCompressedSize(zeIN.getCompressedSize());
                        zeOUT.setCrc(zeIN.getCrc());
                        zeOUT.setExtra(zeIN.getExtra());
                        zeOUT.setMethod(zeIN.getMethod());
                        zeOUT.setSize(zeIN.getSize());
                        zeOUT.setTime(zeIN.getTime());
                        // startTime = System.currentTimeMillis();
                        zos.putNextEntry(zeOUT);
                        zos.write(zdataIN, 0, zdataIN.length);
                    // System.out.println("zipwrite time="+((System.currentTimeMillis()-startTime)/1000.0)+"\n");
                    }
                } finally {
                    try {
                        if (zis != null) {
                            zis.close();
                        }
                    } catch (Exception e) {
                    /*ignore*/
                    }
                    ;
                    try {
                        if (zos != null) {
                            zos.close();
                        }
                    } catch (Exception e) {
                    /*ignore*/
                    }
                    ;
                }
                zipIndex += 1;
            }
            // Now see if we can read what we just wrote
            return fieldDataFileOperation(FieldDataFileOperationSpec.createInfoFieldDataFileOperationSpec(fieldDataFileOperationSpec.specEDI.getKey(), fieldDataFileOperationSpec.owner, FieldDataFileOperationSpec.JOBINDEX_DEFAULT));
        } catch (Exception e) {
            e.printStackTrace();
            try {
                for (int i = 0; i < removeFilesIfErrorV.size(); i += 1) {
                    removeFilesIfErrorV.elementAt(i).delete();
                }
            } catch (Throwable e2) {
            // ignore, we tried to cleanup
            }
            throw new RuntimeException("Error copying sim data to new Field Data\n" + e.getMessage());
        }
    } else if (fieldDataFileOperationSpec.opType == FieldDataFileOperationSpec.FDOS_ADD) {
        if (fieldDataFileOperationSpec.cartesianMesh == null) {
            throw new RuntimeException("Field Data Operation 'ADD' cartesianMesh cannot be null");
        }
        if (fieldDataFileOperationSpec.times == null || fieldDataFileOperationSpec.times.length == 0) {
            throw new RuntimeException("Field Data Operation 'ADD' times cannot be null");
        }
        if (fieldDataFileOperationSpec.times[0] != 0) {
            throw new RuntimeException("Field Data Operation 'ADD' first time must be 0.0");
        }
        if (fieldDataFileOperationSpec.varNames == null || fieldDataFileOperationSpec.varNames.length == 0) {
            throw new RuntimeException("Field Data Operation 'ADD' variable names cannot be null");
        }
        if ((fieldDataFileOperationSpec.shortSpecData != null && fieldDataFileOperationSpec.doubleSpecData != null) || (fieldDataFileOperationSpec.shortSpecData == null && fieldDataFileOperationSpec.doubleSpecData == null)) {
            throw new RuntimeException("Field Data Operation 'ADD' must have ONLY 1 data specifier, short or double");
        }
        if (fieldDataFileOperationSpec.shortSpecData != null && (fieldDataFileOperationSpec.shortSpecData.length != fieldDataFileOperationSpec.times.length || fieldDataFileOperationSpec.shortSpecData[0].length != fieldDataFileOperationSpec.varNames.length)) {
            throw new RuntimeException("Field Data Operation 'ADD' 'short' data dimension does not match\n" + "times and variable names array lengths");
        }
        if (fieldDataFileOperationSpec.doubleSpecData != null && (fieldDataFileOperationSpec.doubleSpecData.length != fieldDataFileOperationSpec.times.length || fieldDataFileOperationSpec.doubleSpecData[0].length != fieldDataFileOperationSpec.varNames.length)) {
            throw new RuntimeException("Field Data Operation 'ADD' 'double' data dimension does not match\n" + "times and variable names array lengths");
        }
        if (fieldDataFileOperationSpec.variableTypes == null || fieldDataFileOperationSpec.variableTypes.length == 0) {
            throw new RuntimeException("Field Data Operation 'ADD' variable types cannot be null");
        }
        if (fieldDataFileOperationSpec.variableTypes.length != fieldDataFileOperationSpec.varNames.length) {
            throw new RuntimeException("Field Data Operation 'ADD' variable types count does not match variable names count");
        }
        // byte[][][] allData = fieldDataFileOperationSpec.specData;
        double[] times = fieldDataFileOperationSpec.times;
        ExternalDataIdentifier dataset = fieldDataFileOperationSpec.specEDI;
        String[] vars = fieldDataFileOperationSpec.varNames;
        VariableType[] varTypes = fieldDataFileOperationSpec.variableTypes;
        File userDir = null;
        try {
            userDir = getPrimaryUserDir(fieldDataFileOperationSpec.owner, true);
        } catch (FileNotFoundException e) {
            throw new RuntimeException("Couldn't create new user directory on server");
        }
        double[][][] convertedData = null;
        if (fieldDataFileOperationSpec.doubleSpecData != null) {
            convertedData = fieldDataFileOperationSpec.doubleSpecData;
        } else {
            // convert short to double
            convertedData = new double[times.length][vars.length][];
            for (int i = 0; i < times.length; i += 1) {
                for (int j = 0; j < vars.length; j += 1) {
                    if (fieldDataFileOperationSpec.shortSpecData != null) {
                        convertedData[i][j] = new double[fieldDataFileOperationSpec.shortSpecData[i][j].length];
                        for (int k = 0; k < fieldDataFileOperationSpec.shortSpecData[i][j].length; k += 1) {
                            convertedData[i][j][k] = (double) (((int) fieldDataFileOperationSpec.shortSpecData[i][j][k]) & 0x0000FFFF);
                        }
                    } else {
                        throw new RuntimeException("no pixel data found");
                    }
                }
            }
        }
        // Write Log file
        File fdLogFile = new File(userDir, SimulationData.createCanonicalSimLogFileName(dataset.getKey(), 0, false));
        PrintStream ps = null;
        File zipFile = new File(userDir, SimulationData.createCanonicalSimZipFileName(dataset.getKey(), 0, 0, false, false));
        Vector<String> simFileNamesV = new Vector<String>();
        try {
            if (!fdLogFile.createNewFile()) {
                throw new Exception("File.createNewFile() returned null");
            }
            ps = new PrintStream(fdLogFile);
            for (int i = 0; i < times.length; i += 1) {
                String simFilename = SimulationData.createCanonicalSimFilePathName(dataset.getKey(), i, 0, false);
                simFileNamesV.add(simFilename);
                ps.println(i + "\t" + simFilename + "\t" + zipFile.getName() + "\t" + times[i] + "");
            }
            ps.flush();
        } catch (Exception e) {
            throw new RuntimeException("Couldn't create log file " + fdLogFile.getAbsolutePath() + "\n" + e.getMessage());
        } finally {
            if (ps != null) {
                ps.close();
            }
        }
        // Write zipFile
        java.util.zip.ZipOutputStream zipOut = null;
        try {
            java.io.BufferedOutputStream bout = new java.io.BufferedOutputStream(new java.io.FileOutputStream(zipFile));
            zipOut = new java.util.zip.ZipOutputStream(bout);
            for (int t = 0; t < times.length; t += 1) {
                java.io.File temp = java.io.File.createTempFile("temp", null);
                DataSet.writeNew(temp, vars, varTypes, fieldDataFileOperationSpec.isize, convertedData[t]);
                java.util.zip.ZipEntry zipEntry = new java.util.zip.ZipEntry(simFileNamesV.get(t));
                zipOut.putNextEntry(zipEntry);
                // ----------------------------
                java.io.BufferedInputStream in = new java.io.BufferedInputStream(new java.io.FileInputStream(temp));
                byte[] bytes = new byte[65536];
                try {
                    int b = in.read(bytes);
                    while (b != -1) {
                        zipOut.write(bytes, 0, b);
                        b = in.read(bytes);
                    }
                } catch (IOException e) {
                    throw new Exception("Error writing zip file bytes");
                } finally {
                    // cleanup
                    in.close();
                    temp.delete();
                }
            // ----------------------------
            }
        } catch (Exception e) {
            throw new RuntimeException("Couldn't create zip file " + zipFile.getAbsolutePath() + "\n" + e.getMessage());
        } finally {
            try {
                zipOut.close();
            } catch (IOException e) {
                e.printStackTrace();
            // ignore
            }
        }
        // Write Mesh file
        FileOutputStream fos = null;
        File meshFile = null;
        try {
            CartesianMesh mesh = fieldDataFileOperationSpec.cartesianMesh;
            meshFile = new File(userDir, SimulationData.createCanonicalMeshFileName(fieldDataFileOperationSpec.specEDI.getKey(), 0, false));
            fos = new FileOutputStream(meshFile);
            mesh.write(new PrintStream(fos));
        } catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException("Error writing mesh file " + meshFile.getAbsolutePath() + "\n" + e.getMessage());
        } finally {
            try {
                if (fos != null) {
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            // ignore
            }
        }
        // Write Functionfile file
        PrintStream ps2 = null;
        File funcFile = null;
        try {
            funcFile = new File(userDir, SimulationData.createCanonicalFunctionsFileName(fieldDataFileOperationSpec.specEDI.getKey(), 0, false));
            FileOutputStream fos2 = new FileOutputStream(funcFile);
            ps2 = new PrintStream(fos2);
            ps2.println("##---------------------------------------------" + "\n" + "##  " + funcFile.getAbsolutePath() + "\n" + "##---------------------------------------------" + "\n");
            ps2.flush();
            ps2.close();
        } catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException("Error writing function file " + funcFile.getAbsolutePath() + "\n" + e.getMessage());
        } finally {
            if (ps2 != null) {
                ps2.close();
            }
        }
        try {
            // return Info
            return fieldDataFileOperation(FieldDataFileOperationSpec.createInfoFieldDataFileOperationSpec(fieldDataFileOperationSpec.specEDI.getKey(), fieldDataFileOperationSpec.owner, FieldDataFileOperationSpec.JOBINDEX_DEFAULT));
        } catch (Exception e) {
            e.printStackTrace();
        // ignore
        }
    } else if (fieldDataFileOperationSpec.opType == FieldDataFileOperationSpec.FDOS_DEPENDANTFUNCS) {
        throw new RuntimeException("This function is not currently used");
    // //
    // //Check for references to FieldData from users User Defined Functions
    // //
    // HashMap<String, KeyValue> dbFuncFileNamesAndSimKeys = null;
    // try{
    // dbFuncFileNamesAndSimKeys =
    // FieldDataDBOperationDriver.getFunctionFileNamesAndSimKeys(
    // fieldDataFileOperationSpec.specEDI.getOwner());
    // }catch(Exception e){
    // e.printStackTrace();
    // throw new RuntimeException("couldn't get Function File names from Database\n"+e.getMessage());
    // }
    // //String regex = "^.*"+MathMLTags.FIELD+"\\s*\\(\\s*"+fieldDataFileOperationSpec.specEDI.getName()+"\\s*,.*$";
    // String regex = "^.*?field\\s*\\(\\s*"+fieldDataFileOperationSpec.specEDI.getName()+"\\s*,.*?$";
    // java.util.regex.Pattern pattern =
    // java.util.regex.Pattern.compile(regex);//,java.util.regex.Pattern.MULTILINE|java.util.regex.Pattern.DOTALL);
    // Matcher matcher = pattern.matcher("");
    // Set<Map.Entry<String,KeyValue>> funcAndSimsES = dbFuncFileNamesAndSimKeys.entrySet();
    // Vector<FieldDataFileOperationResults.FieldDataReferenceInfo> referencingFuncFileDescription =
    // new Vector<FieldDataFileOperationResults.FieldDataReferenceInfo>();
    // boolean bSearchSecondary =
    // secondaryRootDirectory != null &&
    // !primaryRootDirectory.equals(secondaryRootDirectory);
    // TreeSet<String> searchedFuncFilesTS = new TreeSet<String>();
    // Iterator<Map.Entry<String,KeyValue>> iter = funcAndSimsES.iterator();
    // FunctionFileGenerator.FuncFileLineInfo funcfileInfo = null;
    // while(iter.hasNext()){
    // Map.Entry<String,KeyValue> currentEntry = iter.next();
    // File currentFile = null;
    // for (int i = 0; i < (bSearchSecondary?2:1); i++) {
    // if(searchedFuncFilesTS.contains(currentEntry.getKey())){
    // continue;
    // }
    // currentFile = new File(
    // getUserDirectoryName(
    // (i==0?primaryRootDirectory:secondaryRootDirectory),
    // fieldDataFileOperationSpec.specEDI.getOwner()),currentEntry.getKey());
    // if(!currentFile.exists()){
    // continue;
    // }
    // searchedFuncFilesTS.add(currentEntry.getKey());
    // LineNumberReader lineNumberReader = null;
    // Vector<String> referringFieldfunctionNamesV = new Vector<String>();
    // try{
    // lineNumberReader = new LineNumberReader(new FileReader(currentFile));
    // String funcFileLine = null;
    // while((funcFileLine = lineNumberReader.readLine()) != null){
    // funcfileInfo = FunctionFileGenerator.readFunctionLine(funcFileLine);
    // if(funcfileInfo != null && funcfileInfo.functionExpr != null){
    // matcher.reset(funcfileInfo.functionExpr);
    // if(matcher.matches()){
    // referringFieldfunctionNamesV.add(funcfileInfo.functionName);
    // }
    // }
    // }
    // lineNumberReader.close();
    // if(referringFieldfunctionNamesV.size() > 0){
    // FieldDataFileOperationResults.FieldDataReferenceInfo fieldDataReferenceInfo =
    // FieldDataDBOperationDriver.getModelDescriptionForSimulation(
    // fieldDataFileOperationSpec.specEDI.getOwner(), currentEntry.getValue());
    // fieldDataReferenceInfo.funcNames = referringFieldfunctionNamesV.toArray(new String[0]);
    // referencingFuncFileDescription.add(fieldDataReferenceInfo);
    // //						for (int j = 0; j < referringFieldfunctionNamesV.size(); j++) {
    // //							referencingFuncFileDescription.add(new String[][] {
    // //								referringFieldfunctionNamesV.elementAt(j),modelDescription});
    // //						}
    // }
    // }catch(Exception e){
    // e.printStackTrace();
    // throw new RuntimeException(e.getMessage(),e);
    // }finally{
    // if(lineNumberReader != null){try{lineNumberReader.close();}catch(Exception e){e.printStackTrace();}}
    // }
    // }
    // }
    // if(referencingFuncFileDescription.size() > 0){
    // FieldDataFileOperationResults fdfor = new FieldDataFileOperationResults();
    // fdfor.dependantFunctionInfo =
    // referencingFuncFileDescription.toArray(new FieldDataFileOperationResults.FieldDataReferenceInfo[0]);
    // return fdfor;
    // }
    // return null;
    } else if (fieldDataFileOperationSpec.opType == FieldDataFileOperationSpec.FDOS_DELETE) {
        // 
        if (cacheTable0 != null) {
            VCSimulationIdentifier vcSimID = new VCSimulationIdentifier(fieldDataFileOperationSpec.specEDI.getKey(), fieldDataFileOperationSpec.specEDI.getOwner());
            VCSimulationDataIdentifier simDataID = new VCSimulationDataIdentifier(vcSimID, FieldDataFileOperationSpec.JOBINDEX_DEFAULT);
            cacheTable0.removeAll(simDataID);
            cacheTable0.removeAll(fieldDataFileOperationSpec.specEDI);
        }
        if (userExtDataIDH != null) {
            userExtDataIDH.remove(fieldDataFileOperationSpec.specEDI.getOwner());
        }
        SimulationData simulationData = null;
        try {
            simulationData = (SimulationData) getVCData(fieldDataFileOperationSpec.specEDI);
        } catch (Exception e) {
            throw new ObjectNotFoundException(e.getMessage(), e);
        }
        File fdLogFile = simulationData.getLogFile();
        File fdMeshFile = simulationData.getMeshFile(false);
        File fdFunctionFile = simulationData.getFunctionsFile(true);
        File fdSubdomainFile = simulationData.getSubdomainFile();
        if (!fdLogFile.delete()) {
            System.out.println("Couldn't delete log file " + fdLogFile.getAbsolutePath());
        }
        if (!fdMeshFile.delete()) {
            System.out.println("Couldn't delete Mesh file " + fdMeshFile.getAbsolutePath());
        }
        if (!fdFunctionFile.delete()) {
            System.out.println("Couldn't delete Functions file " + fdFunctionFile.getAbsolutePath());
        }
        if (fdSubdomainFile.exists() && fdSubdomainFile.delete()) {
            System.out.println("Couldn't delete Subdomains file " + fdSubdomainFile.getAbsolutePath());
        }
        int index = 0;
        while (true) {
            File fdZipFile = simulationData.getZipFile(false, index);
            if (index != 0 && !fdZipFile.exists()) {
                break;
            }
            if (!fdZipFile.delete()) {
                System.out.println("Couldn't delete zip file " + fdZipFile.getAbsolutePath());
            }
            index += 1;
        }
        return null;
    } else if (fieldDataFileOperationSpec.opType == FieldDataFileOperationSpec.FDOS_INFO) {
        try {
            FieldDataFileOperationResults fdor = new FieldDataFileOperationResults();
            VCDataIdentifier sourceSimDataID = new VCSimulationDataIdentifier(new VCSimulationIdentifier(fieldDataFileOperationSpec.sourceSimDataKey, fieldDataFileOperationSpec.sourceOwner), fieldDataFileOperationSpec.sourceSimParamScanJobIndex);
            fdor.dataIdentifierArr = getDataIdentifiers(null, sourceSimDataID);
            CartesianMesh mesh = getMesh(sourceSimDataID);
            fdor.extent = mesh.getExtent();
            fdor.origin = mesh.getOrigin();
            fdor.iSize = new ISize(mesh.getSizeX(), mesh.getSizeY(), mesh.getSizeZ());
            fdor.times = getDataSetTimes(sourceSimDataID);
            return fdor;
        } catch (FileNotFoundException e) {
            throw new ObjectNotFoundException("Error FieldDataOp get INFO", e);
        } catch (Exception e) {
            throw new RuntimeException("Error FieldDataFileOperationSpec INFO Operation\n" + e.getMessage());
        }
    }
    throw new RuntimeException("Field data operation " + fieldDataFileOperationSpec.opType + " unknown.");
}