SpatialFamilyPopulation.cpp

Go to the documentation of this file.

#include "SpatialFamilyPopulation.h"
#include "PCSIMException.h"
#include <boost/format.hpp>

#include <map>
using std::map;

#include <algorithm>
using std::sort;

#include <iostream>
using std::cerr;
using std::endl;

SpatialFamilyPopulation::SpatialFamilyPopulation( SimNetwork* net, 
                                                  vector<SimObject::ID::Packed> const& objIDs, 
                                                  vector<familyid_t> const& famIDs,
                                                  shared_ptr<Point3DSet> locs )
    : SpatialSimObjectPopulation( *net, locs )
{
    if( !( (objIDs.size() == famIDs.size()) && (objIDs.size() == locs->size()) ) ) {
        throw( PCSIM::ConstructionException( "SpatialFamilyPopulation::SpatialFamilyPopulation", "All vectors must be of same size." ) );
    }

    shared_ptr< vector<familyid_t> > tmpfam( new vector<familyid_t>(famIDs) );
    this->familyIDs = tmpfam;

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

SpatialFamilyPopulation::SpatialFamilyPopulation( SimNetwork & net, shared_ptr<Point3DSet> locs)
    : SpatialSimObjectPopulation( net, locs )
{
    this->net = &net;
}

SpatialFamilyPopulation::SpatialFamilyPopulation( SimNetwork & net,
                                                  vector< SimObjectFactory* > const& families,
                                                  SpatialFamilyIDGenerator const& fidgen,
                                                  shared_ptr<Point3DSet> locs )
    : SpatialSimObjectPopulation( net, locs )
{
    this->familyIDs = fidgen.generateIDs( net, families, *locations );
    shr_ptr_vec = populate( families );
    id_vec = shr_ptr_vec.get();
}

SpatialFamilyPopulation::SpatialFamilyPopulation( SimNetwork & net,
                                                  vector< shared_ptr<SimObjectFactory> > const& familiesArg,
                                                  SpatialFamilyIDGenerator const& fidgen,
                                                  shared_ptr<Point3DSet> locs )
    : SpatialSimObjectPopulation( 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 );
    shr_ptr_vec = populate( families );
    id_vec = shr_ptr_vec.get();
}

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

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

SpatialFamilyPopulation::SpatialFamilyPopulation( vector< shared_ptr<SpatialFamilyPopulation> >  const& pops )
{
    if( pops.size() < 1 ) {
        throw( PCSIM::ConstructionException( "SpatialFamilyPopulation::SpatialFamilyPopulation", "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( "SpatialFamilyPopulation::SpatialFamilyPopulation", "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();

    vector< Point3D<double> > points( tot_size );
    size_t ii=0;
    for( p = 0; p<pops.size(); p++ ) {
        SpatialFamilyPopulation* 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 );
            ii++;
        }
    }

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

SpatialFamilyPopulation::~SpatialFamilyPopulation()
{
  // NOOP
}

SimObject::ID::Vector SpatialFamilyPopulation::populate( vector< SimObjectFactory* > const& families ) 
{
    size_t n = this->locations->size();
    SimObject::ID::Vector ids( new vector<SimObject::ID::Packed>(n) );
    SimObject::ID id;
    familyid_t fid;
    for( size_t i=0; i<n; i++ ) {
        fid = (*familyIDs)[i];
        net->addObject( *(families[fid]), id );
        (*ids)[i] = id.packed();
    }
    return ids;
}

familyid_t SpatialFamilyPopulation::getFamilyIdAt( Point3D<double> const& p ) {
    return (*familyIDs)[ locations->getIndex( p ) ];
}

familyid_t SpatialFamilyPopulation::getFamilyIdAt( double const& x, double const& y, double const& z) {
    return (*familyIDs)[ locations->getIndex( x, y, z ) ];
}


familyid_t SpatialFamilyPopulation::getFamilyID( size_t index ) {
    return (*familyIDs)[ index ];
}

void SpatialFamilyPopulation::setFamilyID( familyid_t newID )
{
    for( size_t i=0; i<familyIDs->size(); i++ )
        (*familyIDs)[ i ] = newID;
}

shared_ptr<SpatialFamilyPopulation> SpatialFamilyPopulation::subPopulation( vector< familyid_t > const& families )
{
    vector<size_t> subindices;
    map< size_t, size_t >  fid_set;
    for( size_t f=0; f<families.size(); f ++ ) {
        fid_set[ families[f] ] = 1;
    }
    for( size_t i=0; i<id_vec->size(); i++ ) {
        if( fid_set.find( (*familyIDs)[ i ] ) !=  fid_set.end() ) {
            subindices.push_back( i );
        }
    }
    return shared_ptr<SpatialFamilyPopulation>( new_subset( subindices ) );
}

SpatialFamilyPopulation* SpatialFamilyPopulation::new_subset( vector< size_t > const& subindices ) const 
{
    size_t s;
    vector<SimObject::ID::Packed> objIDs( subindices.size() );
    vector<familyid_t> famIDs( subindices.size() );
    for( size_t i=0; i<subindices.size(); i++ ) {
        s = subindices[i];
        objIDs[i] = (*id_vec)[ s ];
        famIDs[i] = (*familyIDs)[ s ];
    }
    return new SpatialFamilyPopulation( net, objIDs, famIDs, locations->subset( subindices ) );
}

shared_ptr< vector< shared_ptr<SpatialFamilyPopulation> > > SpatialFamilyPopulation::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<SpatialFamilyPopulation> > > subpops( new vector< shared_ptr<SpatialFamilyPopulation> >( subs.size() ) );

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

}

---