Examples with SimpleReaction cbit.vcell.model.SimpleReaction used on opensource projects

Example 46 with SimpleReaction

use of cbit.vcell.model.SimpleReaction in project vcell by virtualcell.

the class PathwayMapping method createReactionStep.

/*
	 * for reaction:
	 * 1. annotate the selected vcell object using linked pathway conversion
	 * 2. add non-existing speciesContexts from linked pathway conversion
	 * 3. add links between relative vcell objects and pathway objects
	 * Questions:
	 * - how to deal with the case that the reaction is existing in the model?
	 * 		+ add it in no matter what? 
	 * 				(this is the version we have now: 
	 * 					add the duplicated reactions in without name changing, 
	 * 				 	all duplicated reactions share the same participant objects)
	 *      + just modify the existing one?
	 */
private void createReactionStep(BioModel bioModel, Process process, ReactionStep reactionStep, RelationshipObject relationshipObject, ArrayList<ConversionTableRow> participants, boolean addSubunits) throws Exception {
    if (reactionStep == null || bioModel == null || bioModel.getRelationshipModel() == null || participants.size() < 1) {
        return;
    }
    ArrayList<ReactionParticipant> rplist = new ArrayList<ReactionParticipant>();
    // create and add reaction participants to list
    for (ConversionTableRow ctr : participants) {
        if (ctr.getBioPaxObject() instanceof Conversion)
            continue;
        int stoich = ctr.stoich().intValue();
        String safeId = getSafetyName(ctr.id());
        // get speciesContext object based on its name
        // if the speciesContext is not existed, create a new one
        createSpeciesContextFromTableRow(bioModel, (PhysicalEntity) ctr.getBioPaxObject(), ctr.stoich(), ctr.id(), ctr.location(), addSubunits);
        // add the existed speciesContext objects or new speciesContext objects to reaction participant list
        if (ctr.participantType().equals("Reactant")) {
            if (reactionStep instanceof SimpleReaction || reactionStep instanceof FluxReaction) {
                rplist.add(new Reactant(null, reactionStep, bioModel.getModel().getSpeciesContext(safeId), stoich));
            }
        } else if (ctr.participantType().equals("Product")) {
            if (reactionStep instanceof SimpleReaction || reactionStep instanceof FluxReaction) {
                rplist.add(new Product(null, reactionStep, bioModel.getModel().getSpeciesContext(safeId), stoich));
            }
        }
    // we do not add catalysts
    }
    ReactionParticipant[] rpArray = rplist.toArray(new ReactionParticipant[0]);
    reactionStep.setReactionParticipants(rpArray);
    // add Controls to the reaction
    Set<PhysicalEntity> controllers = process.getControllers();
    for (ConversionTableRow ctr : participants) {
        if (controllers.contains(ctr.getBioPaxObject())) {
            if (ctr.participantType().equals("Catalyst")) {
                String safeId = getSafetyName(ctr.id());
                /* 
					 * using addCatalyst() to create catalyst in reaction: 
					 * this function cannot allow an object to be catalyst and (reactant/product) in the same reaction
					 */
                // reactionStep.addCatalyst(bioModel.getModel().getSpeciesContext(safeId));
                /* However, in pathway interaction object, an physicalEntity can be catalyst and (reactant/product) in the same reaction
					 * So we just call create catalyst for the reaction no matter what rolls the object is playing in the reaction
					 * Switch back to the addCatalyst() function when it is necessary, but exceptions make be reported for some reactions
					 */
                reactionStep.addReactionParticipant(new Catalyst(null, reactionStep, bioModel.getModel().getSpeciesContext(safeId)));
            } else if (ctr.participantType().equals("Control")) {
                String safeId = getSafetyName(ctr.id());
                // reactionStep.addCatalyst(bioModel.getModel().getSpeciesContext(safeId));
                reactionStep.addReactionParticipant(new Catalyst(null, reactionStep, bioModel.getModel().getSpeciesContext(safeId)));
            }
        }
    }
}

Example 47 with SimpleReaction

use of cbit.vcell.model.SimpleReaction in project vcell by virtualcell.

the class VCReactionProxy method factory.

/**
 * get proxy for Reaction type
 * @param reaction not null
 * @return proxy
 * @throws ProgrammingException unknown type
 */
public static VCReactionProxy factory(ReactionStep reaction) {
    VCAssert.assertValid(reaction);
    SimpleReaction sr = BeanUtils.downcast(SimpleReaction.class, reaction);
    if (sr != null) {
        return new Simple(sr);
    }
    FluxReaction fr = BeanUtils.downcast(FluxReaction.class, reaction);
    if (fr != null) {
        return new Flux(fr);
    }
    throw new ProgrammingException("Unknown reaction type " + ExecutionTrace.justClassName(reaction));
}

Example 48 with SimpleReaction

use of cbit.vcell.model.SimpleReaction in project vcell by virtualcell.

the class Generate2DSimBioModelOp method generateBioModel.

public BioModel generateBioModel(Extent extent, ROI cellROI_2D, double[] timeStamps, Integer indexFirstPostbleach, double primaryDiffusionRate, double primaryFraction, double bleachMonitorRate, Double secondaryDiffusionRate, double secondaryFraction, Double bindingSiteConcentration, double bindingOnRate, double bindingOffRate, String extracellularName, String cytosolName, User owner, KeyValue simKey) throws PropertyVetoException, ExpressionException, ModelException, GeometryException, ImageException, MappingException, MathException, MatrixException {
    if (owner == null) {
        throw new IllegalArgumentException("Owner is not defined");
    }
    double df = primaryDiffusionRate;
    double ff = primaryFraction;
    double bwmRate = bleachMonitorRate;
    double dc = 0.0;
    double fc = 0.0;
    if (secondaryDiffusionRate != null) {
        dc = secondaryDiffusionRate;
        fc = secondaryFraction;
    }
    double bs = 0.0;
    double onRate = 0.0;
    double offRate = 0.0;
    if (bindingSiteConcentration != null) {
        bs = bindingSiteConcentration;
        onRate = bindingOnRate;
        offRate = bindingOffRate;
    }
    // immobile fraction
    double fimm = 1 - ff - fc;
    if (fimm < epsilon && fimm > (0 - epsilon)) {
        fimm = 0;
    }
    if (fimm < (1 + epsilon) && fimm > (1 - epsilon)) {
        fimm = 1;
    }
    int startingIndexForRecovery = indexFirstPostbleach;
    TimeBounds timeBounds = new TimeBounds(0.0, timeStamps[timeStamps.length - 1] - timeStamps[startingIndexForRecovery]);
    double timeStepVal = timeStamps[startingIndexForRecovery + 1] - timeStamps[startingIndexForRecovery];
    ROI cellROI = cellROI_2D;
    int numX = cellROI.getISize().getX();
    int numY = cellROI.getISize().getY();
    int numZ = cellROI.getISize().getZ();
    short[] shortPixels = cellROI.getRoiImages()[0].getPixels();
    byte[] bytePixels = new byte[numX * numY * numZ];
    final byte EXTRACELLULAR_PIXVAL = 0;
    final byte CYTOSOL_PIXVAL = 1;
    for (int i = 0; i < bytePixels.length; i++) {
        if (shortPixels[i] != 0) {
            bytePixels[i] = CYTOSOL_PIXVAL;
        }
    }
    VCImage maskImage;
    try {
        maskImage = new VCImageUncompressed(null, bytePixels, extent, numX, numY, numZ);
    } catch (ImageException e) {
        e.printStackTrace();
        throw new RuntimeException("failed to create mask image for geometry");
    }
    Geometry geometry = new Geometry("geometry", maskImage);
    if (geometry.getGeometrySpec().getNumSubVolumes() != 2) {
        throw new IllegalArgumentException("Cell ROI has no ExtraCellular.");
    }
    String EXTRACELLULAR_NAME = extracellularName;
    String CYTOSOL_NAME = cytosolName;
    int subVolume0PixVal = ((ImageSubVolume) geometry.getGeometrySpec().getSubVolume(0)).getPixelValue();
    geometry.getGeometrySpec().getSubVolume(0).setName((subVolume0PixVal == EXTRACELLULAR_PIXVAL ? EXTRACELLULAR_NAME : CYTOSOL_NAME));
    int subVolume1PixVal = ((ImageSubVolume) geometry.getGeometrySpec().getSubVolume(1)).getPixelValue();
    geometry.getGeometrySpec().getSubVolume(1).setName((subVolume1PixVal == CYTOSOL_PIXVAL ? CYTOSOL_NAME : EXTRACELLULAR_NAME));
    geometry.getGeometrySurfaceDescription().updateAll();
    BioModel bioModel = new BioModel(null);
    bioModel.setName("unnamed");
    Model model = new Model("model");
    bioModel.setModel(model);
    model.addFeature(EXTRACELLULAR_NAME);
    Feature extracellular = (Feature) model.getStructure(EXTRACELLULAR_NAME);
    model.addFeature(CYTOSOL_NAME);
    Feature cytosol = (Feature) model.getStructure(CYTOSOL_NAME);
    // Membrane mem = model.addMembrane(EXTRACELLULAR_CYTOSOL_MEM_NAME);
    // model.getStructureTopology().setInsideFeature(mem, cytosol);
    // model.getStructureTopology().setOutsideFeature(mem, extracellular);
    String roiDataName = ROI_EXTDATA_NAME;
    final int SPECIES_COUNT = 4;
    final int FREE_SPECIES_INDEX = 0;
    final int BS_SPECIES_INDEX = 1;
    final int COMPLEX_SPECIES_INDEX = 2;
    final int IMMOBILE_SPECIES_INDEX = 3;
    Expression[] diffusionConstants = null;
    Species[] species = null;
    SpeciesContext[] speciesContexts = null;
    Expression[] initialConditions = null;
    diffusionConstants = new Expression[SPECIES_COUNT];
    species = new Species[SPECIES_COUNT];
    speciesContexts = new SpeciesContext[SPECIES_COUNT];
    initialConditions = new Expression[SPECIES_COUNT];
    // total initial condition
    FieldFunctionArguments postBleach_first = new FieldFunctionArguments(roiDataName, "postbleach_first", new Expression(0), VariableType.VOLUME);
    FieldFunctionArguments prebleach_avg = new FieldFunctionArguments(roiDataName, "prebleach_avg", new Expression(0), VariableType.VOLUME);
    Expression expPostBleach_first = new Expression(postBleach_first.infix());
    Expression expPreBleach_avg = new Expression(prebleach_avg.infix());
    Expression totalIniCondition = Expression.div(expPostBleach_first, expPreBleach_avg);
    // Free Species
    diffusionConstants[FREE_SPECIES_INDEX] = new Expression(df);
    species[FREE_SPECIES_INDEX] = new Species(SPECIES_NAME_PREFIX_MOBILE, "Mobile bleachable species");
    speciesContexts[FREE_SPECIES_INDEX] = new SpeciesContext(null, species[FREE_SPECIES_INDEX].getCommonName(), species[FREE_SPECIES_INDEX], cytosol);
    initialConditions[FREE_SPECIES_INDEX] = Expression.mult(new Expression(ff), totalIniCondition);
    // Immobile Species (No diffusion)
    // Set very small diffusion rate on immobile to force evaluation as state variable (instead of FieldData function)
    // If left as a function errors occur because functions involving FieldData require a database connection
    final String IMMOBILE_DIFFUSION_KLUDGE = "1e-14";
    diffusionConstants[IMMOBILE_SPECIES_INDEX] = new Expression(IMMOBILE_DIFFUSION_KLUDGE);
    species[IMMOBILE_SPECIES_INDEX] = new Species(SPECIES_NAME_PREFIX_IMMOBILE, "Immobile bleachable species");
    speciesContexts[IMMOBILE_SPECIES_INDEX] = new SpeciesContext(null, species[IMMOBILE_SPECIES_INDEX].getCommonName(), species[IMMOBILE_SPECIES_INDEX], cytosol);
    initialConditions[IMMOBILE_SPECIES_INDEX] = Expression.mult(new Expression(fimm), totalIniCondition);
    // BS Species
    diffusionConstants[BS_SPECIES_INDEX] = new Expression(IMMOBILE_DIFFUSION_KLUDGE);
    species[BS_SPECIES_INDEX] = new Species(SPECIES_NAME_PREFIX_BINDING_SITE, "Binding Site species");
    speciesContexts[BS_SPECIES_INDEX] = new SpeciesContext(null, species[BS_SPECIES_INDEX].getCommonName(), species[BS_SPECIES_INDEX], cytosol);
    initialConditions[BS_SPECIES_INDEX] = Expression.mult(new Expression(bs), totalIniCondition);
    // Complex species
    diffusionConstants[COMPLEX_SPECIES_INDEX] = new Expression(dc);
    species[COMPLEX_SPECIES_INDEX] = new Species(SPECIES_NAME_PREFIX_SLOW_MOBILE, "Slower mobile bleachable species");
    speciesContexts[COMPLEX_SPECIES_INDEX] = new SpeciesContext(null, species[COMPLEX_SPECIES_INDEX].getCommonName(), species[COMPLEX_SPECIES_INDEX], cytosol);
    initialConditions[COMPLEX_SPECIES_INDEX] = Expression.mult(new Expression(fc), totalIniCondition);
    // add reactions to species if there is bleachWhileMonitoring rate.
    for (int i = 0; i < initialConditions.length; i++) {
        model.addSpecies(species[i]);
        model.addSpeciesContext(speciesContexts[i]);
        // reaction with BMW rate, which should not be applied to binding site
        if (!(species[i].getCommonName().equals(SPECIES_NAME_PREFIX_BINDING_SITE))) {
            SimpleReaction simpleReaction = new SimpleReaction(model, cytosol, speciesContexts[i].getName() + "_bleach", true);
            model.addReactionStep(simpleReaction);
            simpleReaction.addReactant(speciesContexts[i], 1);
            MassActionKinetics massActionKinetics = new MassActionKinetics(simpleReaction);
            simpleReaction.setKinetics(massActionKinetics);
            KineticsParameter kforward = massActionKinetics.getForwardRateParameter();
            simpleReaction.getKinetics().setParameterValue(kforward, new Expression(new Double(bwmRate)));
        }
    }
    // add the binding reaction: F + BS <-> C
    SimpleReaction simpleReaction2 = new SimpleReaction(model, cytosol, "reac_binding", true);
    model.addReactionStep(simpleReaction2);
    simpleReaction2.addReactant(speciesContexts[FREE_SPECIES_INDEX], 1);
    simpleReaction2.addReactant(speciesContexts[BS_SPECIES_INDEX], 1);
    simpleReaction2.addProduct(speciesContexts[COMPLEX_SPECIES_INDEX], 1);
    MassActionKinetics massActionKinetics = new MassActionKinetics(simpleReaction2);
    simpleReaction2.setKinetics(massActionKinetics);
    KineticsParameter kforward = massActionKinetics.getForwardRateParameter();
    KineticsParameter kreverse = massActionKinetics.getReverseRateParameter();
    simpleReaction2.getKinetics().setParameterValue(kforward, new Expression(new Double(onRate)));
    simpleReaction2.getKinetics().setParameterValue(kreverse, new Expression(new Double(offRate)));
    // create simulation context
    SimulationContext simContext = new SimulationContext(bioModel.getModel(), geometry);
    bioModel.addSimulationContext(simContext);
    FeatureMapping cytosolFeatureMapping = (FeatureMapping) simContext.getGeometryContext().getStructureMapping(cytosol);
    FeatureMapping extracellularFeatureMapping = (FeatureMapping) simContext.getGeometryContext().getStructureMapping(extracellular);
    SubVolume cytSubVolume = geometry.getGeometrySpec().getSubVolume(CYTOSOL_NAME);
    SubVolume exSubVolume = geometry.getGeometrySpec().getSubVolume(EXTRACELLULAR_NAME);
    SurfaceClass pmSurfaceClass = geometry.getGeometrySurfaceDescription().getSurfaceClass(exSubVolume, cytSubVolume);
    cytosolFeatureMapping.setGeometryClass(cytSubVolume);
    extracellularFeatureMapping.setGeometryClass(exSubVolume);
    cytosolFeatureMapping.getUnitSizeParameter().setExpression(new Expression(1.0));
    extracellularFeatureMapping.getUnitSizeParameter().setExpression(new Expression(1.0));
    for (int i = 0; i < speciesContexts.length; i++) {
        SpeciesContextSpec scs = simContext.getReactionContext().getSpeciesContextSpec(speciesContexts[i]);
        scs.getInitialConditionParameter().setExpression(initialConditions[i]);
        scs.getDiffusionParameter().setExpression(diffusionConstants[i]);
    }
    MathMapping mathMapping = simContext.createNewMathMapping();
    MathDescription mathDesc = mathMapping.getMathDescription();
    // Add total fluorescence as function of mobile(optional: and slower mobile) and immobile fractions
    mathDesc.addVariable(new Function(SPECIES_NAME_PREFIX_COMBINED, new Expression(species[FREE_SPECIES_INDEX].getCommonName() + "+" + species[COMPLEX_SPECIES_INDEX].getCommonName() + "+" + species[IMMOBILE_SPECIES_INDEX].getCommonName()), null));
    simContext.setMathDescription(mathDesc);
    SimulationVersion simVersion = new SimulationVersion(simKey, "sim1", owner, new GroupAccessNone(), new KeyValue("0"), new BigDecimal(0), new Date(), VersionFlag.Current, "", null);
    Simulation newSimulation = new Simulation(simVersion, mathDesc);
    simContext.addSimulation(newSimulation);
    newSimulation.getSolverTaskDescription().setTimeBounds(timeBounds);
    newSimulation.getMeshSpecification().setSamplingSize(cellROI.getISize());
    // newSimulation.getSolverTaskDescription().setTimeStep(timeStep); // Sundials doesn't need time step
    newSimulation.getSolverTaskDescription().setSolverDescription(SolverDescription.SundialsPDE);
    // use exp time step as output time spec
    newSimulation.getSolverTaskDescription().setOutputTimeSpec(new UniformOutputTimeSpec(timeStepVal));
    return bioModel;
}

Example 49 with SimpleReaction

use of cbit.vcell.model.SimpleReaction in project vcell by virtualcell.

the class ReactStepTable method getReactionStep.

/**
 * This method was created in VisualAge.
 * @return cbit.vcell.model.ReactionParticipant
 * @param rset java.sql.ResultSet
 */
public ReactionStep getReactionStep(Structure structure, Model model, KeyValue rsKey, java.sql.ResultSet rset, DatabaseSyntax dbSyntax) throws java.sql.SQLException, DataAccessException {
    KeyValue key = rsKey;
    if (rset.wasNull()) {
        key = null;
    }
    String reactType = rset.getString(ReactStepTable.table.reactType.toString());
    String reactionStepName = null;
    String nameString = rset.getString(ReactStepTable.table.name.toString());
    if (rset.wasNull()) {
        nameString = null;
    }
    if (nameString != null) {
        reactionStepName = TokenMangler.getSQLRestoredString(nameString);
    }
    ReactionStep rs = null;
    try {
        if (reactType.equals(ReactStepTable.REACTTYPE_FLUX_REVERSIBLE)) {
            rs = new FluxReaction(model, (Membrane) structure, key, reactionStepName, true);
        } else if (reactType.equals(ReactStepTable.REACTTYPE_FLUX_IRREVERSIBLE)) {
            rs = new FluxReaction(model, (Membrane) structure, key, reactionStepName, false);
        } else if (reactType.equals(ReactStepTable.REACTTYPE_SIMPLE_REVERSIBLE)) {
            rs = new SimpleReaction(model, structure, key, reactionStepName, true);
        } else if (reactType.equals(ReactStepTable.REACTTYPE_SIMPLE_IRREVERSIBLE)) {
            rs = new SimpleReaction(model, structure, key, reactionStepName, false);
        }
    } catch (java.beans.PropertyVetoException e) {
        e.printStackTrace(System.out);
        throw new DataAccessException(e.getMessage());
    }
    // 
    // if valence is stored as a 'null', it was an error (previous models were updated administratively).
    // 
    int valenceValue = rset.getInt(ReactStepTable.table.chargeValence.toString());
    if (rset.wasNull()) {
        throw new DataAccessException("unexpected null for chargeValence");
    }
    // 
    // New procedure for getting kinetics
    // 
    String kinetics_vcml = DbDriver.varchar2_CLOB_get(rset, ReactStepTable.table.kineticsSmall, ReactStepTable.table.kineticsLarge, dbSyntax);
    if (kinetics_vcml == null || kinetics_vcml.length() == 0) {
        throw new DataAccessException("no data stored for kinetics");
    }
    // This isn't needed?
    // if (kinetics_vcml.endsWith(";}\n")){
    // StringBuffer buffer = new StringBuffer(kinetics_vcml.substring(0,kinetics_vcml.length()-2));
    // buffer.append("\n}\n");
    // kinetics_vcml = buffer.toString();
    // }
    org.vcell.util.CommentStringTokenizer tokens = new org.vcell.util.CommentStringTokenizer(kinetics_vcml);
    Kinetics kinetics = null;
    try {
        String token = tokens.nextToken();
        if (!token.equalsIgnoreCase(VCMODL.Kinetics)) {
            throw new DataAccessException("expected " + VCMODL.Kinetics);
        }
        token = tokens.nextToken();
        KineticsDescription kineticsDescription = KineticsDescription.fromVCMLKineticsName(token);
        if (kineticsDescription != null) {
            kinetics = kineticsDescription.createKinetics(rs);
        } else {
            throw new DataAccessException("expected valid kinetics type, read '" + token + "'");
        }
        kinetics.fromTokens(kinetics_vcml);
        // 
        // for debug purposes only, remove when unresolvedParameters are ok ... when globals exist
        // 
        // if (kinetics.getUnresolvedParameters().length!=0){
        // System.out.println("<<<WARNING>>> ReactStepTable.getReactionStep(key="+rsKey+") has "+kinetics.getUnresolvedParameters().length+" UnresolvedParameters");
        // for (int i = 0; i < kinetics.getUnresolvedParameters().length; i++){
        // System.out.println(">>>>>>>>>>>>> UnresolvedParameter["+i+"] = "+kinetics.getUnresolvedParameters()[i].toString());
        // }
        // }
        KineticsParameter chargeValenceParameter = kinetics.getChargeValenceParameter();
        if (chargeValenceParameter != null) {
            chargeValenceParameter.setExpression(new cbit.vcell.parser.Expression(valenceValue));
        }
    } catch (Exception e) {
        lg.error(e.getMessage(), e);
        throw new DataAccessException(e.getMessage());
    }
    rs.setKinetics(kinetics);
    // 
    // if physicsOptions is stored as a 'null', it was an error (previous models were updated administratively).
    // 
    int physicsOptionsValue = rset.getInt(ReactStepTable.table.physicsOptions.toString());
    if (rset.wasNull()) {
        throw new DataAccessException("unexpected null for physicsOptions");
    }
    try {
        rs.setPhysicsOptions(physicsOptionsValue);
    } catch (java.beans.PropertyVetoException e) {
        e.printStackTrace(System.out);
    }
    String annot = rset.getString(ReactStepTable.table.annotation.getUnqualifiedColName());
    if (!rset.wasNull()) {
    // annot = TokenMangler.getSQLRestoredString(annot);
    // rs.setAnnotation(annot);
    }
    return rs;
}