IndFactory Class Reference

Factory of Individual, stores the individual prototype and the trait prototypes, manages the individual garbage collector. More...

#include <indfactory.h>

Inheritance diagram for IndFactory:

Collaboration diagram for IndFactory:

Public Member Functions
	IndFactory ()
virtual	~IndFactory ()
void	recycle (Individual *ind)
	Put an individual in the recycling pool. More...
void	purgeRecyclingPOOL ()
	Empty the recycling pool. More...
void	makePrototype (map< trait_t, TraitPrototype * > TTlist)
	Creates the individuals prototype from the selected trait prototypes. More...
void	clearPrototype ()
	Reset the trait prototypes, mostly done to unregister the genetic maps. More...
Individual *	getPrototypeClone ()
	Return an uninitialized copy of the individual prototype. More...
Individual *	getNewIndividual ()
	Creates a blank individual which has to be "decorated" later. More...
Individual *	makeNewIndividual (Individual *mother, Individual *father, sex_t sex, unsigned short homepatch)
	Creates an individual with pointers to parents, sex and home ID set but no genetic data. More...
Individual *	makeOffsprg (Individual *mother, Individual *father, sex_t sex, unsigned short homepatch)
	Completely creates an individual with inheritance and mutations on all traits. More...
Individual *	getIndividualProtoype ()
	Individual prototype accessor. More...
TraitPrototype *	getTraitPrototype (trait_t type)
	Accessor to a TraitPrototype. More...
std::map< trait_t, TraitPrototype * > &	getTraitPrototypes ()
	Accessor to the list of TraitPrototype's. More...
int	getTraitIndex (trait_t type)
	Gives the index of trait with type. More...

Protected Attributes
std::map< trait_t, TraitPrototype * >	_protoTraits
	Map of the trait prototypes. More...
std::map< trait_t, int >	_TraitsIndex
	Table containing the index of each trait. More...
Individual	_protoIndividual
	The individuals prototype used to create any new individual in a simulation. More...
std::deque< Individual * >	RecyclingPOOL
	Garbage collector for unused Individual's. More...

Detailed Description

Factory of Individual, stores the individual prototype and the trait prototypes, manages the individual garbage collector.

Provides methods to generate new individuals within the Metapop. Each new individual is created by cloning a prototype itself created at the simulation setup. New individuals are decorated with the appropriate traits as set by the trait prototypes and receives a unique ID (unique within a simulation).

Constructor & Destructor Documentation

IndFactory()

IndFactory::IndFactory ( )

inline

{ }; 

~IndFactory()

IndFactory::~IndFactory ( )

virtual

{
  purgeRecyclingPOOL(); 
  
  _protoIndividual.clearTraits();
    
  _protoTraits.clear(); //the proto traits are deallocated within ~SimBuilder
  
  _TraitsIndex.clear();
  
}

Member Function Documentation

clearPrototype()

void IndFactory::clearPrototype

(

)

Reset the trait prototypes, mostly done to unregister the genetic maps.

{
#ifdef _DEBUG_
  message("IndFactory::clearPrototype\n");
#endif
  
  //clear the ttraits:
  _protoIndividual.clearTraits();
  
  map< trait_t, TraitPrototype* >::iterator trait = _protoTraits.begin();
 
  while(trait != _protoTraits.end()) {
     
    trait->second->reset();
    
    trait++;
  }
  
  _protoTraits.clear();
  _TraitsIndex.clear();
  TTProtoWithMap::_map.clear();
}

References TTProtoWithMap::_map, GeneticMap::clear(), and message().

Referenced by SimRunner::run().

getIndividualProtoype()

Individual* IndFactory::getIndividualProtoype ( )

inline

Individual prototype accessor.

{return &_protoIndividual;}

References _protoIndividual.

Referenced by LCE_Breed_Selection::setNonSelectedTraitTable().

getNewIndividual()

Individual* IndFactory::getNewIndividual ( )

inline

Creates a blank individual which has to be "decorated" later.

ID is set and new traits are allocated but no genetic data is created (i.e. TTrait::init_sequence() is not called). Sex has to be set later too.

{return makeNewIndividual(NULL,NULL,MAL,0);}

References makeNewIndividual(), and MAL.

Referenced by LCE_Breed_base::breed_cloning(), Metapop::fillPatchFromSource(), Metapop::fillPopulationFromSource(), Metapop::loadPopFromBinarySource(), and Metapop::retrieve_data().

getPrototypeClone()

Individual* IndFactory::getPrototypeClone ( )

inline

Return an uninitialized copy of the individual prototype.

{return _protoIndividual.clone();}

References _protoIndividual, and Individual::clone().

Referenced by LCE_Cross::generatePedigree().

getTraitIndex()

int IndFactory::getTraitIndex

(

trait_t

type

)

Gives the index of trait with type.

Parameters

type	the type of the trait (i.e. its "name")

{
  map< trait_t, int >::iterator trait = _TraitsIndex.find(type);
  
  if(trait == _TraitsIndex.end())
    return -1;
  
  return trait->second;
}

Referenced by LifeCycleEvent::attach_trait(), TTDispersalSH::init(), TTQuantiSH::init(), LCE_FileServicesNotifier::loadFileServices(), SimRunner::run(), LCE_BreedAssortativeMating::setParameters(), LCE_Disperse_EvolDisp::setParameters(), and LCE_Selection_base::setParameters().

getTraitPrototype()

TraitPrototype * IndFactory::getTraitPrototype

(

trait_t

type

)

Accessor to a TraitPrototype.

Parameters

type	the trait name

{
  map< trait_t, TraitPrototype* >::iterator trait = _protoTraits.find(type);
  
  if(trait == _protoTraits.end()) return NULL;
  
  return trait->second;
  
}

Referenced by LCE_QuantiInit::execute(), LCE_Init_BDMI::execute(), LCE_Selection_base::set_sel_model(), LCE_PhenotypeExpression::setParameters(), LCE_QuantiInit::setParameters(), LCE_QuantiModifier::setParameters(), LCE_Breed_Quanti::setParameters(), LCE_Init_BDMI::setParameters(), LCE_NtrlInit::setParameters(), and LCE_Selection_base::setSelectionMatrix().

getTraitPrototypes()

std::map< trait_t,TraitPrototype* >& IndFactory::getTraitPrototypes ( )

inline

Accessor to the list of TraitPrototype's.

{return _protoTraits;}

References _protoTraits.

Referenced by Metapop::loadPopFromTraitFile(), and Metapop::store_data().

makeNewIndividual()

Individual * IndFactory::makeNewIndividual	(	Individual *	mother,
		Individual *	father,
		sex_t	sex,
		unsigned short	homepatch
	)

Creates an individual with pointers to parents, sex and home ID set but no genetic data.

No inheritance or mutations on the trait sequences are done. Sets the pedigree class of the individual. Calls Individual::init() to allocate traits' sequences memory if individual is cloned from the prototype. Otherwise, calls Individual::reset() if the new individual is coming from the recycling pool.

Parameters

mother	ptr to the mother
father	ptr to the father
sex	gender of the individual
homepatch	ID of the Patch where this individual is born, usually the current position in the Metapop::vPatch array.

{
  Individual* newind;
  
  if(RecyclingPOOL.empty()) {
    //create new Individual by cloning the proto-individual
    newind = _protoIndividual.clone();
    //allocate memory for the traits' sequences:
    newind->init();
  } else {
    //recycle an Individual from the POOL
    newind = RecyclingPOOL[0];
    RecyclingPOOL.pop_front();
    newind->reset();
    newind->setID(Individual::currentID++);
  }
  
  newind->setSex(sex);
  newind->setHome(homepatch);
  if(mother != NULL && father != NULL) {
    newind->setFatherID(father->getID());
    newind->setMotherID(mother->getID());
    newind->setFather(father);
    newind->setMother(mother);
    newind->setPedigreeClass(mother, father);
  }
  
  return newind;
}

References Individual::clone(), Individual::currentID, Individual::getID(), Individual::init(), Individual::reset(), Individual::setFather(), Individual::setFatherID(), Individual::setHome(), Individual::setID(), Individual::setMother(), Individual::setMotherID(), Individual::setPedigreeClass(), and Individual::setSex().

Referenced by LCE_Breed_base::breed(), LCE_Breed_base::breed_cloning(), LCE_Cross::create_individual_ancestors(), TTDeletMutBitstrFH::FHread(), TTNeutralGenesFH::FHread(), TTQuantiFH::FHread(), LCE_Resize::fillPatchNoBackup(), getNewIndividual(), LCE_Breed_Disperse::mate_full_selfing(), LCE_Breed_Disperse::mate_random(), LCE_Breed_Disperse::mate_random_hermaphrodite(), LCE_Breed_Disperse::mate_selfing(), and Patch::setNewGeneration().

makeOffsprg()

Individual * IndFactory::makeOffsprg	(	Individual *	mother,
		Individual *	father,
		sex_t	sex,
		unsigned short	homepatch
	)

Completely creates an individual with inheritance and mutations on all traits.

Calls makeNewIndividual() to get the new offspring.

Parameters

mother	ptr to the mother
father	ptr to the father
sex	gender of the individual
homepatch	ID of the Patch where this individual is born, usually the current position in the Patch array

{  
  Individual* offspring = makeNewIndividual(mother,father,sex,homepatch);
  unsigned int cat = offspring->getPedigreeClass();
  mother->DidHaveABaby(cat);
  if(cat!=4) father->DidHaveABaby(cat);
  return offspring->create(mother, father);
}

References Individual::create(), Individual::DidHaveABaby(), and Individual::getPedigreeClass().

Referenced by LCE_Cross::sampleAmongPop(), LCE_Cross::sampleWithinPop(), LCE_Breed_Wolbachia::wolbachia_model_1(), and LCE_Breed_Wolbachia::wolbachia_model_2().

makePrototype()

void IndFactory::makePrototype

(

map< trait_t, TraitPrototype * >

TTlist

)

Creates the individuals prototype from the selected trait prototypes.

Resets the individual's ID counter to 0 and sets the traits index table.

Parameters

TTlist

the list of the current trait prototype selected from the current simulation parameters.

{
#ifdef _DEBUG_
  message("IndFactory::makePrototype\n");
#endif
 
  //first, reset the ID counter:
  _protoIndividual.setCurrentID(0);
  
  //store the traits list for future use:
  _protoTraits = TTlist;
 
  //then add the traits from the trait prototypes:
  map< trait_t, TraitPrototype* >::iterator trait = TTlist.begin();
 
  _TraitsIndex.clear(); //kept here but also done in clearPrototype()
  
  int i = 0;
  
  while(trait != TTlist.end()) {
    
#ifdef _DEBUG_
    message("IndFactory::makePrototype::addTrait: %s\n",trait->first.c_str());
    cout << "trait proto ptr:"<<trait->second <<endl;
    cout << "trait proto type:"<<trait->second->get_type() <<endl;
//    TTrait* tt=trait->second->hatch();
//    tt->init();
//    tt->init_sequence();
//    tt->show_up();
//    delete tt;
#endif
    
    //init the trait prototype, set attribute from input file parameters value
    if(!trait->second->setParameters()) {
      error("initialization of prototype for trait \"%s\" failed\n",trait->first.c_str());
      fatal("bailing out from individual prototype initialization\n");
    }
    //set the prototype's index value
    trait->second->set_index(i);
 
    //create the trait and add it to the proto-individual
    _protoIndividual.addTrait(trait->second->hatch(),i);
    
    //store the trait's index into the index map
    _TraitsIndex[trait->first] = i++;
    
    trait++;
  }
  
}

References error(), fatal(), and message().

Referenced by BinaryDataLoader::extractPop(), SimRunner::init_components(), and Metapop::loadPopFromTraitFile().

purgeRecyclingPOOL()

void IndFactory::purgeRecyclingPOOL ( )

inline

Empty the recycling pool.

  { for(unsigned int i=0; i < RecyclingPOOL.size(); ++i) delete RecyclingPOOL[i]; RecyclingPOOL.clear(); }

References RecyclingPOOL.

Referenced by Metapop::clear(), Metapop::init(), and Metapop::setPopulation().

recycle()

void IndFactory::recycle ( Individual *  ind )

inline

Put an individual in the recycling pool.

  { if(ind == NULL) error("IndFactory::recycle:ind is NULL!!\n"); else RecyclingPOOL.push_back(ind); }

References error(), and RecyclingPOOL.

Referenced by LCE_Patch_Extinction::do_remove(), LCE_Selection_base::doViabilitySelection(), LCE_Disperse_EvolDisp::evoldisp(), LCE_Disperse_EvolDisp::fixdisp(), Patch::flush(), LCE_Breed_Selection::makeOffspringWithSelection(), LCE_Disperse_ConstDisp::MigratePatch_AbsorbingBorder(), LCE_Resize::regulateAgeClassNoBackup(), LCE_Regulation::regulatePatch(), and LCE_Breed_Wolbachia::wolbachia_model_1().

Member Data Documentation

_protoIndividual

Individual IndFactory::_protoIndividual

protected

The individuals prototype used to create any new individual in a simulation.

Referenced by getIndividualProtoype(), and getPrototypeClone().

_protoTraits

std::map< trait_t, TraitPrototype* > IndFactory::_protoTraits

protected

Map of the trait prototypes.

Referenced by getTraitPrototypes(), and Metapop::retrieve_data().

_TraitsIndex

std::map< trait_t, int > IndFactory::_TraitsIndex

protected

Table containing the index of each trait.

RecyclingPOOL

std::deque<Individual*> IndFactory::RecyclingPOOL

protected

Garbage collector for unused Individual's.

Referenced by purgeRecyclingPOOL(), and recycle().

---

The documentation for this class was generated from the following files:

• indfactory.h
• indfactory.cc