Examples with ISize org.vcell.util.ISize used on opensource projects

Example 26 with ISize

use of org.vcell.util.ISize in project vcell by virtualcell.

the class FiniteVolumeFileWriter method writeChomboSpec.

private void writeChomboSpec() throws ExpressionException, SolverException, PropertyVetoException, ClassNotFoundException, IOException, GeometryException, ImageException {
    if (!bChomboSolver) {
        return;
    }
    GeometrySpec geometrySpec = resampledGeometry.getGeometrySpec();
    int dimension = geometrySpec.getDimension();
    if (dimension == 1) {
        throw new SolverException(simTask.getSimulation().getSolverTaskDescription().getSolverDescription().getDisplayLabel() + " is only supported for simulations with 2D or 3D geometry.");
    }
    Simulation simulation = getSimulationTask().getSimulation();
    SolverTaskDescription solverTaskDescription = simulation.getSolverTaskDescription();
    ChomboSolverSpec chomboSolverSpec = solverTaskDescription.getChomboSolverSpec();
    printWriter.println(FVInputFileKeyword.CHOMBO_SPEC_BEGIN);
    printWriter.println(FVInputFileKeyword.DIMENSION + " " + geometrySpec.getDimension());
    Extent extent = geometrySpec.getExtent();
    Origin origin = geometrySpec.getOrigin();
    ISize isize = simulation.getMeshSpecification().getSamplingSize();
    switch(geometrySpec.getDimension()) {
        case 2:
            printWriter.println(FVInputFileKeyword.MESH_SIZE + " " + isize.getX() + " " + isize.getY());
            printWriter.println(FVInputFileKeyword.DOMAIN_SIZE + " " + extent.getX() + " " + extent.getY());
            printWriter.println(FVInputFileKeyword.DOMAIN_ORIGIN + " " + origin.getX() + " " + origin.getY());
            break;
        case 3:
            printWriter.println(FVInputFileKeyword.MESH_SIZE + " " + isize.getX() + " " + isize.getY() + " " + isize.getZ());
            printWriter.println(FVInputFileKeyword.DOMAIN_SIZE + " " + extent.getX() + " " + extent.getY() + " " + extent.getZ());
            printWriter.println(FVInputFileKeyword.DOMAIN_ORIGIN + " " + origin.getX() + " " + origin.getY() + " " + origin.getZ());
            break;
    }
    List<CompartmentSubDomain> featureList = new ArrayList<CompartmentSubDomain>();
    Enumeration<SubDomain> enum1 = simulation.getMathDescription().getSubDomains();
    while (enum1.hasMoreElements()) {
        SubDomain sd = enum1.nextElement();
        if (sd instanceof CompartmentSubDomain) {
            featureList.add((CompartmentSubDomain) sd);
        }
    }
    int numFeatures = featureList.size();
    CompartmentSubDomain[] features = featureList.toArray(new CompartmentSubDomain[0]);
    int[] phases = new int[numFeatures];
    Arrays.fill(phases, -1);
    phases[numFeatures - 1] = 0;
    int[] numAssigned = new int[] { 1 };
    assignPhases(features, numFeatures - 1, phases, numAssigned);
    Map<String, Integer> subDomainPhaseMap = new HashMap<String, Integer>();
    for (int i = 0; i < phases.length; ++i) {
        if (phases[i] == -1) {
            throw new SolverException("Failed to assign a phase to CompartmentSubdomain '" + features[i].getName() + "'. It might be caused by too coarsh a mesh.");
        }
        subDomainPhaseMap.put(features[i].getName(), phases[i]);
    }
    SubVolume[] subVolumes = geometrySpec.getSubVolumes();
    if (geometrySpec.hasImage()) {
        Geometry geometry = (Geometry) BeanUtils.cloneSerializable(simulation.getMathDescription().getGeometry());
        Geometry simGeometry = geometry;
        VCImage img = geometry.getGeometrySpec().getImage();
        int factor = Math.max(Math.max(img.getNumX(), img.getNumY()), img.getNumZ()) < 512 ? 2 : 1;
        ISize distanceMapMeshSize = new ISize(img.getNumX() * factor, img.getNumY() * factor, img.getNumZ() * factor);
        Vect3d deltaX = null;
        boolean bCellCentered = false;
        double dx = 0.5;
        double dy = 0.5;
        double dz = 0.5;
        int Nx = distanceMapMeshSize.getX();
        int Ny = distanceMapMeshSize.getY();
        int Nz = distanceMapMeshSize.getZ();
        if (dimension == 2) {
            // pad the 2D image with itself in order to obtain a 3D image used to compute the distance map
            // because the distance map algorithm is 3D only (using distance to triangles)
            byte[] oldPixels = img.getPixels();
            byte[] newPixels = new byte[oldPixels.length * 3];
            System.arraycopy(oldPixels, 0, newPixels, 0, oldPixels.length);
            System.arraycopy(oldPixels, 0, newPixels, oldPixels.length, oldPixels.length);
            System.arraycopy(oldPixels, 0, newPixels, oldPixels.length * 2, oldPixels.length);
            double distX = geometry.getExtent().getX() / img.getNumX();
            double distY = geometry.getExtent().getY() / img.getNumY();
            // we set the distance on the z axis to something that makes sense
            double distZ = Math.max(distX, distY);
            Extent newExtent = new Extent(geometry.getExtent().getX(), geometry.getExtent().getY(), distZ * 3);
            VCImage newImage = new VCImageUncompressed(null, newPixels, newExtent, img.getNumX(), img.getNumY(), 3);
            // copy the pixel classes too
            ArrayList<VCPixelClass> newPixelClasses = new ArrayList<VCPixelClass>();
            for (VCPixelClass origPixelClass : geometry.getGeometrySpec().getImage().getPixelClasses()) {
                SubVolume origSubvolume = geometry.getGeometrySpec().getImageSubVolumeFromPixelValue(origPixelClass.getPixel());
                newPixelClasses.add(new VCPixelClass(null, origSubvolume.getName(), origPixelClass.getPixel()));
            }
            newImage.setPixelClasses(newPixelClasses.toArray(new VCPixelClass[newPixelClasses.size()]));
            simGeometry = new Geometry(geometry, newImage);
            Nz = 3;
        }
        GeometrySpec simGeometrySpec = simGeometry.getGeometrySpec();
        Extent simExtent = simGeometrySpec.getExtent();
        dx = simExtent.getX() / (Nx - 1);
        dy = simExtent.getY() / (Ny - 1);
        dz = simExtent.getZ() / (Nz - 1);
        if (Math.abs(dx - dy) > 0.1 * Math.max(dx, dy)) {
            dx = Math.min(dx, dy);
            dy = dx;
            Nx = (int) (simExtent.getX() / dx + 1);
            Ny = (int) (simExtent.getY() / dx + 1);
            if (dimension == 3) {
                dz = dx;
                Nz = (int) (simExtent.getZ() / dx + 1);
            }
        }
        deltaX = new Vect3d(dx, dy, dz);
        // one more point in each direction
        distanceMapMeshSize = new ISize(Nx + 1, Ny + 1, Nz + 1);
        Extent distanceMapExtent = new Extent(simExtent.getX() + dx, simExtent.getY() + dy, simExtent.getZ() + dz);
        simGeometrySpec.setExtent(distanceMapExtent);
        GeometrySurfaceDescription geoSurfaceDesc = simGeometry.getGeometrySurfaceDescription();
        geoSurfaceDesc.setVolumeSampleSize(distanceMapMeshSize);
        geoSurfaceDesc.updateAll();
        VCImage vcImage = RayCaster.sampleGeometry(simGeometry, distanceMapMeshSize, bCellCentered);
        SubvolumeSignedDistanceMap[] distanceMaps = DistanceMapGenerator.computeDistanceMaps(simGeometry, vcImage, bCellCentered);
        if (dimension == 2) {
            distanceMaps = DistanceMapGenerator.extractMiddleSlice(distanceMaps);
        }
        printWriter.println(FVInputFileKeyword.SUBDOMAINS + " " + simGeometrySpec.getNumSubVolumes() + " " + FVInputFileKeyword.DISTANCE_MAP);
        for (int i = 0; i < subVolumes.length; i++) {
            File distanceMapFile = new File(workingDirectory, getSimulationTask().getSimulationJobID() + "_" + subVolumes[i].getName() + DISTANCE_MAP_FILE_EXTENSION);
            writeDistanceMapFile(deltaX, distanceMaps[i], distanceMapFile);
            int phase = subDomainPhaseMap.get(subVolumes[i].getName());
            printWriter.println(subVolumes[i].getName() + " " + phase + " " + distanceMapFile.getAbsolutePath());
        }
    } else {
        printWriter.println(FVInputFileKeyword.SUBDOMAINS + " " + geometrySpec.getNumSubVolumes());
        Expression[] rvachevExps = convertAnalyticGeometryToRvachevFunction(geometrySpec);
        for (int i = 0; i < subVolumes.length; i++) {
            if (subVolumes[i] instanceof AnalyticSubVolume) {
                String name = subVolumes[i].getName();
                int phase = subDomainPhaseMap.get(name);
                printWriter.println(name + " " + phase + " ");
                printWriter.println(FVInputFileKeyword.IF + " " + rvachevExps[i].infix() + ";");
                printWriter.println(FVInputFileKeyword.USER + " " + ((AnalyticSubVolume) subVolumes[i]).getExpression().infix() + ";");
            }
        }
    }
    printWriter.println(FVInputFileKeyword.MAX_BOX_SIZE + " " + chomboSolverSpec.getMaxBoxSize());
    printWriter.println(FVInputFileKeyword.FILL_RATIO + " " + chomboSolverSpec.getFillRatio());
    printWriter.println(FVInputFileKeyword.RELATIVE_TOLERANCE + " " + simulation.getSolverTaskDescription().getErrorTolerance().getRelativeErrorTolerance());
    printWriter.println(FVInputFileKeyword.SAVE_VCELL_OUTPUT + " " + chomboSolverSpec.isSaveVCellOutput());
    printWriter.println(FVInputFileKeyword.SAVE_CHOMBO_OUTPUT + " " + chomboSolverSpec.isSaveChomboOutput());
    printWriter.println(FVInputFileKeyword.ACTIVATE_FEATURE_UNDER_DEVELOPMENT + " " + chomboSolverSpec.isActivateFeatureUnderDevelopment());
    printWriter.println(FVInputFileKeyword.SMALL_VOLFRAC_THRESHOLD + " " + chomboSolverSpec.getSmallVolfracThreshold());
    printWriter.println(FVInputFileKeyword.BLOCK_FACTOR + " " + chomboSolverSpec.getBlockFactor());
    printWriter.println(FVInputFileKeyword.TAGS_GROW + " " + chomboSolverSpec.getTagsGrow());
    // Refinement
    int numLevels = chomboSolverSpec.getNumRefinementLevels();
    // Refinements #Levels ratio 1, ratio 2, etc
    printWriter.print(FVInputFileKeyword.REFINEMENTS + " " + (numLevels + 1));
    List<Integer> ratios = chomboSolverSpec.getRefineRatioList();
    for (int i : ratios) {
        printWriter.print(" " + i);
    }
    // write last refinement ratio, fake
    printWriter.println(" 2");
    // membrane rois
    List<RefinementRoi> memRios = chomboSolverSpec.getMembraneRefinementRois();
    printWriter.println(FVInputFileKeyword.REFINEMENT_ROIS + " " + RoiType.Membrane + " " + memRios.size());
    for (RefinementRoi roi : memRios) {
        if (roi.getRoiExpression() == null) {
            throw new SolverException("ROI expression cannot be null");
        }
        // level tagsGrow ROIexpression
        printWriter.println(roi.getLevel() + " " + roi.getRoiExpression().infix() + ";");
    }
    List<RefinementRoi> volRios = chomboSolverSpec.getVolumeRefinementRois();
    printWriter.println(FVInputFileKeyword.REFINEMENT_ROIS + " " + RoiType.Volume + " " + volRios.size());
    for (RefinementRoi roi : volRios) {
        if (roi.getRoiExpression() == null) {
            throw new SolverException("ROI expression cannot be null");
        }
        printWriter.println(roi.getLevel() + " " + roi.getRoiExpression().infix() + ";");
    }
    printWriter.println(FVInputFileKeyword.VIEW_LEVEL + " " + chomboSolverSpec.getViewLevel());
    printWriter.println(FVInputFileKeyword.CHOMBO_SPEC_END);
    printWriter.println();
}

Example 27 with ISize

use of org.vcell.util.ISize 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 28 with ISize

use of org.vcell.util.ISize in project vcell by virtualcell.

the class DataSetControllerImpl method evaluatePostProcessFunction.

private static DataProcessingOutputDataValues evaluatePostProcessFunction(DataOperationResults.DataProcessingOutputInfo dataProcessingOutputInfo, String[] postProcessSymbols, double[][][] postProcessData, DataIndexHelper dataIndexHelper, TimePointHelper timePointHelper, Expression flattenedBoundExpression, String varName) throws Exception {
    ISize iSize = dataProcessingOutputInfo.getVariableISize(postProcessSymbols[0]);
    VCImageUncompressed vcImage = new VCImageUncompressed(null, new byte[iSize.getXYZ()], new Extent(1, 1, 1), iSize.getX(), iSize.getY(), iSize.getZ());
    int dimension = 1 + (iSize.getY() > 1 ? 1 : 0) + (iSize.getZ() > 1 ? 1 : 0);
    RegionImage regionImage = new RegionImage(vcImage, dimension, dataProcessingOutputInfo.getVariableExtent(postProcessSymbols[0]), dataProcessingOutputInfo.getVariableOrigin(postProcessSymbols[0]), RegionImage.NO_SMOOTHING);
    CartesianMesh cartesianMesh = CartesianMesh.createSimpleCartesianMesh(dataProcessingOutputInfo.getVariableOrigin(postProcessSymbols[0]), dataProcessingOutputInfo.getVariableExtent(postProcessSymbols[0]), dataProcessingOutputInfo.getVariableISize(postProcessSymbols[0]), regionImage);
    double[] timePoints = null;
    if (timePointHelper.isAllTimePoints()) {
        timePoints = dataProcessingOutputInfo.getVariableTimePoints();
    } else {
        timePoints = timePointHelper.getTimePoints();
    }
    double[][] evaluatedValues = new double[timePoints.length][];
    int dataIndexCount = 0;
    ISize DATA_SIZE = dataProcessingOutputInfo.getVariableISize(postProcessSymbols[0]);
    int DATA_SIZE_XY = DATA_SIZE.getX() * DATA_SIZE.getY();
    if (dataIndexHelper.isAllDataIndexes()) {
        dataIndexCount = DATA_SIZE.getXYZ();
    } else if (dataIndexHelper.isSingleSlice()) {
        dataIndexCount = DATA_SIZE_XY;
    } else {
        dataIndexCount = dataIndexHelper.getDataIndexes().length;
    }
    double[] args = new double[TXYZ_OFFSET + postProcessSymbols.length];
    for (int t = 0; t < timePoints.length; t++) {
        evaluatedValues[t] = new double[dataIndexCount];
        args[0] = timePoints[t];
        for (int i = 0; i < dataIndexCount; i++) {
            Coordinate coord;
            if (dataIndexHelper.isAllDataIndexes()) {
                coord = cartesianMesh.getCoordinateFromVolumeIndex(i);
            } else if (dataIndexHelper.isSingleSlice()) {
                coord = cartesianMesh.getCoordinateFromVolumeIndex(dataIndexHelper.getSliceIndex() * DATA_SIZE_XY + i);
            } else {
                coord = cartesianMesh.getCoordinateFromVolumeIndex(dataIndexHelper.getDataIndexes()[i]);
            }
            args[1] = coord.getX();
            args[2] = coord.getY();
            args[3] = coord.getZ();
            for (int j = 0; j < postProcessSymbols.length; j++) {
                args[TXYZ_OFFSET + j] = postProcessData[j][t][i];
            }
            evaluatedValues[t][i] = flattenedBoundExpression.evaluateVector(args);
        // System.out.println("in="+args[4]+" out="+evaluatedValues[t][i]+" sin(in)="+Math.sin(args[4]));
        }
    }
    return new DataOperationResults.DataProcessingOutputDataValues(dataProcessingOutputInfo.getVCDataIdentifier(), varName, timePointHelper, dataIndexHelper, evaluatedValues);
}

Example 29 with ISize

use of org.vcell.util.ISize in project vcell by virtualcell.

the class ITextWriter method writeSimulation.

// container can be a chapter or a section of a chapter.
protected void writeSimulation(Section container, Simulation sim) throws DocumentException {
    if (sim == null) {
        return;
    }
    Section simSection = container.addSection(sim.getName(), container.numberDepth() + 1);
    writeMetadata(simSection, sim.getName(), sim.getDescription(), null, "Simulation ");
    // add overriden params
    Table overParamTable = null;
    MathOverrides mo = sim.getMathOverrides();
    if (mo != null) {
        String[] constants = mo.getOverridenConstantNames();
        for (int i = 0; i < constants.length; i++) {
            String actualStr = "", defStr = "";
            Expression tempExp = mo.getDefaultExpression(constants[i]);
            if (tempExp != null) {
                defStr = tempExp.infix();
            }
            if (mo.isScan(constants[i])) {
                actualStr = mo.getConstantArraySpec(constants[i]).toString();
            } else {
                tempExp = mo.getActualExpression(constants[i], 0);
                if (tempExp != null) {
                    actualStr = tempExp.infix();
                }
            }
            if (overParamTable == null) {
                overParamTable = getTable(3, 75, 1, 3, 3);
                overParamTable.setAlignment(Table.ALIGN_LEFT);
                overParamTable.addCell(createCell("Overriden Parameters", getBold(DEF_HEADER_FONT_SIZE), 3, 1, Element.ALIGN_CENTER, true));
                overParamTable.addCell(createHeaderCell("Name", getBold(), 1));
                overParamTable.addCell(createHeaderCell("Actual Value", getBold(), 1));
                overParamTable.addCell(createHeaderCell("Default Value", getBold(), 1));
            }
            overParamTable.addCell(createCell(constants[i], getFont()));
            overParamTable.addCell(createCell(actualStr, getFont()));
            overParamTable.addCell(createCell(defStr, getFont()));
        }
    }
    if (overParamTable != null) {
        simSection.add(overParamTable);
    }
    // add spatial details
    // sim.isSpatial();
    Table meshTable = null;
    MeshSpecification mesh = sim.getMeshSpecification();
    if (mesh != null) {
        Geometry geom = mesh.getGeometry();
        Extent extent = geom.getExtent();
        String extentStr = "(" + extent.getX() + ", " + extent.getY() + ", " + extent.getZ() + ")";
        ISize meshSize = mesh.getSamplingSize();
        String meshSizeStr = "(" + meshSize.getX() + ", " + meshSize.getY() + ", " + meshSize.getZ() + ")";
        meshTable = getTable(2, 75, 1, 3, 3);
        meshTable.setAlignment(Table.ALIGN_LEFT);
        meshTable.addCell(createCell("Geometry Setting", getBold(DEF_HEADER_FONT_SIZE), 2, 1, Element.ALIGN_CENTER, true));
        meshTable.addCell(createCell("Geometry Size (um)", getFont()));
        meshTable.addCell(createCell(extentStr, getFont()));
        meshTable.addCell(createCell("Mesh Size (elements)", getFont()));
        meshTable.addCell(createCell(meshSizeStr, getFont()));
    }
    if (meshTable != null) {
        simSection.add(meshTable);
    }
    // write advanced sim settings
    Table simAdvTable = null;
    SolverTaskDescription solverDesc = sim.getSolverTaskDescription();
    if (solverDesc != null) {
        String solverName = solverDesc.getSolverDescription().getDisplayLabel();
        simAdvTable = getTable(2, 75, 1, 3, 3);
        simAdvTable.setAlignment(Table.ALIGN_LEFT);
        simAdvTable.addCell(createCell("Advanced Settings", getBold(DEF_HEADER_FONT_SIZE), 2, 1, Element.ALIGN_CENTER, true));
        simAdvTable.addCell(createCell("Solver Name", getFont()));
        simAdvTable.addCell(createCell(solverName, getFont()));
        simAdvTable.addCell(createCell("Time Bounds - Starting", getFont()));
        simAdvTable.addCell(createCell("" + solverDesc.getTimeBounds().getStartingTime(), getFont()));
        simAdvTable.addCell(createCell("Time Bounds - Ending", getFont()));
        simAdvTable.addCell(createCell("" + solverDesc.getTimeBounds().getEndingTime(), getFont()));
        simAdvTable.addCell(createCell("Time Step - Min", getFont()));
        simAdvTable.addCell(createCell("" + solverDesc.getTimeStep().getMinimumTimeStep(), getFont()));
        simAdvTable.addCell(createCell("Time Step - Default", getFont()));
        simAdvTable.addCell(createCell("" + solverDesc.getTimeStep().getDefaultTimeStep(), getFont()));
        simAdvTable.addCell(createCell("Time Step - Max", getFont()));
        simAdvTable.addCell(createCell("" + solverDesc.getTimeStep().getMaximumTimeStep(), getFont()));
        ErrorTolerance et = solverDesc.getErrorTolerance();
        if (et != null) {
            simAdvTable.addCell(createCell("Error Tolerance - Absolute", getFont()));
            simAdvTable.addCell(createCell("" + et.getAbsoluteErrorTolerance(), getFont()));
            simAdvTable.addCell(createCell("Error Tolerance - Relative", getFont()));
            simAdvTable.addCell(createCell("" + et.getRelativeErrorTolerance(), getFont()));
        }
        OutputTimeSpec ots = solverDesc.getOutputTimeSpec();
        if (ots.isDefault()) {
            simAdvTable.addCell(createCell("Keep Every", getFont()));
            simAdvTable.addCell(createCell("" + ((DefaultOutputTimeSpec) ots).getKeepEvery(), getFont()));
            simAdvTable.addCell(createCell("Keep At Most", getFont()));
            simAdvTable.addCell(createCell("" + ((DefaultOutputTimeSpec) ots).getKeepAtMost(), getFont()));
        } else if (ots.isUniform()) {
            simAdvTable.addCell(createCell("Output Time Step", getFont()));
            simAdvTable.addCell(createCell("" + ((UniformOutputTimeSpec) ots).getOutputTimeStep(), getFont()));
        } else if (ots.isExplicit()) {
            simAdvTable.addCell(createCell("Output Time Points", getFont()));
            simAdvTable.addCell(createCell("" + ((ExplicitOutputTimeSpec) ots).toCommaSeperatedOneLineOfString(), getFont()));
        }
        simAdvTable.addCell(createCell("Use Symbolic Jacobian (T/F)", getFont()));
        simAdvTable.addCell(createCell((solverDesc.getUseSymbolicJacobian() ? " T " : " F "), getFont()));
        Constant sp = solverDesc.getSensitivityParameter();
        if (sp != null) {
            simAdvTable.addCell(createCell("Sensitivity Analysis Param", getFont()));
            simAdvTable.addCell(createCell(sp.getName(), getFont()));
        }
    }
    if (simAdvTable != null) {
        simSection.add(simAdvTable);
    }
}

Example 30 with ISize

use of org.vcell.util.ISize in project vcell by virtualcell.

the class MovingBoundarySolver method getResampledGeometry.

/*
@Override
protected String[] getMathExecutableCommand() {
	String exeSuffix = System.getProperty(PropertyLoader.exesuffixProperty); // ".exe";
	String baseName = "MovingBoundary" ;
	File exeFile = new File(getSaveDirectory(), baseName + exeSuffix);
	return new String[] { exeFile.getAbsolutePath() };
}
*/
public Geometry getResampledGeometry() throws SolverException {
    if (resampledGeometry == null) {
        // clone and resample geometry
        try {
            resampledGeometry = (Geometry) BeanUtils.cloneSerializable(simTask.getSimulation().getMathDescription().getGeometry());
            GeometrySurfaceDescription geoSurfaceDesc = resampledGeometry.getGeometrySurfaceDescription();
            ISize newSize = simTask.getSimulation().getMeshSpecification().getSamplingSize();
            geoSurfaceDesc.setVolumeSampleSize(newSize);
            geoSurfaceDesc.updateAll();
        } catch (Exception e) {
            e.printStackTrace();
            throw new SolverException(e.getMessage());
        }
    }
    return resampledGeometry;
}