Examples with GeometrySurfaceDescription cbit.vcell.geometry.surface.GeometrySurfaceDescription used on opensource projects

Example 6 with GeometrySurfaceDescription

use of cbit.vcell.geometry.surface.GeometrySurfaceDescription in project vcell by virtualcell.

the class XmlReader method getGeometry.

/**
 * This method returns a Geometry object from a XML representation.
 * Creation date: (4/26/2001 12:12:18 PM)
 * @return cbit.vcell.geometry.Geometry
 * @param param org.jdom.Element
 * @exception cbit.vcell.xml.XmlParseException The exception description.
 */
public Geometry getGeometry(Element param) throws XmlParseException {
    // Get the Extent object
    Extent newextent = getExtent(param.getChild(XMLTags.ExtentTag, vcNamespace));
    // Get VCimage information
    VCImage newimage = null;
    if (param.getChild(XMLTags.ImageTag, vcNamespace) != null) {
        try {
            newimage = getVCImage(param.getChild(XMLTags.ImageTag, vcNamespace), newextent);
        } catch (Throwable e) {
            e.printStackTrace();
            throw new XmlParseException(e);
        }
    }
    // Get attributes
    String name = unMangle(param.getAttributeValue(XMLTags.NameAttrTag));
    int newdimension = Integer.parseInt(param.getAttributeValue(XMLTags.DimensionAttrTag));
    // Get Version
    Version version = getVersion(param.getChild(XMLTags.VersionTag, vcNamespace));
    // Try to construct the geometry upon four different cases
    Geometry newgeometry = null;
    if (version != null && newimage != null) {
        newgeometry = new Geometry(version, newimage);
    } else if (version != null) {
        newgeometry = new Geometry(version, newdimension);
    } else if (newimage != null) {
        newgeometry = new Geometry(name, newimage);
    } else {
        newgeometry = new Geometry(name, newdimension);
    }
    // set attributes
    try {
        if (!newgeometry.getName().equalsIgnoreCase(name)) {
            newgeometry.setName(name);
        }
        // String annotation = param.getAttributeValue(XMLTags.AnnotationAttrTag);
        // if (annotation!=null) {
        // newgeometry.setDescription( unMangle(annotation) );
        // }
        // Add annotation
        String annotation = param.getChildText(XMLTags.AnnotationTag, vcNamespace);
        if (annotation != null && annotation.length() > 0) {
            newgeometry.setDescription(unMangle(annotation));
        }
    } catch (java.beans.PropertyVetoException e) {
        e.printStackTrace();
        throw new XmlParseException("A PropertyVetoException occurred when setting the name " + name + " to a Geometry object!", e);
    }
    // Add the Extent
    try {
        newgeometry.getGeometrySpec().setExtent(newextent);
    } catch (java.beans.PropertyVetoException e) {
        e.printStackTrace();
        throw new XmlParseException("A PropertyVetoException occurred while trying to set the Extent for the Geometry " + name, e);
    }
    // Add the Origin
    newgeometry.getGeometrySpec().setOrigin(getOrigin(param.getChild(XMLTags.OriginTag, vcNamespace)));
    // Add the SubVolumes
    List<Element> children = param.getChildren(XMLTags.SubVolumeTag, vcNamespace);
    SubVolume[] newsubvolumes = new SubVolume[children.size()];
    int subvolumeCounter = 0;
    for (Element child : children) {
        newsubvolumes[subvolumeCounter] = getSubVolume(child);
        subvolumeCounter++;
    }
    try {
        newgeometry.getGeometrySpec().setSubVolumes(newsubvolumes);
    } catch (java.beans.PropertyVetoException e) {
        e.printStackTrace();
        throw new XmlParseException("A PropertyVetoException was generated when ading the subvolumes to the Geometry " + name, e);
    }
    if (newgeometry.getDimension() > 0) {
        // Add SurfaceClasses
        List<Element> surfaceClassChildren = param.getChildren(XMLTags.SurfaceClassTag, vcNamespace);
        SurfaceClass[] newSurfaceClassArr = new SurfaceClass[surfaceClassChildren.size()];
        int surfClassCounter = 0;
        for (Element surfClassChild : surfaceClassChildren) {
            newSurfaceClassArr[surfClassCounter] = getSurfaceClass(surfClassChild, newgeometry);
            surfClassCounter++;
        }
        try {
            newgeometry.getGeometrySurfaceDescription().setSurfaceClasses(newSurfaceClassArr);
        } catch (java.beans.PropertyVetoException e) {
            e.printStackTrace();
            throw new XmlParseException("A PropertyVetoException was generated when ading the subvolumes to the Geometry " + name, e);
        }
    }
    // read Filaments (if any)
    Iterator<Element> iterator = param.getChildren(XMLTags.FilamentTag, vcNamespace).iterator();
    while (iterator.hasNext()) {
        Element tempElement = iterator.next();
        String filname = unMangle(tempElement.getAttributeValue(XMLTags.NameAttrTag));
        Iterator<Element> curveiterator = tempElement.getChildren().iterator();
        while (curveiterator.hasNext()) {
            ControlPointCurve curve = getControlPointCurve(curveiterator.next());
            newgeometry.getGeometrySpec().getFilamentGroup().addCurve(filname, curve);
        }
    }
    // read Surface description (if any)
    Element sd = param.getChild(XMLTags.SurfaceDescriptionTag, vcNamespace);
    if (sd != null) {
        GeometrySurfaceDescription dummy = getGeometrySurfaceDescription(sd, newgeometry);
    }
    try {
        newgeometry.precomputeAll(new GeometryThumbnailImageFactoryAWT(), false, false);
    } catch (GeometryException e) {
        e.printStackTrace(System.out);
    } catch (ImageException e) {
        e.printStackTrace(System.out);
    } catch (ExpressionException e) {
        e.printStackTrace(System.out);
    }
    return newgeometry;
}

Example 7 with GeometrySurfaceDescription

use of cbit.vcell.geometry.surface.GeometrySurfaceDescription in project vcell by virtualcell.

the class Xmlproducer method getXML.

/**
 * This method returns a XML representation of a Geometry object.
 * Creation date: (2/28/2001 5:51:36 PM)
 * @return Element
 * @param param cbit.vcell.geometry.Geometry
 */
public Element getXML(Geometry param) throws XmlParseException {
    Element geometry = new Element(XMLTags.GeometryTag);
    // Add attributes
    String name = param.getName();
    geometry.setAttribute(XMLTags.NameAttrTag, mangle(name));
    geometry.setAttribute(XMLTags.DimensionAttrTag, String.valueOf(param.getDimension()));
    // add Annotation
    if (param.getDescription() != null && param.getDescription().length() > 0) {
        Element annotationElem = new Element(XMLTags.AnnotationTag);
        annotationElem.setText(mangle(param.getDescription()));
        geometry.addContent(annotationElem);
    }
    // add sub-elements
    // Create extent subelement
    geometry.addContent(getXML(param.getExtent()));
    // Add Origin subelement
    Element origin = new Element(XMLTags.OriginTag);
    // Add Origin attributes
    origin.setAttribute(XMLTags.XAttrTag, String.valueOf(param.getOrigin().getX()));
    origin.setAttribute(XMLTags.YAttrTag, String.valueOf(param.getOrigin().getY()));
    origin.setAttribute(XMLTags.ZAttrTag, String.valueOf(param.getOrigin().getZ()));
    geometry.addContent(origin);
    // Add Image	subelement if there is.
    if (param.getGeometrySpec().getImage() != null) {
        try {
            geometry.addContent(getXML(param.getGeometrySpec().getImage()));
        } catch (XmlParseException e) {
            e.printStackTrace();
            throw new XmlParseException("A problem occurred when trying to get the Image for the geometry " + name, e);
        }
    }
    // Add subvolumes elements
    for (int i = 0; i < param.getGeometrySpec().getSubVolumes().length; i++) {
        geometry.addContent(getXML(param.getGeometrySpec().getSubVolumes(i)));
    }
    if (param.getDimension() > 0 && param.getGeometrySurfaceDescription() != null && param.getGeometrySurfaceDescription().getSurfaceClasses() != null) {
        // Add SurfaceClass elements
        for (int i = 0; i < param.getGeometrySurfaceDescription().getSurfaceClasses().length; i++) {
            geometry.addContent(getXML(param.getGeometrySurfaceDescription().getSurfaceClasses()[i]));
        }
    }
    // Add Filaments
    if (param.getDimension() > 0) {
        Filament[] filarray = param.getGeometrySpec().getFilamentGroup().getFilaments();
        for (int i = 0; i < filarray.length; i++) {
            geometry.addContent(getXML(filarray[i]));
        }
    }
    // Add Surface descriptions, if any
    GeometrySurfaceDescription gsd = param.getGeometrySurfaceDescription();
    if (gsd != null) {
        geometry.addContent(getXML(gsd));
    }
    // Add Metadata(version) if there is one
    if (param.getVersion() != null) {
        geometry.addContent(getXML(param.getVersion(), param));
    }
    return geometry;
}

Example 8 with GeometrySurfaceDescription

use of cbit.vcell.geometry.surface.GeometrySurfaceDescription in project vcell by virtualcell.

the class TestingFrameworkWindowManager method addTestCases.

/**
 * Insert the method's description here.
 * Creation date: (4/10/2003 11:27:32 AM)
 * @param testCase cbit.vcell.numericstestingframework.TestCase
 */
public String addTestCases(final TestSuiteInfoNew tsInfo, final TestCaseNew[] testCaseArray, int regrRefFlag, ClientTaskStatusSupport pp) {
    if (tsInfo == null) {
        throw new IllegalArgumentException("TestSuiteInfo cannot be null");
    }
    if (testCaseArray == null || testCaseArray.length == 0) {
        throw new IllegalArgumentException("TestCases cannot be null / empty");
    }
    // make modifiable list
    List<TestCaseNew> testCases = new ArrayList<>(Arrays.asList(testCaseArray));
    StringBuffer errors = new StringBuffer();
    // When a testCase (mathmodel/biomodel) is added to a testSuite, a new version of the mathModel/biomodel should be created.
    // Also, the simulations in the original mathmodel/biomodel should be rid of their parent simulation reference.
    pp.setMessage("Getting testSuite");
    pp.setProgress(1);
    TestSuiteNew testSuite = null;
    try {
        testSuite = getRequestManager().getDocumentManager().getTestSuite(tsInfo.getTSKey());
    } catch (Throwable e) {
        throw new RuntimeException("couldn't get test suite " + tsInfo.getTSID() + "\n" + e.getClass().getName() + " mesg=" + e.getMessage() + "\n");
    }
    if (testSuite != null && testSuite.getTSInfoNew().isLocked()) {
        throw new RuntimeException("Cannot addTestCases to locked table");
    }
    if (testSuite != null) {
        // Saving BioModels
        TestCaseNew[] existingTestCases = testSuite.getTestCases();
        java.util.HashMap<KeyValue, BioModel> bioModelHashMap = new java.util.HashMap<KeyValue, BioModel>();
        // if(existingTestCases != null){
        // Find BioModels, Using the same BM reference for sibling Applications
        int pcounter = 0;
        // use iterator to allow removal of test case from collection if exception
        Iterator<TestCaseNew> iter = testCases.iterator();
        while (iter.hasNext()) {
            TestCaseNew testCase = iter.next();
            pp.setProgress(Math.max(1, ((int) ((pcounter++ / (double) (testCases.size() * 3)) * 100))));
            pp.setMessage("Checking " + testCase.getVersion().getName());
            try {
                if (testCase instanceof TestCaseNewBioModel) {
                    TestCaseNewBioModel bioTestCase = (TestCaseNewBioModel) testCase;
                    // 
                    if (bioModelHashMap.get(bioTestCase.getBioModelInfo().getVersion().getVersionKey()) == null) {
                        pp.setMessage("Getting BM " + testCase.getVersion().getName());
                        BioModel bioModel = getRequestManager().getDocumentManager().getBioModel(bioTestCase.getBioModelInfo().getVersion().getVersionKey());
                        if (!bioModel.getVersion().getOwner().equals(getRequestManager().getDocumentManager().getUser())) {
                            throw new Exception("BioModel does not belong to VCELLTESTACCOUNT, cannot proceed with test!");
                        }
                        // 
                        // if biomodel already exists in same testsuite, then use this BioModel edition
                        // 
                        BioModel newBioModel = null;
                        if (existingTestCases != null) {
                            for (int j = 0; newBioModel == null && j < existingTestCases.length; j++) {
                                if (existingTestCases[j] instanceof TestCaseNewBioModel) {
                                    TestCaseNewBioModel existingTestCaseBioModel = (TestCaseNewBioModel) existingTestCases[j];
                                    // 
                                    if (existingTestCaseBioModel.getBioModelInfo().getVersion().getBranchID().equals(bioTestCase.getBioModelInfo().getVersion().getBranchID())) {
                                        // 
                                        if (existingTestCaseBioModel.getBioModelInfo().getVersion().getVersionKey().equals(bioTestCase.getBioModelInfo().getVersion().getVersionKey())) {
                                            // 
                                            // same, store this "unchanged" in bioModelHashMap
                                            // 
                                            newBioModel = bioModel;
                                        } else {
                                            // 
                                            throw new Exception("can't add new test case using (" + bioTestCase.getBioModelInfo().getVersion().getName() + " " + bioTestCase.getBioModelInfo().getVersion().getDate() + ")\n" + "a test case already exists with different edition of same BioModel dated " + existingTestCaseBioModel.getBioModelInfo().getVersion().getDate());
                                        }
                                    }
                                }
                            }
                        }
                        if (newBioModel == null) {
                            pp.setMessage("Saving BM " + testCase.getVersion().getName());
                            // 
                            // some older models have membrane voltage variable names which are not unique
                            // (e.g. membranes 'pm' and 'nm' both have membrane voltage variables named 'Voltage_Membrane0')
                            // 
                            // if this is the case, we will try to repair the conflict (for math testing purposes only) by renaming the voltage variables to their default values.
                            // 
                            // Ordinarily, the conflict will be identified as an "Error" issue and the user will be prompted to repair before saving or math generation.
                            // 
                            bioModel.refreshDependencies();
                            boolean bFoundIdentifierConflictUponLoading = hasDuplicateIdentifiers(bioModel);
                            if (bFoundIdentifierConflictUponLoading) {
                                // 
                                // look for two MembraneVoltage instances with same variable name, rename all
                                // 
                                HashSet<String> membraneVoltageVarNames = new HashSet<String>();
                                ArrayList<MembraneVoltage> membraneVoltageVars = new ArrayList<MembraneVoltage>();
                                for (Structure struct : bioModel.getModel().getStructures()) {
                                    if (struct instanceof Membrane) {
                                        MembraneVoltage membraneVoltage = ((Membrane) struct).getMembraneVoltage();
                                        if (membraneVoltage != null) {
                                            membraneVoltageVars.add(membraneVoltage);
                                            membraneVoltageVarNames.add(membraneVoltage.getName());
                                        }
                                    }
                                }
                                if (membraneVoltageVars.size() != membraneVoltageVarNames.size()) {
                                    // rename them all to the default names
                                    for (MembraneVoltage memVoltage : membraneVoltageVars) {
                                        memVoltage.setName(Membrane.getDefaultMembraneVoltageName(memVoltage.getMembrane().getName()));
                                    }
                                }
                            }
                            SimulationContext[] simContexts = bioModel.getSimulationContexts();
                            for (int j = 0; j < simContexts.length; j++) {
                                simContexts[j].clearVersion();
                                GeometrySurfaceDescription gsd = simContexts[j].getGeometry().getGeometrySurfaceDescription();
                                if (gsd != null) {
                                    GeometricRegion[] grArr = gsd.getGeometricRegions();
                                    if (grArr == null) {
                                        gsd.updateAll();
                                    }
                                }
                                MathMapping mathMapping = simContexts[j].createNewMathMapping();
                                // for older models that do not have absolute compartment sizes set, but have relative sizes (SVR/VF); or if there is only one compartment with size not set,
                                // compute absolute compartment sizes using relative sizes and assuming a default value of '1' for one of the compartments.
                                // Otherwise, the math generation will fail, since for the relaxed topology (VCell 5.3 and later) absolute compartment sizes are required.
                                GeometryContext gc = simContexts[j].getGeometryContext();
                                if (simContexts[j].getGeometry().getDimension() == 0 && ((gc.isAllSizeSpecifiedNull() && !gc.isAllVolFracAndSurfVolSpecifiedNull()) || (gc.getModel().getStructures().length == 1 && gc.isAllSizeSpecifiedNull()))) {
                                    // choose the first structure in model and set its size to '1'.
                                    Structure struct = simContexts[j].getModel().getStructure(0);
                                    double structSize = 1.0;
                                    StructureSizeSolver.updateAbsoluteStructureSizes(simContexts[j], struct, structSize, struct.getStructureSize().getUnitDefinition());
                                }
                                simContexts[j].setMathDescription(mathMapping.getMathDescription());
                            }
                            Simulation[] sims = bioModel.getSimulations();
                            String[] simNames = new String[sims.length];
                            for (int j = 0; j < sims.length; j++) {
                                // prevents parent simulation (from the original mathmodel) reference connection
                                // Otherwise it will refer to data from previous (parent) simulation.
                                sims[j].clearVersion();
                                simNames[j] = sims[j].getName();
                            // if(sims[j].getSolverTaskDescription().getSolverDescription().equals(SolverDescription.FiniteVolume)){
                            // sims[j].getSolverTaskDescription().setSolverDescription(SolverDescription.FiniteVolumeStandalone);
                            // }
                            }
                            newBioModel = getRequestManager().getDocumentManager().save(bioModel, simNames);
                        }
                        bioModelHashMap.put(bioTestCase.getBioModelInfo().getVersion().getVersionKey(), newBioModel);
                    }
                }
            } catch (Throwable e) {
                String identifier = testCase.getVersion() != null ? "Name=" + testCase.getVersion().getName() : "TCKey=" + testCase.getTCKey();
                if (lg.isInfoEnabled()) {
                    lg.info(identifier, e);
                }
                errors.append("Error collecting BioModel for TestCase " + identifier + '\n' + e.getClass().getName() + " " + e.getMessage() + '\n');
                // remove to avoid further processing attempts
                iter.remove();
            }
        }
        // }
        // then process each BioModelTestCase individually
        // if(bioModelHashMap != null){
        pcounter = 0;
        for (TestCaseNew testCase : testCases) {
            pp.setProgress(Math.max(1, ((int) ((pcounter++ / (double) (testCases.size() * 3)) * 100))));
            pp.setMessage("Checking " + testCase.getVersion().getName());
            try {
                AddTestCasesOP testCaseOP = null;
                if (testCase instanceof TestCaseNewBioModel) {
                    pp.setMessage("Processing BM " + testCase.getVersion().getName());
                    TestCaseNewBioModel bioTestCase = (TestCaseNewBioModel) testCase;
                    BioModel newBioModel = (BioModel) bioModelHashMap.get(bioTestCase.getBioModelInfo().getVersion().getVersionKey());
                    if (newBioModel == null) {
                        throw new Exception("BioModel not found");
                    }
                    SimulationContext simContext = null;
                    for (int j = 0; j < newBioModel.getSimulationContexts().length; j++) {
                        if (newBioModel.getSimulationContext(j).getName().equals(bioTestCase.getSimContextName())) {
                            simContext = newBioModel.getSimulationContext(j);
                        }
                    }
                    Simulation[] newSimulations = simContext.getSimulations();
                    AddTestCriteriaOPBioModel[] testCriteriaOPs = new AddTestCriteriaOPBioModel[newSimulations.length];
                    for (int j = 0; j < newSimulations.length; j++) {
                        TestCriteriaNewBioModel tcritOrigForSimName = null;
                        for (int k = 0; bioTestCase.getTestCriterias() != null && k < bioTestCase.getTestCriterias().length; k += 1) {
                            if (bioTestCase.getTestCriterias()[k].getSimInfo().getName().equals(newSimulations[j].getName())) {
                                tcritOrigForSimName = (TestCriteriaNewBioModel) bioTestCase.getTestCriterias()[k];
                                break;
                            }
                        }
                        KeyValue regressionBioModelKey = null;
                        KeyValue regressionBioModelSimKey = null;
                        if (bioTestCase.getType().equals(TestCaseNew.REGRESSION)) {
                            if (regrRefFlag == TestingFrameworkWindowManager.COPY_REGRREF) {
                                regressionBioModelKey = (tcritOrigForSimName != null && tcritOrigForSimName.getRegressionBioModelInfo() != null ? tcritOrigForSimName.getRegressionBioModelInfo().getVersion().getVersionKey() : null);
                                regressionBioModelSimKey = (tcritOrigForSimName != null && tcritOrigForSimName.getRegressionSimInfo() != null ? tcritOrigForSimName.getRegressionSimInfo().getVersion().getVersionKey() : null);
                            } else if (regrRefFlag == TestingFrameworkWindowManager.ASSIGNORIGINAL_REGRREF) {
                                regressionBioModelKey = (tcritOrigForSimName != null ? bioTestCase.getBioModelInfo().getVersion().getVersionKey() : null);
                                regressionBioModelSimKey = (tcritOrigForSimName != null ? tcritOrigForSimName.getSimInfo().getVersion().getVersionKey() : null);
                            } else if (regrRefFlag == TestingFrameworkWindowManager.ASSIGNNEW_REGRREF) {
                                regressionBioModelKey = newBioModel.getVersion().getVersionKey();
                                regressionBioModelSimKey = newSimulations[j].getVersion().getVersionKey();
                            } else {
                                throw new IllegalArgumentException(this.getClass().getName() + ".addTestCases(...) BIOMODEL Unknown Regression Operation Flag");
                            }
                        }
                        testCriteriaOPs[j] = new AddTestCriteriaOPBioModel(testCase.getTCKey(), newSimulations[j].getVersion().getVersionKey(), regressionBioModelKey, regressionBioModelSimKey, (tcritOrigForSimName != null ? tcritOrigForSimName.getMaxAbsError() : new Double(1e-16)), (tcritOrigForSimName != null ? tcritOrigForSimName.getMaxRelError() : new Double(1e-9)), null);
                    }
                    testCaseOP = new AddTestCasesOPBioModel(new BigDecimal(tsInfo.getTSKey().toString()), newBioModel.getVersion().getVersionKey(), simContext.getKey(), bioTestCase.getType(), bioTestCase.getAnnotation(), testCriteriaOPs);
                    getRequestManager().getDocumentManager().doTestSuiteOP(testCaseOP);
                }
            } catch (Throwable e) {
                errors.append("Error processing Biomodel for TestCase " + (testCase.getVersion() != null ? "Name=" + testCase.getVersion().getName() : "TCKey=" + testCase.getTCKey()) + "\n" + e.getClass().getName() + " " + e.getMessage() + "\n");
            }
        }
        // }
        // Process MathModels
        pcounter = 0;
        for (TestCaseNew testCase : testCases) {
            pp.setProgress(Math.max(1, ((int) ((pcounter++ / (double) (testCases.size() * 3)) * 100))));
            pp.setMessage("Checking " + testCase.getVersion().getName());
            try {
                AddTestCasesOP testCaseOP = null;
                if (testCase instanceof TestCaseNewMathModel) {
                    TestCaseNewMathModel mathTestCase = (TestCaseNewMathModel) testCase;
                    pp.setMessage("Getting MathModel " + testCase.getVersion().getName());
                    MathModel mathModel = getRequestManager().getDocumentManager().getMathModel(mathTestCase.getMathModelInfo().getVersion().getVersionKey());
                    if (!mathModel.getVersion().getOwner().equals(getRequestManager().getDocumentManager().getUser())) {
                        throw new Exception("MathModel does not belong to VCELLTESTACCOUNT, cannot proceed with test!");
                    }
                    Simulation[] sims = mathModel.getSimulations();
                    String[] simNames = new String[sims.length];
                    for (int j = 0; j < sims.length; j++) {
                        // prevents parent simulation (from the original mathmodel) reference connection
                        // Otherwise it will refer to data from previous (parent) simulation.
                        sims[j].clearVersion();
                        simNames[j] = sims[j].getName();
                    // if(sims[j].getSolverTaskDescription().getSolverDescription().equals(SolverDescription.FiniteVolume)){
                    // sims[j].getSolverTaskDescription().setSolverDescription(SolverDescription.FiniteVolumeStandalone);
                    // }
                    }
                    pp.setMessage("Saving MathModel " + testCase.getVersion().getName());
                    MathModel newMathModel = getRequestManager().getDocumentManager().save(mathModel, simNames);
                    Simulation[] newSimulations = newMathModel.getSimulations();
                    AddTestCriteriaOPMathModel[] testCriteriaOPs = new AddTestCriteriaOPMathModel[newSimulations.length];
                    for (int j = 0; j < newSimulations.length; j++) {
                        TestCriteriaNewMathModel tcritOrigForSimName = null;
                        for (int k = 0; mathTestCase.getTestCriterias() != null && k < mathTestCase.getTestCriterias().length; k += 1) {
                            if (mathTestCase.getTestCriterias()[k].getSimInfo().getName().equals(newSimulations[j].getName())) {
                                tcritOrigForSimName = (TestCriteriaNewMathModel) mathTestCase.getTestCriterias()[k];
                                break;
                            }
                        }
                        KeyValue regressionMathModelKey = null;
                        KeyValue regressionMathModelSimKey = null;
                        if (mathTestCase.getType().equals(TestCaseNew.REGRESSION)) {
                            if (regrRefFlag == TestingFrameworkWindowManager.COPY_REGRREF) {
                                regressionMathModelKey = (tcritOrigForSimName != null && tcritOrigForSimName.getRegressionMathModelInfo() != null ? tcritOrigForSimName.getRegressionMathModelInfo().getVersion().getVersionKey() : null);
                                regressionMathModelSimKey = (tcritOrigForSimName != null && tcritOrigForSimName.getRegressionSimInfo() != null ? tcritOrigForSimName.getRegressionSimInfo().getVersion().getVersionKey() : null);
                            } else if (regrRefFlag == TestingFrameworkWindowManager.ASSIGNORIGINAL_REGRREF) {
                                regressionMathModelKey = (tcritOrigForSimName != null ? mathTestCase.getMathModelInfo().getVersion().getVersionKey() : null);
                                regressionMathModelSimKey = (tcritOrigForSimName != null ? tcritOrigForSimName.getSimInfo().getVersion().getVersionKey() : null);
                            } else if (regrRefFlag == TestingFrameworkWindowManager.ASSIGNNEW_REGRREF) {
                                regressionMathModelKey = newMathModel.getVersion().getVersionKey();
                                regressionMathModelSimKey = newSimulations[j].getVersion().getVersionKey();
                            } else {
                                throw new IllegalArgumentException(this.getClass().getName() + ".addTestCases(...) MATHMODEL Unknown Regression Operation Flag");
                            }
                        }
                        testCriteriaOPs[j] = new AddTestCriteriaOPMathModel(testCase.getTCKey(), newSimulations[j].getVersion().getVersionKey(), regressionMathModelKey, regressionMathModelSimKey, (tcritOrigForSimName != null ? tcritOrigForSimName.getMaxAbsError() : new Double(1e-16)), (tcritOrigForSimName != null ? tcritOrigForSimName.getMaxRelError() : new Double(1e-9)), null);
                    }
                    testCaseOP = new AddTestCasesOPMathModel(new BigDecimal(tsInfo.getTSKey().toString()), newMathModel.getVersion().getVersionKey(), mathTestCase.getType(), mathTestCase.getAnnotation(), testCriteriaOPs);
                    getRequestManager().getDocumentManager().doTestSuiteOP(testCaseOP);
                }
            } catch (Throwable e) {
                errors.append("Error processing MathModel for TestCase " + (testCase.getVersion() != null ? "Name=" + testCase.getVersion().getName() : "TCKey=" + testCase.getTCKey()) + "\n" + e.getClass().getName() + " " + e.getMessage() + "\n");
            }
        }
    }
    if (errors.length() > 0) {
        return errors.toString();
    }
    return null;
}

Example 9 with GeometrySurfaceDescription

use of cbit.vcell.geometry.surface.GeometrySurfaceDescription in project vcell by virtualcell.

the class CartesianMesh method createSimpleCartesianMesh.

public static CartesianMesh createSimpleCartesianMesh(Geometry geometry, Map<Polygon, MembraneElement> polygonMembaneElementMap) throws IOException, MathFormatException {
    GeometrySurfaceDescription geometrySurfaceDescription = geometry.getGeometrySurfaceDescription();
    RegionImage regionImage = geometrySurfaceDescription.getRegionImage();
    ISize iSize = new ISize(regionImage.getNumX(), regionImage.getNumY(), regionImage.getNumZ());
    CartesianMesh mesh = createSimpleCartesianMesh(geometry.getOrigin(), geometry.getExtent(), iSize, regionImage);
    GeometricRegion[] geometricRegions = geometrySurfaceDescription.getGeometricRegions();
    if (geometricRegions != null) {
        int memRegionCount = 0;
        for (int i = 0; i < geometricRegions.length; i++) {
            if (geometricRegions[i] instanceof VolumeGeometricRegion) {
                VolumeGeometricRegion vgr = (VolumeGeometricRegion) geometricRegions[i];
                mesh.meshRegionInfo.mapVolumeRegionToSubvolume(vgr.getRegionID(), vgr.getSubVolume().getHandle(), vgr.getSize(), vgr.getName());
            } else if (geometricRegions[i] instanceof SurfaceGeometricRegion) {
                SurfaceGeometricRegion sgr = (SurfaceGeometricRegion) geometricRegions[i];
                GeometricRegion[] neighbors = sgr.getAdjacentGeometricRegions();
                VolumeGeometricRegion insideRegion = (VolumeGeometricRegion) neighbors[0];
                VolumeGeometricRegion outsideRegion = (VolumeGeometricRegion) neighbors[1];
                mesh.meshRegionInfo.mapMembraneRegionToVolumeRegion(memRegionCount, insideRegion.getRegionID(), outsideRegion.getRegionID(), sgr.getSize());
                memRegionCount++;
            }
        }
    }
    SurfaceCollection surfaceCollection = geometrySurfaceDescription.getSurfaceCollection();
    if (surfaceCollection != null) {
        int numMembraneElement = surfaceCollection.getTotalPolygonCount();
        mesh.membraneElements = new MembraneElement[numMembraneElement];
        boolean bMembraneEdgeNeighborsAvailable = surfaceCollection.getMembraneEdgeNeighbors() != null && surfaceCollection.getMembraneEdgeNeighbors().length == surfaceCollection.getSurfaceCount();
        int[] membraneElementMapMembraneRegion = new int[numMembraneElement];
        mesh.meshRegionInfo.mapMembraneElementsToMembraneRegions(membraneElementMapMembraneRegion);
        int memCount = 0;
        // original values when no membraneedgeneighbors
        int[] membraneNeighbors = new int[] { 0, 0, 0, 0 };
        for (int i = 0; i < surfaceCollection.getSurfaceCount(); i++) {
            Surface surface = surfaceCollection.getSurfaces(i);
            bMembraneEdgeNeighborsAvailable = bMembraneEdgeNeighborsAvailable && surfaceCollection.getMembraneEdgeNeighbors()[i].length == surface.getPolygonCount();
            for (int j = 0; j < surface.getPolygonCount(); j++) {
                if (bMembraneEdgeNeighborsAvailable) {
                    membraneNeighbors = new int[MembraneElement.MAX_POSSIBLE_NEIGHBORS];
                    Arrays.fill(membraneNeighbors, MembraneElement.NEIGHBOR_UNDEFINED);
                    for (int k = 0; k < surfaceCollection.getMembraneEdgeNeighbors()[i][j].size(); k++) {
                        membraneNeighbors[k] = surfaceCollection.getMembraneEdgeNeighbors()[i][j].get(k).getMasterPolygonIndex();
                    }
                }
                Quadrilateral polygon = (Quadrilateral) surface.getPolygons(j);
                int volNeighbor1Region = regionImage.getRegionInfoFromOffset(polygon.getVolIndexNeighbor1()).getRegionIndex();
                int volNeighbor2Region = regionImage.getRegionInfoFromOffset(polygon.getVolIndexNeighbor2()).getRegionIndex();
                HashMap<Integer, int[]> map = mesh.getMembraneRegionMapSubvolumesInOut();
                Set<Entry<Integer, int[]>> entries = map.entrySet();
                for (Entry<Integer, int[]> entry : entries) {
                    int[] volNeighbors = entry.getValue();
                    if (volNeighbors[0] == volNeighbor1Region && volNeighbors[1] == volNeighbor2Region || volNeighbors[1] == volNeighbor1Region && volNeighbors[0] == volNeighbor2Region) {
                        membraneElementMapMembraneRegion[memCount] = entry.getKey();
                        break;
                    }
                }
                mesh.membraneElements[memCount] = new MembraneElement(memCount, polygon.getVolIndexNeighbor1(), polygon.getVolIndexNeighbor2(), membraneNeighbors[0], membraneNeighbors[1], membraneNeighbors[2], membraneNeighbors[3], MembraneElement.AREA_UNDEFINED, 0, 0, 0, 0, 0, 0);
                if (polygonMembaneElementMap != null) {
                    polygonMembaneElementMap.put(polygon, mesh.membraneElements[memCount]);
                }
                memCount++;
            }
        }
    }
    return mesh;
}

Example 10 with GeometrySurfaceDescription

use of cbit.vcell.geometry.surface.GeometrySurfaceDescription in project vcell by virtualcell.

the class FVSolverStandalone method getResampledGeometry.

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;
}