Ejemplo n.º 1
0
  virtual void fire(){

    E0 = getVariableReference( "E0" );
    Real PO2 = E0.getVariable()->getValue();
    //    theCurrentTime = getStepper()->getCurrentTime();   

    Real i = trunc( getStepper()->getCurrentTime() / 5.5 );
    theCalcTime = getStepper()->getCurrentTime() - 5.5 * i;
 

    if (0 < theCalcTime <=0.36)
	  PO2 = 186.1111 * theCalcTime + 30;

    else if(theCalcTime <= 2.55)
	  PO2 = 97;


    else if(theCalcTime < 5.5)
	  PO2 = 60 - 32 * (theCalcTime - 2.57)/(0.15 + (theCalcTime - 2.57));


    //    else if(theCalcTime == 5.5)
    //      {
	////      theCalcTime = 0;
    //	i= i+1;
    //      }

    //    std::cout << "i: " <<  i << std::endl;
    //   std::cout << "theCalcTime: " <<  theCalcTime << std::endl;

    E0.getVariable()->setValue( PO2 ); 

  }
Ejemplo n.º 2
0
  void fire()
  {
    if( theLastTime < 0.0 )
      {
	return;
      }

    Real aCurrentTime( getStepper()->getCurrentTime() );

    Real aNextTime( theLastTime + Interval );
    
    if( aNextTime >= Duration )
      {
	theLastTime = -1;

	P0.setValue( 1e-20 * getSuperSystem()->getSizeN_A() );
	return;
      }					


    Real aTimeDifference( aCurrentTime - theLastTime );
    Real aDecay( aTimeDifference * DecayFactor / Interval );
    
    P0.setValue( Impulse * getSuperSystem()->getSizeN_A() 
		 / ( aDecay + 1 ) );
    
    if( aTimeDifference >= Interval )
      {
	theLastTime += Interval;
      }
  }
Ejemplo n.º 3
0
void System::preinitialize()
{
    // no need to call subsystems' initialize() -- the Model does this
    if ( !theStepper )
    {
        theStepper = theModel->getStepper( theStepperID );
        theStepper->registerSystem( this );
    }

    //
    // Set Process::theStepper.
    // 
    for ( ProcessMap::const_iterator i( theProcessMap.begin() );
          i != theProcessMap.end() ; ++i )
    {
        Process* aProcess( i->second );

        if( !aProcess->getStepper() )
        {
            aProcess->setStepper( getStepper() );
        }
    }

    configureSizeVariable();
}
void MoleculePopulateProcess::populateUniformSparse(Species* aSpecies)
{
  Comp* aComp(aSpecies->getComp());
  if(!aSpecies->getIsPopulated())
    {
      if(UniformRadiusX == 1 && UniformRadiusY == 1 && UniformRadiusZ == 1 &&
         !OriginX && !OriginY && !OriginZ)
        {
          unsigned int aSize(aSpecies->getPopulateMoleculeSize());
          int availableVoxelSize(aComp->coords.size());
          for(unsigned int j(0); j != aSize; ++j)
            {
              Voxel* aVoxel;
              do
                {
                  aVoxel = theSpatiocyteStepper->coord2voxel(
                     aComp->coords[gsl_rng_uniform_int(
                                getStepper()->getRng(), availableVoxelSize)]);
                }
              while(aVoxel->id != aComp->vacantID);
              aSpecies->addMolecule(aVoxel);
            }
        }
      else
        { 
          populateUniformRanged(aSpecies);
        }
      aSpecies->setIsPopulated();
    }
}
Ejemplo n.º 5
0
void Process::initialize()
{
    if( !getStepper() )
    {
        THROW_EXCEPTION_INSIDE( InitializationFailed,
                                "No stepper is connected with [" +
                                asString() + "]." );
    }
}
 virtual void fire()
   {
     int col(gsl_rng_uniform_int(getStepper()->getRng(),
                                 theComp->maxCol-theComp->minCol-4));
     col += theComp->minCol;
     theSpatiocyteStepper->growCompartment(theComp, Axis, col);
     theTime += theStepInterval;
     thePriorityQueue->moveTop();
   }
Ejemplo n.º 7
0
void Model::deleteStepper( String const& anID )
{
    Stepper* aStepper( getStepper( anID ) );

    if ( !aStepper->getProcessVector().empty() )
    {
        THROW_EXCEPTION( IllegalOperation,
                "Stepper [" + anID + "] is relied on by one or more processes" );
    }

    aStepper->detach();
}
 virtual void initialize()
   {
     if(isInitialized)
       {
         return;
       }
     isInitialized = true;
     Process::initialize();
     theSpatiocyteStepper = dynamic_cast<SpatiocyteStepper*>(getStepper());
     theSortedVariableReferences.resize(theVariableReferenceVector.size());
     for(VariableReferenceVector::iterator
         i(theVariableReferenceVector.begin());
         i != theVariableReferenceVector.end(); ++i)
       {
         theSortedVariableReferences[(*i).getEllipsisNumber()] = *i; 
       }
     for(VariableReferenceVector::iterator
         i(theSortedVariableReferences.begin());
         i != theSortedVariableReferences.end(); ++i)
       {
         Variable* aVariable((*i).getVariable()); 
         // if Name is HD, it is a homogeneously distributed species.
         // only create Species for immobile or diffusing species
         if(aVariable->getName() != "HD")
           {
             Species* aSpecies(theSpatiocyteStepper->addSpecies(aVariable));
             theProcessSpecies.push_back(aSpecies);
           }
         if((*i).getCoefficient() > 0)
           {
             thePositiveVariableReferences.push_back(*i);
           }
         else if((*i).getCoefficient() < 0)
           {
             theNegativeVariableReferences.push_back(*i);
           }
         else
           {
             theZeroVariableReferences.push_back(*i);
           }
       }
   }
void PolymerizationProcess::removeContPoint(Subunit* aSubunit,  Point* aPoint)
{
  if(aSubunit->contPoints.size() == 1)
    {
      --aSubunit->contPointSize[0];
      if(!aSubunit->contPointSize[0])
        {
          aSubunit->contPoints.clear();
          aSubunit->contPointSize.clear();
        }
      return;
    }
  //If the size of contPoints is more than 1:
  else
    { 
      for(unsigned int i(0); i != aSubunit->contPoints.size(); ++i)
        {
          if(getDistance(&aSubunit->contPoints[i], aPoint) < 0.1)
            { 
              --aSubunit->contPointSize[i];
              //If the size of the continuous point is zero, we need to remove
              //the point from the contPoints, and update the contPointSize
              //list size:
              if(!aSubunit->contPointSize[i])
                {
                  //Remove the continuous point:
                  aSubunit->contPoints[i] = aSubunit->contPoints.back();
                  aSubunit->contPoints.pop_back();
                  //Update the size:
                  aSubunit->contPointSize[i] = aSubunit->contPointSize.back();
                  aSubunit->contPointSize.pop_back();
                }
              return;
            }
        }
    }
  std::cout << "error in remove contPoint at time:" << getStepper()->getCurrentTime() << std::endl;
}
 virtual double getInterval()
   {
     return getPropensity()*
       (-log(gsl_rng_uniform_pos(getStepper()->getRng())));
   }
Ejemplo n.º 11
0
 virtual void fire()
 {
     setFlux( gsl_ran_poisson( getStepper()->getRng(), getPropensity() ) );
 }
void MoleculePopulateProcess::populateUniformRanged(Species* aSpecies)
{
  Comp* aComp(aSpecies->getComp());
  double delta(0);
  // Increase the compartment dimensions by delta if it is a surface 
  // compartment:
  if(aComp->dimension == 2)
    {
      delta = 0.1;
    }
  double maxX(std::min(1.0, OriginX+UniformRadiusX));
  double minX(std::max(-1.0, OriginX-UniformRadiusX));
  double maxY(std::min(1.0, OriginY+UniformRadiusY));
  double minY(std::max(-1.0, OriginY-UniformRadiusY));
  double maxZ(std::min(1.0, OriginZ+UniformRadiusZ));
  double minZ(std::max(-1.0, OriginZ-UniformRadiusZ)); 
  maxX = aComp->centerPoint.x + maxX*aComp->lengthX/2*(1+delta);
  minX = aComp->centerPoint.x + minX*aComp->lengthX/2*(1+delta);
  maxY = aComp->centerPoint.y + maxY*aComp->lengthY/2*(1+delta);
  minY = aComp->centerPoint.y + minY*aComp->lengthY/2*(1+delta);
  maxZ = aComp->centerPoint.z + maxZ*aComp->lengthZ/2*(1+delta);
  minZ = aComp->centerPoint.z + minZ*aComp->lengthZ/2*(1+delta);
  std::vector<unsigned int> aCoords;
  for(std::vector<unsigned int>::iterator i(aComp->coords.begin());
      i != aComp->coords.end(); ++i)
    {
      Voxel* aVoxel(theSpatiocyteStepper->coord2voxel(*i));
      Point aPoint(theSpatiocyteStepper->coord2point(aVoxel->coord));
      if(aVoxel->id == aSpecies->getVacantID() &&
         aPoint.x < maxX && aPoint.x > minX &&
         aPoint.y < maxY && aPoint.y > minY &&
         aPoint.z < maxZ && aPoint.z > minZ)
        {
          aCoords.push_back(*i);
        }
    }
  unsigned int aSize(aSpecies->getPopulateMoleculeSize());
  if(aCoords.size() < aSize)
    {
      THROW_EXCEPTION(ValueError, String(
                      getPropertyInterface().getClassName()) +
                      "[" + getFullID().asString() + "]: There are " +
                      int2str(aSize) + " " + getIDString(aSpecies) +
                      " molecules that must be uniformly populated in a " +
                      "given range,\n but there are only " +
                      int2str(aCoords.size()) + " vacant voxels of " +
                      getIDString(aSpecies->getVacantSpecies()) +
                      " that can be populated.");
    }
  unsigned int aCoordsArray[aCoords.size()]; 
  for(unsigned int i(0); i != aCoords.size(); ++i)
    {
      aCoordsArray[i] = aCoords[i];
    }
  gsl_ran_shuffle(getStepper()->getRng(), aCoordsArray, aCoords.size(),
                  sizeof(unsigned int));
  for(unsigned int i(0); i != aSize; ++i)
    {
      aSpecies->addMolecule(theSpatiocyteStepper->coord2voxel(aCoordsArray[i]));
    }
}
Ejemplo n.º 13
0
GET_METHOD_DEF( Real, StepInterval, GillespieProcess )
{
    return getPropensity_R() *
        ( - log( gsl_rng_uniform_pos( getStepper()->getRng() ) ) );
}