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

Example 16 with VCDataIdentifier

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

the class ClientPDEDataContext method setDataManager.

/**
 * Insert the method's description here.
 * Creation date: (10/3/00 5:03:43 PM)
 */
// public abstract void refreshIdentifiers();
/**
 * This method is called from SimResultsViewer.updateScanParamChoices(),
 * which is going to update results view upon a choice of scanned parameters.
 */
public void setDataManager(PDEDataManager newDataManager) throws DataAccessException {
    VCDataIdentifier oldid = dataManager.getVCDataIdentifier();
    VCDataIdentifier newid = newDataManager.getVCDataIdentifier();
    if (oldid instanceof VCSimulationDataIdentifier && newid instanceof VCSimulationDataIdentifier && ((VCSimulationDataIdentifier) oldid).getVcSimID().equals(((VCSimulationDataIdentifier) newid).getVcSimID())) {
        PDEDataManager oldPDataManager = dataManager;
        dataManager = newDataManager;
        DataIdentifier[] dis = getDataManager().getDataIdentifiers();
        double[] times = getDataManager().getDataSetTimes();
        setDataIdentifiers(dis);
        setTimePoints(times);
        externalRefresh();
        setVCDataIdentifier(dataManager.getVCDataIdentifier());
        firePropertyChange(SimDataConstants.PDE_DATA_MANAGER_CHANGED, oldPDataManager, newDataManager);
    } else {
        throw new RuntimeException("DataManager change not allowed: oldID = " + oldid + " newID = " + newid);
    }
}

Example 17 with VCDataIdentifier

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

the class DataSetControllerImpl method adjustMembraneAdjacentVolumeValues.

private void adjustMembraneAdjacentVolumeValues(OutputContext outputContext, double[][] dataToAdjust, boolean bTimeFormat, SimDataBlock fullDataValueSource, int[] volumeDataIndexes, int[] membraneIndexesInOut, VCDataIdentifier vcdID, String varName, CartesianMesh mesh, TimeInfo timeInfo) throws Exception {
    if (membraneIndexesInOut == null || membraneIndexesInOut.length == 0) {
        return;
    }
    if (bTimeFormat) {
        if (dataToAdjust.length != volumeDataIndexes.length + 1 || dataToAdjust[0].length != timeInfo.desiredTimeValues.length) {
            throw new IllegalArgumentException(this.getClass().getName() + ".adjustMembraneAdjacentVolumeValues array format wrong for time flag=" + bTimeFormat);
        }
    } else {
        if (dataToAdjust.length != timeInfo.desiredTimeValues.length || dataToAdjust[0].length != volumeDataIndexes.length) {
            throw new IllegalArgumentException(this.getClass().getName() + ".adjustMembraneAdjacentVolumeValues array format wrong for time flag=" + bTimeFormat);
        }
    }
    boolean bIsSpecial = false;
    AnnotatedFunction insideFunction = null;
    AnnotatedFunction outsideFunction = null;
    VCData vcData = getVCData(vcdID);
    DataIdentifier[] myDataIdentifers = getDataIdentifiers(outputContext, vcdID);
    for (int i = 0; i < myDataIdentifers.length; i++) {
        if (myDataIdentifers[i].getName().equals(varName)) {
            if (myDataIdentifers[i].getVariableType().equals(VariableType.MEMBRANE)) {
                throw new IllegalArgumentException(this.getClass().getName() + ".adjustMembraneAdjacentVolumeValues Not for Membrane Variables");
            }
            Expression insideExp = null;
            Expression outsideExp = null;
            if (myDataIdentifers[i].isFunction()) {
                AnnotatedFunction sourceFunction = null;
                AnnotatedFunction[] functionsArr = getFunctions(outputContext, vcdID);
                for (int j = 0; j < functionsArr.length; j++) {
                    if (functionsArr[j].getName().equals(varName)) {
                        // need to subsitute and flatten the expression since we no longer store simplified expression.
                        if (vcData instanceof SimulationData) {
                            sourceFunction = ((SimulationData) vcData).simplifyFunction(functionsArr[j]);
                        } else {
                            throw new Exception("DataSetControllerImpl::getTimeSeriesValues_private(): has to be SimulationData to get time plot.");
                        }
                        break;
                    }
                }
                Vector<DataSetIdentifier> dependencyList = identifyDataDependencies(sourceFunction);
                insideExp = new Expression(sourceFunction.getExpression());
                outsideExp = new Expression(sourceFunction.getExpression());
                for (int j = 0; j < dependencyList.size(); j++) {
                    insideExp.substituteInPlace(new Expression(dependencyList.elementAt(j).getName()), new Expression(dependencyList.elementAt(j).getName() + InsideVariable.INSIDE_VARIABLE_SUFFIX));
                    outsideExp.substituteInPlace(new Expression(dependencyList.elementAt(j).getName()), new Expression(dependencyList.elementAt(j).getName() + OutsideVariable.OUTSIDE_VARIABLE_SUFFIX));
                }
            } else {
                insideExp = new Expression(varName + InsideVariable.INSIDE_VARIABLE_SUFFIX);
                outsideExp = new Expression(varName + OutsideVariable.OUTSIDE_VARIABLE_SUFFIX);
            }
            if (insideExp != null && outsideExp != null) {
                insideExp.bindExpression(vcData);
                outsideExp.bindExpression(vcData);
                // TODO domain
                Domain domain = null;
                insideFunction = new AnnotatedFunction("", insideExp, domain, "", VariableType.MEMBRANE, FunctionCategory.PREDEFINED);
                outsideFunction = new AnnotatedFunction("", outsideExp, domain, "", VariableType.MEMBRANE, FunctionCategory.PREDEFINED);
                insideFunction.setExpression(insideExp.flatten());
                outsideFunction.setExpression(outsideExp.flatten());
                FieldFunctionArguments[] insideExpFieldFunctionArgs = FieldUtilities.getFieldFunctionArguments(insideExp);
                FieldFunctionArguments[] outsideExpFieldFunctionArgs = FieldUtilities.getFieldFunctionArguments(outsideExp);
                bIsSpecial = !isAllowOptimizedTimeDataRetrieval() || hasGradient(insideExp) || hasGradient(outsideExp) || (insideExpFieldFunctionArgs != null && insideExpFieldFunctionArgs.length > 0) || (outsideExpFieldFunctionArgs != null && outsideExpFieldFunctionArgs.length > 0);
                if (bIsSpecial && fullDataValueSource == null) {
                    throw new IllegalArgumentException(this.getClass().getName() + ".adjustMembraneAdjacentVolumeValues: special values need SimDataBlock");
                }
            }
            break;
        }
    }
    int crossingCount = 0;
    for (int j = 0; j < membraneIndexesInOut.length; j++) {
        if (membraneIndexesInOut[j] != -1) {
            crossingCount += 1;
        }
    }
    if (crossingCount > 0) {
        int[] crossingCondensedIndexes = new int[crossingCount];
        int[] crossingCondensedOrigLocation = new int[crossingCount];
        crossingCount = 0;
        for (int j = 0; j < membraneIndexesInOut.length; j++) {
            if (membraneIndexesInOut[j] != -1) {
                crossingCondensedOrigLocation[crossingCount] = j;
                crossingCondensedIndexes[crossingCount] = membraneIndexesInOut[j];
                crossingCount += 1;
            }
        }
        MultiFunctionIndexes mfi_inside = null;
        MultiFunctionIndexes mfi_outside = null;
        for (int j = 0; j < crossingCount; j++) {
            double specialInsideVal = (bIsSpecial ? interpolateVolDataValToMemb(mesh, crossingCondensedIndexes[j], fullDataValueSource, true, false) : 0);
            double specialOutsideVal = (bIsSpecial ? interpolateVolDataValToMemb(mesh, crossingCondensedIndexes[j], fullDataValueSource, false, false) : 0);
            VolumeIndexNearFar vinf_inside = interpolateFindNearFarIndex(mesh, crossingCondensedIndexes[j], true, false);
            VolumeIndexNearFar vinf_outside = interpolateFindNearFarIndex(mesh, crossingCondensedIndexes[j], false, false);
            if (vinf_inside.volIndexNear == volumeDataIndexes[crossingCondensedOrigLocation[j]]) {
                if (!bIsSpecial && mfi_inside == null) {
                    mfi_inside = new MultiFunctionIndexes(vcdID, insideFunction, crossingCondensedIndexes, timeInfo.wantsTheseTimes, null, outputContext);
                }
                for (int k = 0; k < timeInfo.desiredTimeValues.length; k++) {
                    if (bTimeFormat) {
                        dataToAdjust[crossingCondensedOrigLocation[j] + 1][k] = (bIsSpecial ? specialInsideVal : mfi_inside.evaluateTimeFunction(outputContext, k, j));
                    } else {
                        dataToAdjust[k][crossingCondensedOrigLocation[j]] = (bIsSpecial ? specialInsideVal : mfi_inside.evaluateTimeFunction(outputContext, k, j));
                    }
                }
            } else if (vinf_outside.volIndexNear == volumeDataIndexes[crossingCondensedOrigLocation[j]]) {
                if (!bIsSpecial && mfi_outside == null) {
                    mfi_outside = new MultiFunctionIndexes(vcdID, outsideFunction, crossingCondensedIndexes, timeInfo.wantsTheseTimes, null, outputContext);
                }
                for (int k = 0; k < timeInfo.desiredTimeValues.length; k++) {
                    if (bTimeFormat) {
                        dataToAdjust[crossingCondensedOrigLocation[j] + 1][k] = (bIsSpecial ? specialOutsideVal : mfi_outside.evaluateTimeFunction(outputContext, k, j));
                    } else {
                        dataToAdjust[k][crossingCondensedOrigLocation[j]] = (bIsSpecial ? specialOutsideVal : mfi_outside.evaluateTimeFunction(outputContext, k, j));
                    }
                }
            } else {
                throw new Exception("couldn't match 'near' indexes");
            }
        }
    } else {
        throw new IllegalArgumentException("No non-null membrane crossing indexes found");
    }
}

Example 18 with VCDataIdentifier

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

the class DataSetControllerImpl method getVtuVarInfos.

public VtuVarInfo[] getVtuVarInfos(ComsolSimFiles comsolFiles, OutputContext outputContext, VCDataIdentifier vcdataID) throws DataAccessException {
    try {
        DataIdentifier[] dataIdentifiers = getDataIdentifiers(outputContext, vcdataID);
        if (dataIdentifiers == null) {
            return null;
        }
        ArrayList<VtuVarInfo> vtuVarInfos = new ArrayList<VtuVarInfo>();
        for (DataIdentifier di : dataIdentifiers) {
            String name = di.getName();
            String displayName = di.getDisplayName();
            if (di.getDomain() != null) {
                System.err.println("DataSetControllerImpl.getVtuVarInfos(comsol): need to support proper domain names now");
            }
            String domainName = "domain";
            VariableDomain variableDomain = null;
            VariableType variableType = di.getVariableType();
            if (variableType.equals(VariableType.VOLUME) || variableType.equals(VariableType.VOLUME_REGION)) {
                variableDomain = VariableDomain.VARIABLEDOMAIN_VOLUME;
            } else if (variableType.equals(VariableType.MEMBRANE) || variableType.equals(VariableType.MEMBRANE_REGION)) {
                variableDomain = VariableDomain.VARIABLEDOMAIN_MEMBRANE;
            } else if (variableType.equals(VariableType.POINT_VARIABLE)) {
                variableDomain = VariableDomain.VARIABLEDOMAIN_POINT;
            } else if (variableType.equals(VariableType.CONTOUR) || variableType.equals(VariableType.CONTOUR_REGION)) {
                variableDomain = VariableDomain.VARIABLEDOMAIN_CONTOUR;
            } else if (variableType.equals(VariableType.NONSPATIAL)) {
                variableDomain = VariableDomain.VARIABLEDOMAIN_UNKNOWN;
            } else if (variableType.equals(VariableType.POSTPROCESSING)) {
                variableDomain = VariableDomain.VARIABLEDOMAIN_POSTPROCESSING;
            } else {
                System.err.print("skipping var " + di + ", unsupported data type");
            }
            String functionExpression = null;
            boolean bMeshVariable = false;
            if (name.toUpperCase().contains("SIZE")) {
                System.err.println("Skipping Moving Boundary variable '" + name + "' because it is a size ... change later");
                continue;
            }
            vtuVarInfos.add(new VtuVarInfo(name, displayName, domainName, variableDomain, functionExpression, DataType.PointData, bMeshVariable));
        }
        return vtuVarInfos.toArray(new VtuVarInfo[0]);
    } catch (Exception e) {
        lg.error(e.getMessage(), e);
        throw new DataAccessException("failed to retrieve VTK variable list: " + e.getMessage(), e);
    }
}

Example 19 with VCDataIdentifier

use of org.vcell.util.document.VCDataIdentifier 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.");
}

Example 20 with VCDataIdentifier

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

the class DataSetControllerImpl method getLineScan.

/**
 * This method was created by a SmartGuide.
 * @return cbit.plot.PlotData
 * @param varName java.lang.String
 * @param begin cbit.vcell.math.CoordinateIndex
 * @param end cbit.vcell.math.CoordinateIndex
 */
public PlotData getLineScan(OutputContext outputContext, VCDataIdentifier vcdID, String varName, double time, SpatialSelection spatialSelection) throws DataAccessException, MathException {
    try {
        if (spatialSelection == null) {
            throw new IllegalArgumentException("null spatialSelection");
        }
        if (spatialSelection.isPoint()) {
            throw new RuntimeException("'Point' spatialSelection not expected");
        }
        double[] dataTimes = getDataSetTimes(vcdID);
        if (dataTimes == null || dataTimes.length <= 0) {
            return null;
        }
        CartesianMesh mesh = getMesh(vcdID);
        // mesh is transient and is null if we got here by a serialized path (e.g. rmi)
        spatialSelection.setMesh(mesh);
        SimDataBlock simDataBlock = getSimDataBlock(outputContext, vcdID, varName, time);
        if (simDataBlock == null) {
            return null;
        }
        DataIdentifier dataIdentifier = null;
        try {
            DataIdentifier[] dataIdentifiers = getDataIdentifiers(outputContext, vcdID);
            for (int i = 0; i < dataIdentifiers.length; i++) {
                if (dataIdentifiers[i].getName().equals(varName)) {
                    dataIdentifier = dataIdentifiers[i];
                }
            }
        } catch (IOException e) {
            throw new DataAccessException(e.getMessage());
        }
        double[] data = simDataBlock.getData();
        if (data == null) {
            return null;
        }
        if (spatialSelection instanceof SpatialSelectionVolume) {
            SpatialSelectionVolume ssVolume = (SpatialSelectionVolume) spatialSelection;
            SpatialSelection.SSHelper ssvHelper = ssVolume.getIndexSamples(0.0, 1.0);
            if (dataIdentifier.getVariableType().equals(VariableType.VOLUME)) {
                ssvHelper.initializeValues_VOLUME(data);
            } else if (dataIdentifier.getVariableType().equals(VariableType.VOLUME_REGION)) {
                ssvHelper.initializeValues_VOLUMEREGION(data);
            } else {
                throw new RuntimeException(SpatialSelectionVolume.class.getName() + " does not support variableType=" + dataIdentifier.getVariableType());
            }
            try {
                if (ssvHelper.getMembraneIndexesInOut() != null && ssvHelper.getMembraneIndexesInOut().length > 0) {
                    adjustMembraneAdjacentVolumeValues(outputContext, new double[][] { ssvHelper.getSampledValues() }, false, simDataBlock, ssvHelper.getSampledIndexes(), ssvHelper.getMembraneIndexesInOut(), vcdID, varName, mesh, // PostProcess never calls LineScan so send in VCell times
                    new TimeInfo(vcdID, time, 1, time, getDataSetTimes(vcdID)));
                }
            } catch (Exception e) {
                throw new DataAccessException("Error getLineScan adjustingMembraneValues\n" + e.getMessage(), e);
            }
            double[] values = ssvHelper.getSampledValues();
            if (mesh.isChomboMesh()) {
                // convert NaN to 0
                for (int i = 0; i < values.length; i++) {
                    if (Double.isNaN(values[i])) {
                        values[i] = 0;
                    }
                }
            }
            return new PlotData(ssvHelper.getWorldCoordinateLengths(), values);
        } else if (spatialSelection instanceof SpatialSelectionContour) {
            // 
            // get length of span (in microns)
            // 
            double lengthMicrons = spatialSelection.getLengthInMicrons();
            if (lengthMicrons <= 0) {
                return null;
            }
            int sizeScan;
            int[] sampleIndexes = null;
            double[] lineScan = null;
            double[] distance = null;
            SpatialSelectionContour ssContour = (SpatialSelectionContour) spatialSelection;
            sampleIndexes = ssContour.getIndexSamples();
            sizeScan = sampleIndexes.length;
            // 
            if (dataIdentifier.getVariableType().equals(VariableType.CONTOUR_REGION)) {
                for (int i = 0; i < sampleIndexes.length; i++) {
                    sampleIndexes[i] = mesh.getContourRegionIndex(sampleIndexes[i]);
                }
            }
            lineScan = new double[sizeScan];
            distance = new double[sizeScan];
            for (int i = 0; i < sizeScan; i++) {
                lineScan[i] = data[sampleIndexes[i]];
                distance[i] = (((double) i) / (sizeScan - 1)) * lengthMicrons;
            }
            return new PlotData(distance, lineScan);
        } else if (spatialSelection instanceof SpatialSelectionMembrane) {
            SpatialSelectionMembrane ssMembrane = (SpatialSelectionMembrane) spatialSelection;
            SpatialSelection.SSHelper ssmHelper = ssMembrane.getIndexSamples();
            if (dataIdentifier.getVariableType().equals(VariableType.MEMBRANE)) {
                ssmHelper.initializeValues_MEMBRANE(data);
            } else if (dataIdentifier.getVariableType().equals(VariableType.MEMBRANE_REGION)) {
                ssmHelper.initializeValues_MEMBRANEREGION(data);
            } else {
                throw new RuntimeException(SpatialSelectionMembrane.class.getName() + " does not support variableType=" + dataIdentifier.getVariableType());
            }
            return new PlotData(ssmHelper.getWorldCoordinateLengths(), ssmHelper.getSampledValues());
        } else {
            throw new RuntimeException("unexpected SpatialSelection type " + spatialSelection.getClass().toString());
        }
    } catch (DataAccessException e) {
        lg.error(e.getMessage(), e);
        throw e;
    } catch (IOException e) {
        lg.error(e.getMessage(), e);
        throw new DataAccessException(e.getMessage());
    }
}