void CompartmentSpaceVectorImpl::remove_molecules(
const Species& sp, const Integer& num)
{
if (num < 0)
{
std::ostringstream message;
message << "The number of molecules must be positive. [" << sp.serial() << "]";
throw std::invalid_argument(message.str());
}
species_map_type::const_iterator i(index_map_.find(sp));
if (i == index_map_.end())
{
std::ostringstream message;
message << "Speices [" << sp.serial() << "] not found";
throw NotFound(message.str()); // use boost::format if it's allowed
}
if (num_molecules_[(*i).second] < num)
{
std::ostringstream message;
message << "The number of molecules cannot be negative. [" << sp.serial() << "]";
throw std::invalid_argument(message.str());
}
num_molecules_[(*i).second] -= num;
}
void CompartmentSpaceVectorImpl::release_species(const Species& sp)
{
species_map_type::iterator i(index_map_.find(sp));
if (i == index_map_.end())
{
std::ostringstream message;
message << "Speices [" << sp.serial() << "] not found";
throw NotFound(message.str()); // use boost::format if it's allowed
}
species_map_type::mapped_type
idx((*i).second), last_idx(num_molecules_.size() - 1);
if (idx != last_idx)
{
species_container_type::size_type const
idx_(static_cast<species_container_type::size_type>(idx)),
last_idx_(static_cast<species_container_type::size_type>(last_idx));
const Species& last_sp(species_[last_idx_]);
species_[idx_] = last_sp;
num_molecules_[idx] = num_molecules_[last_idx];
index_map_[last_sp] = idx;
}
species_.pop_back();
num_molecules_.pop_back();
index_map_.erase(sp);
}
explicit Particle(
const Species& sp, const Real3& pos, const Real& radius,
const Real& D)
// : position_(pos), radius_(radius), D_(D)
: species_serial_(sp.serial()), position_(pos), radius_(radius), D_(D)
// : species_(sp), species_serial_(sp.serial()), position_(pos), radius_(radius), D_(D)
{
// std::strcpy(species_serial_, sp.serial().c_str());
}
void NetworkModel::remove_species_attribute(const Species& sp)
{
species_container_type::iterator i(
std::find(species_attributes_.begin(), species_attributes_.end(), sp));
if (i == species_attributes_.end())
{
std::ostringstream message;
message << "Speices [" << sp.serial() << "] not found";
throw NotFound(message.str()); // use boost::format if it's allowed
}
species_attributes_.erase(i);
}
static void sort_by_location(std::multimap<std::string, Species> location_map,
std::vector<Species>& species, const std::string location="")
{
std::multimap<std::string, Species>::iterator itr;
while ((itr = location_map.find(location)) != location_map.end())
{
const Species sp((*itr).second);
species.push_back(sp);
sort_by_location(location_map, species, sp.serial());
location_map.erase(itr);
}
}
std::vector<ReactionRule> NetworkModel::query_reaction_rules(
const Species& sp) const
{
first_order_reaction_rules_map_type::const_iterator
i(first_order_reaction_rules_map_.find(sp.serial()));
std::vector<ReactionRule> retval;
if (i != first_order_reaction_rules_map_.end())
{
retval.reserve((*i).second.size());
for (first_order_reaction_rules_map_type::mapped_type::const_iterator
j((*i).second.begin()); j != (*i).second.end(); ++j)
{
retval.push_back(reaction_rules_[*j]);
}
}
return retval;
}
static void save_molecular_type(const MolecularTypeBase* mtb,
std::vector<std::pair<ParticleID, Voxel> > voxels, H5::Group* group)
{
const Species species(mtb->species());
boost::scoped_ptr<H5::Group> mtgroup(
new H5::Group(group->createGroup(species.serial().c_str())));
h5_species_struct property;
property.radius = mtb->radius();
property.D = mtb->D();
const MolecularTypeBase* loc(mtb->location());
if (loc->is_vacant())
std::strcpy(property.location, "");
else
std::strcpy(property.location, loc->species().serial().c_str());
property.is_structure = mtb->is_structure() ? 1 : 0;
property.dimension = mtb->get_dimension();
H5::CompType property_comp_type(get_property_comp());
mtgroup->createAttribute("property", property_comp_type,
H5::DataSpace(H5S_SCALAR)).write(property_comp_type, &property);
// Save voxels
const Integer num_voxels(voxels.size());
std::size_t vidx(0);
boost::scoped_array<h5_voxel_struct> h5_voxel_array(new h5_voxel_struct[num_voxels]);
for (std::vector<std::pair<ParticleID, Voxel> >::const_iterator itr(voxels.begin());
itr != voxels.end(); ++itr)
{
h5_voxel_array[vidx].lot = (*itr).first.lot();
h5_voxel_array[vidx].serial = (*itr).first.serial();
h5_voxel_array[vidx].coordinate = (*itr).second.coordinate();
++vidx;
}
H5::CompType voxel_comp_type(get_voxel_comp());
hsize_t dims[] = {num_voxels};
H5::DataSpace dspace(/* RANK= */1, dims);
boost::scoped_ptr<H5::DataSet> dset(new H5::DataSet(
mtgroup->createDataSet("voxels", voxel_comp_type, dspace)));
dset->write(h5_voxel_array.get(), dset->getDataType());
}
void CompartmentSpaceVectorImpl::add_molecules(
const Species& sp, const Integer& num)
{
if (num < 0)
{
std::ostringstream message;
message << "The number of molecules must be positive. [" << sp.serial() << "]";
throw std::invalid_argument(message.str());
}
species_map_type::const_iterator i(index_map_.find(sp));
if (i == index_map_.end())
{
// throw NotFound("Species not found");
reserve_species(sp);
i = index_map_.find(sp);
}
num_molecules_[(*i).second] += num;
}
std::vector<ReactionRule> NetworkModel::query_reaction_rules(
const Species& sp1, const Species& sp2) const
{
std::vector<ReactionRule> retval;
const std::pair<Species::serial_type, Species::serial_type>
key(sp1.serial() < sp2.serial()?
std::make_pair(sp1.serial(), sp2.serial()):
std::make_pair(sp2.serial(), sp1.serial()));
second_order_reaction_rules_map_type::const_iterator
i(second_order_reaction_rules_map_.find(key));
if (i != second_order_reaction_rules_map_.end())
{
retval.reserve((*i).second.size());
for (second_order_reaction_rules_map_type::mapped_type::const_iterator
j((*i).second.begin()); j != (*i).second.end(); ++j)
{
retval.push_back(reaction_rules_[*j]);
}
}
return retval;
}
bool Species::operator==(const Species& rhs) const
{
return (serial() == rhs.serial());
}
bool Species::operator>(const Species& rhs) const
{
return (serial() > rhs.serial());
}