AugmentedSpatialPopulation.cpp

Go to the documentation of this file.

#include "AugmentedSpatialPopulation.h"
#include "PopObjectAttributeFactory.h"
/*
#include <iostream>
using std::cout;
using std::cerr;
using std::endl;
*/

AugmentedSpatialPopulation::AugmentedSpatialPopulation(
    SimNetwork & net,
    vector< shared_ptr<PopObjectAttributeFactory> > const& familiesArg,
    SpatialFamilyIDGenerator const& fidgen,
    shared_ptr<Point3DSet> locs )
    : SpatialFamilyPopulation( net, locs )
{
    vector< SimObjectFactory* > families( familiesArg.size() );
    for( size_t f=0; f<familiesArg.size(); f++ ) {
        families[f] = &(*familiesArg[f]);
    }
    this->familyIDs = fidgen.generateIDs(net, families, *locations);

    populate(familiesArg);
    id_vec = shr_ptr_vec.get();
}


AugmentedSpatialPopulation::AugmentedSpatialPopulation(SimNetwork & net, 
                                                       shared_ptr<PopObjectAttributeFactory> fam0, 
                                                       shared_ptr<Point3DSet> locs )
    : SpatialFamilyPopulation( net, locs )
{
    shared_ptr< vector<familyid_t> > temp( new vector<familyid_t>( locs->size(), 0 ) );
    this->familyIDs = temp;
    vector< shared_ptr<PopObjectAttributeFactory> > families(1);
    families[0] = fam0;

    populate( families );
    id_vec = shr_ptr_vec.get();
}


AugmentedSpatialPopulation::AugmentedSpatialPopulation(vector< shared_ptr<AugmentedSpatialPopulation> >  const& pops)
{
    if( pops.size() < 1 ) {
        throw( PCSIM::ConstructionException( "AugmentedSpatialPopulation::AugmentedSpatialPopulation", "Empty set of populations specified to merge." ) );
    }

    // Calculate total size and check net
    this->net = &( pops[0]->getNet() );
    size_t tot_size = 0;
    size_t p;
    for( p = 0; p<pops.size(); p++ ) {
        tot_size += pops[p]->size();
        if( this->net != &( pops[p]->getNet() ) ) {
            throw( PCSIM::ConstructionException( "AugmentedSpatialPopulation::AugmentedSpatialPopulation", "Can not merge populations which belong to different networks." ) );
        }
    }

    shared_ptr< vector<familyid_t> > temp( new vector<familyid_t>( tot_size, 0 ) );
    this->familyIDs = temp;

    shared_ptr< vector<SimObject::ID::Packed> > tmpobj( new vector<SimObject::ID::Packed>( tot_size, 0 ) );
    this->shr_ptr_vec = tmpobj;
    id_vec = shr_ptr_vec.get();

    attributes.resize( tot_size );

    vector< Point3D<double> > points( tot_size );
    size_t ii=0;
    for( p = 0; p<pops.size(); p++ ) {
        AugmentedSpatialPopulation* P = pops[p].get();
        for( size_t i = 0; i<pops[p]->size(); i++ ) {
            (*familyIDs)[ ii ]   = P->getFamilyID( i );
            (*shr_ptr_vec)[ ii ] = (*(P->shr_ptr_vec))[ i ];
            points[ ii ]         = P->getLocation( i );
//            attributes[ ii ]     = new SimObjectAttributes( P->getAttributes( i ) );
            attributes[ ii ]     = P->attributes[ i ];
//            attributes[ ii ].reset(new SimObjectAttributes( P->getAttributes( i ) ));
            ii++;
        }
    }

    locations = shared_ptr<Point3DSet>( new Point3DSet( points ) );
}

AugmentedSpatialPopulation::~AugmentedSpatialPopulation()
{
/*      
    for(size_t i=0; i<attributes.size(); i++)
    {
        if (attributes[i])
        {
            delete attributes[i];
            attributes[i] = NULL;
        }
    }
*/
}


void AugmentedSpatialPopulation::populate( vector< shared_ptr<PopObjectAttributeFactory> > const& families )
{
    size_t n = this->locations->size();
    SimObject::ID::Vector ids( new vector<SimObject::ID::Packed>(n) );
    SimObject::ID id;
    familyid_t fid;
    
    attributes.resize(n);

    for( size_t i=0; i<n; i++ )
    {
        fid = (*familyIDs)[i];
        families[fid]->announce(*this, i);
        net->addObject( *(families[fid]), id );
        (*ids)[i] = id.packed();
        
//        attributes[ i ] = families[fid]->createAttributes(net->getMainConstructRNGEngine());
        attributes[ i ].reset(families[fid]->createAttributes(net->getMainConstructRNGEngine()));
    }

    this->shr_ptr_vec = ids;
}


SimObjectAttributes const& AugmentedSpatialPopulation::getAttributesAt(Point3D<double> const& p) const
{
        size_t index = locations->getIndex(p);
        
        return getAttributes(index);
}


SimObjectAttributes const& AugmentedSpatialPopulation::getAttributesAt(double const& x, double const& y, double const& z) const
{
        size_t index = locations->getIndex(x, y, z);
                
        return getAttributes(index);
}


SimObjectAttributes const& AugmentedSpatialPopulation::getAttributes(size_t index) const
{
        if (index < 0)
        throw( PCSIM::ConstructionException("AugmentedSpatialPopulation::AugmentedSpatialPopulation", "index out of bounds."));

        if (index >= attributes.size())
        throw( PCSIM::ConstructionException("AugmentedSpatialPopulation::AugmentedSpatialPopulation", "index out of bounds."));
        
    return *( attributes[ index ] );
}


AugmentedSpatialPopulation* AugmentedSpatialPopulation::new_subset( vector< size_t > const& subindices ) const
{
    size_t s;
    vector<SimObject::ID::Packed> objIDs( subindices.size() );
    vector<familyid_t> famIDs( subindices.size() );
    vector< shared_ptr<SimObjectAttributes> > attrs( subindices.size() );

    for( size_t i=0; i<subindices.size(); i++ ) {
        s = subindices[i];
        objIDs[i] = (*id_vec)[ s ];
        famIDs[i] = (*familyIDs)[ s ];
//        attrs[i]  = new SimObjectAttributes( attributes[s] );
        attrs[i]  = attributes[s];
    }

    return new AugmentedSpatialPopulation( net, objIDs, famIDs, attrs, locations->subset( subindices ) );
}

AugmentedSpatialPopulation::AugmentedSpatialPopulation(
    SimNetwork* net,
    vector<SimObject::ID::Packed> const& objIDs,
    vector<familyid_t> const& famIDs,
    vector<shared_ptr<SimObjectAttributes> > const& attrs,
    shared_ptr<Point3DSet> locs
)
    : SpatialFamilyPopulation( net, objIDs, famIDs, locs )
{
    this->attributes = attrs;
}


/*
shared_ptr< vector< shared_ptr<AugmentedSpatialPopulation> > > AugmentedSpatialPopulation::splitFamilies()
{
    size_t n = familyIDs->size();
    familyid_t fid;

    map< familyid_t, size_t >  cnt;
    vector< vector< size_t > > subs;
    vector< size_t > famids;

    for( size_t i=0; i<n; i++ ) {
        fid = (*familyIDs)[i];
        if (  cnt.find( fid ) == cnt.end() ) {
            cnt[ fid ] = cnt.size() - 1;
            subs.resize( cnt.size() );
            subs[ subs.size() - 1 ].resize(0);
            famids.push_back( fid );
        }
        subs[ cnt[fid] ].push_back( i );
    }
    sort( famids.begin(), famids.end() );

    shared_ptr< vector< shared_ptr<AugmentedSpatialPopulation> > > subpops( new vector< shared_ptr<AugmentedSpatialPopulation> >( subs.size() ) );

    for( size_t s = 0; s < famids.size(); s++ ) {
        fid = famids[s];
        (*subpops)[s] = shared_ptr<AugmentedSpatialPopulation>( new_subset( subs[ cnt[fid] ] ) );
    }
    return subpops;

}
*/

---