GooseMemoryMap Class Reference

The class describing both local and seasonal goose memories and cognition. More...

#include <GooseMemoryMap.h>

Public Member Functions
double	CalcScore (int a_dist, double a_foodresource, double a_threat)
	Inline function to calulate overall score for a distance, resource and threat. More...
bool	ChangeAddFoodRes (int a_polyid, double a_foodres)
	Add to food at a memory location. More...
bool	ChangeAddThreat (int a_polyid, double a_threat)
	Add to threat at a memory location. More...
bool	ChangeMultFoodRes (int a_polyid, double a_foodres)
	Multiply food at a memory location. More...
bool	ChangeMultThreat (int a_polyid, double a_threat)
	Multiply threat at a memory location. More...
bool	ChangeSetFoodRes (int a_polyid, double a_grain, double a_maize, double a_grazing)
	Set food at a memory location. More...
void	ClearAllMemory (void)
	Remove all memory. More...
void	DecayAllMemory ()
	Decay all memory. More...
GooseMemoryLocation	GetBestFeedingScore ()
	Find the current best feeding location. More...
double	GetFoodRes (int a_polyid)
	Get the food resource at location. More...
double	GetThreat (int a_polyid)
	Get the threat level at location. More...
double	GetTotalThreats (void)
	Get total of threat currently remembered. More...
	GooseMemoryMap (Goose_Base *a_owner)
	Constructor. More...
bool	IsKnownArea (int a_polyid)
	Check if this location is known. More...
void	MemAdd (GooseMemoryLocation a_gml)
	Add a new memory location. More...
bool	MemDel (int a_polyid)
	Delete a memory location. More...
	~GooseMemoryMap ()
	Destructor. More...

Protected Member Functions
void	GooseMemoryError (std::string a_str, int a_value)
	Error message functionality. More...

Protected Attributes
int	m_expectedforagingtime
	the time in minutes a goose expects to be able to forage when evaluating cost benefit of flying to a location. More...
std::vector< GooseMemoryLocation >	m_memorylocations
	The list of memory locations. More...
Goose_Base *	m_myOwner
	pointer to the owner More...
double	m_threatdecayrate
	The decay rate per day for threats. More...

Detailed Description

The class describing both local and seasonal goose memories and cognition.

Definition at line 93 of file GooseMemoryMap.h.

Constructor & Destructor Documentation

GooseMemoryMap()

GooseMemoryMap::GooseMemoryMap

(

Goose_Base *

a_owner

)

Constructor.

Definition at line 39 of file GooseMemoryMap.cpp.

{
        m_myOwner = a_owner;
        m_threatdecayrate = cfg_goose_mem_threatdecayrate.value();
        m_expectedforagingtime = cfg_goose_mem_expectedforagingtime.value();
        GooseMemoryLocation aloc;
        aloc.m_infinitememorystop = cfg_goose_mem_minmemoryvalue.value(); // Set the static variable
        //m_memorylocations.reserve(200); // there are usually 200-300 memories, reserving this in advance does not hurt, and speeds the process when new elements are added (a bit).
}

References cfg_goose_mem_expectedforagingtime, cfg_goose_mem_minmemoryvalue, cfg_goose_mem_threatdecayrate, GooseMemoryLocation::m_infinitememorystop, CfgInt::value(), and CfgFloat::value().

~GooseMemoryMap()

GooseMemoryMap::~GooseMemoryMap ( )

inline

Destructor.

Definition at line 110 of file GooseMemoryMap.h.

                          { 
                m_memorylocations.erase(m_memorylocations.begin(),m_memorylocations.end());
        }

References m_memorylocations.

Member Function Documentation

CalcScore()

double GooseMemoryMap::CalcScore	(	int	a_dist,
		double	a_foodresource,
		double	a_threat
	)

Inline function to calulate overall score for a distance, resource and threat.

Parameters

[in]	a_dist	The distance to the location
[in]	a_foodresource	The foodresource at the location
[in]	a_threat	A measure of the strength of threat memory.

Returns

the memory score calculation result

Definition at line 273 of file GooseMemoryMap.cpp.

{
                double cost = a_dist * m_myOwner->GetFlightCost();
                double score = (a_foodresource * m_expectedforagingtime) - cost;
                score = score * (1 - a_threat);
                return score;
}

Referenced by Goose_Base::EvaluateForageToHopLoc(), Goose_Base::On_Bang(), and Goose_Base::st_ChooseForageLocation().

ChangeAddFoodRes()

bool GooseMemoryMap::ChangeAddFoodRes	(	int	a_polyid,
		double	a_foodres
	)

Add to food at a memory location.

Parameters

a_polyid	[in] A unique polygon reference to a goose memory location.
a_foodres	[in] A measure of the strength of food resource memory.

Returns

success

Here we make use of the fact that there should only be one of each entry, so no need to read the whole list, just stop when we find one bigger and add the food resource to be added

Definition at line 105 of file GooseMemoryMap.cpp.

{
        std::vector<GooseMemoryLocation>::iterator it;
        for (it = m_memorylocations.begin(); it != m_memorylocations.end(); ++it)
        {
                if (it->m_polygonid == a_polyid)
                {
                        it->m_foodresource += a_foodres;
                        return true; // all good
                }
        }
        return false; // entry not found
}

ChangeAddThreat()

bool GooseMemoryMap::ChangeAddThreat	(	int	a_polyid,
		double	a_threat
	)

Add to threat at a memory location.

Parameters

a_polyid	[in] A unique polygon reference to a goose memory location.
a_threat	[in] A measure of the strength of threat memory.

Returns

success

Here we make use of the fact that there should only be one of each entry, so no need to read the whole list, just stop when we find one bigger and add the threat to be added

Definition at line 123 of file GooseMemoryMap.cpp.

{
        std::vector<GooseMemoryLocation>::iterator it;
        for (it = m_memorylocations.begin(); it != m_memorylocations.end(); ++it)
        {
                if (it->m_polygonid == a_polyid)
                {
                        it->m_threat += a_threat;
                        return true; // all good
                }
        }
        return false; // entry not found
}

Referenced by Goose_Base::On_Bang().

ChangeMultFoodRes()

bool GooseMemoryMap::ChangeMultFoodRes	(	int	a_polyid,
		double	a_foodres
	)

Multiply food at a memory location.

Parameters

a_polyid	[in] A unique polygon reference to a goose memory location.
a_foodres	[in] A measure of the strength of food resource memory.

Returns

success

Here we make use of the fact that there should only be one of each entry, so no need to read the whole list, just stop when we find one bigger and multiply by the value passed

Definition at line 141 of file GooseMemoryMap.cpp.

{
        std::vector<GooseMemoryLocation>::iterator it;
        for (it = m_memorylocations.begin(); it != m_memorylocations.end(); ++it)
        {
                if (it->m_polygonid == a_polyid)
                {
                        it->m_foodresource *= a_foodres;
                        return true; // all good
                }
        }
        return false; // entry not found
}

ChangeMultThreat()

bool GooseMemoryMap::ChangeMultThreat	(	int	a_polyid,
		double	a_threat
	)

Multiply threat at a memory location.

Parameters

a_polyid	[in] A unique polygon reference to a goose memory location.
a_threat	[in] The memory of a threat at this location

Returns

success

Here we make use of the fact that there should only be one of each entry, so no need to read the whole list, just stop when we find one bigger and multiply by the value passed

Definition at line 187 of file GooseMemoryMap.cpp.

{
        std::vector<GooseMemoryLocation>::iterator it;
        for (it = m_memorylocations.begin(); it != m_memorylocations.end(); ++it)
        {
                if (it->m_polygonid == a_polyid)
                {
                        it->m_threat *= a_threat;
                        return true; // all good
                }
        }
        return false; // entry not found
}

ChangeSetFoodRes()

bool GooseMemoryMap::ChangeSetFoodRes	(	int	a_polyid,
		double	a_grain,
		double	a_maize,
		double	a_grazing
	)

Set food at a memory location.

Parameters

a_polyid	[in] A unique polygon reference to a goose memory location.
a_grain	[in] The grain food resource.
a_maize	[in] The maize food resource.
a_grazing	[in] The grazing food resource.

Returns

success

Here we make use of the fact that there should only be one of each entry, so no need to read the whole list, just stop when we find our polygon.

Todo:

Speed-up Identified as the program bottleneck. The problem is that in most cases this is called we run all the way to the end of the vector and don't find our polygon.

Definition at line 159 of file GooseMemoryMap.cpp.

{
        std::vector<GooseMemoryLocation>::iterator it;
        for (it = m_memorylocations.begin(); it != m_memorylocations.end(); ++it)
        {
                if (it->m_polygonid == a_polyid)
                {
                        it->m_grain = a_grain;
                        it->m_maize = a_maize;
                        it->m_grazing = a_grazing;
                        it->m_foodresource = m_myOwner->GetMaxIntakeRate(a_grain, a_maize, a_grazing);
                        APoint roost = m_myOwner->GetRoost();
                        int dist = g_AlmassMathFuncs.CalcDistPythagorasApprox( roost.m_x, roost.m_y, it->m_x, it->m_y );
                        it->m_score = CalcScore(dist, it->m_foodresource, it->m_threat);
                        return true; // all good
                }
        }
        return false; // entry not found
}

References ALMaSS_MathFuncs::CalcDistPythagorasApprox(), and g_AlmassMathFuncs.

Referenced by Goose_Base::st_ChooseForageLocation(), and Goose_Base::st_Forage().

ClearAllMemory()

void GooseMemoryMap::ClearAllMemory

(

void

)

Remove all memory.

Returns

None

Definition at line 335 of file GooseMemoryMap.cpp.

{
        m_memorylocations.erase(m_memorylocations.begin(), m_memorylocations.end());
}

DecayAllMemory()

void GooseMemoryMap::DecayAllMemory

(

void

)

Decay all memory.

1 - Loop through all locations 2 - Decay the memory 3 - Update the memory score 4 - Remove any memories that are old

Definition at line 295 of file GooseMemoryMap.cpp.

{
        vector<GooseMemoryLocation>::iterator it;
        for (it = m_memorylocations.begin(); it != m_memorylocations.end(); it++)
        {
                // 2 - Decay and age the memory 
                it->m_threat *= m_threatdecayrate;
                it->m_age++;
                // 3. Update the memory score
                int rx = m_myOwner->GetRoost().m_x;
                int ry = m_myOwner->GetRoost().m_y;
                int dist = g_AlmassMathFuncs.CalcDistPythagorasApprox( rx, ry, it->m_x, it->m_y );
                double flightcost = m_myOwner->GetFlightCost();
                it->CalcScore(dist, flightcost, m_expectedforagingtime);
        }
        // 4. Remove memories too old
        m_memorylocations.erase(remove_if(m_memorylocations.begin(), m_memorylocations.end(), IsMarkedToDelete), m_memorylocations.end());
}

References ALMaSS_MathFuncs::CalcDistPythagorasApprox(), g_AlmassMathFuncs, and IsMarkedToDelete().

Referenced by Goose_Base::StartDay().

GetBestFeedingScore()

GooseMemoryLocation GooseMemoryMap::GetBestFeedingScore

(

)

Find the current best feeding location.

Returns

Best food resource memory in memory after taking threats and distance from roost into account

0 - If there are no memories return an impossible score to trigger explore 1 - Loop through all locations. 2 - Keep track of the best score. 3 - We need a way out if nothing is at all suitable, so if score is too small return a dummy location with a big negative score. 4 - Return the best scoring location if we have one.

Definition at line 236 of file GooseMemoryMap.cpp.

{
        double score = -9999.0;
        if (m_memorylocations.size()<1)
        {
                GooseMemoryLocation gml;
                gml.m_score = score;
                return gml;
        }
 
        std::vector<GooseMemoryLocation>::iterator ci, ci_best;
        for (ci = m_memorylocations.begin(); ci != m_memorylocations.end(); ++ci)
        {
                if (ci->m_score>score)
                {
                        ci_best = ci;
                        score = ci->m_score;
                }
        }
        if (score < 1)
        {
                GooseMemoryLocation gml;
                gml.m_score = -9999;
                return gml;
        }
        return *(ci_best);
}

References GooseMemoryLocation::m_score.

Referenced by Goose_Base::st_ChooseForageLocation().

GetFoodRes()

double GooseMemoryMap::GetFoodRes

(

int

a_polyid

)

Get the food resource at location.

Parameters

a_polyid

[in] A unique polygon reference to a goose memory location.

Returns

Food resource memory at a_polyid

Here we make use of the fact that there should only be one of each entry, so no need to read the whole list.

Definition at line 206 of file GooseMemoryMap.cpp.

{
        std::vector<GooseMemoryLocation>::const_iterator ci;
        for (ci = m_memorylocations.begin(); ci != m_memorylocations.end(); ++ci)
        {
                if (ci->m_polygonid == a_polyid) return ci->m_foodresource;
        }
        GooseMemoryError("Polygonid not found", a_polyid);
        return 0; // compiler happiness
}

GetThreat()

double GooseMemoryMap::GetThreat

(

int

a_polyid

)

Get the threat level at location.

Parameters

a_polyid

[in] A unique polygon reference to a goose memory location.

Returns

Threat memory at a_polyid

Here we make use of the fact that there should only be one of each entry, so no need to read the whole list.

Definition at line 221 of file GooseMemoryMap.cpp.

{
        std::vector<GooseMemoryLocation>::const_iterator ci;
        for (ci = m_memorylocations.begin(); ci != m_memorylocations.end(); ++ci)
        {
                if (ci->m_polygonid == a_polyid) return ci->m_threat;
        }
        GooseMemoryError("Polygonid not found", a_polyid);
        return 0; // compiler happiness
}

GetTotalThreats()

double GooseMemoryMap::GetTotalThreats

(

void

)

Get total of threat currently remembered.

Returns

The sum of total threats remembered

1 - Loop through all locations.

2 - Sum the threats and return this.

Definition at line 323 of file GooseMemoryMap.cpp.

{
        double theThreat = 0.0;
        std::vector<GooseMemoryLocation>::iterator it;
        for (it = m_memorylocations.begin(); it != m_memorylocations.end(); ++it)
        {
                theThreat += it->m_threat;
        }
        return theThreat;
}

GooseMemoryError()

void GooseMemoryMap::GooseMemoryError ( std::string  a_str, int  a_value  )

protected

Error message functionality.

Parameters

[in]	a_str	A string to send as output
[in]	a_value	A value to send as output

Opens a file called GooseMemoryMapError.txt and prints an error message before dumping the contents of the current memory. The program then closes.

Definition at line 341 of file GooseMemoryMap.cpp.

{
        std::ofstream ofile("GooseMemoryMapError.txt", std::ios::app | std::ios::out);
        ofile << a_str << ':' << a_value << std::endl;
        // Dumping goose memory
        std::vector<GooseMemoryLocation>::iterator ci;
        ofile << "polygonid" << '\t' << "m_x" << '\t' << "m_y" << '\t' << "foodresource" << '\t' << "threat" << std::endl;
        for (ci = m_memorylocations.begin(); ci != m_memorylocations.end(); ++ci)
        {
                ofile << ci->m_polygonid << '\t' << ci->m_x << '\t' << ci->m_y << '\t' << ci->m_foodresource << '\t' << ci->m_threat << std::endl;
        }
        ofile.close();
        exit(9);
}

IsKnownArea()

bool GooseMemoryMap::IsKnownArea

(

int

a_polyid

)

Check if this location is known.

Parameters

a_polyid

[in] A unique polygon reference to a goose memory location.

Returns

true if we have this polygon otherwise false.

Loop through all locations and see if we have this polygon

If we have it, return true, otherwise return false.

Definition at line 282 of file GooseMemoryMap.cpp.

{
        std::vector<GooseMemoryLocation>::iterator it;
        for (it = m_memorylocations.begin(); it != m_memorylocations.end(); ++it)
        {
                if (it->m_polygonid == a_polyid) return true;
        }
        return false;
}

Referenced by Goose_Base::st_ChooseForageLocation().

MemAdd()

void GooseMemoryMap::MemAdd

(

GooseMemoryLocation

a_gml

)

Add a new memory location.

Parameters

a_gml

[in] A goose memory location to add to the memory list.

Here we make use of the fact that there should only be one of each entry, so no need to read the whole list, just stop when we find one bigger and insert before it.
However, perhaps we have been here before, so just in case make a test and quitely update the memory if we find this polygon id in the list.
If no polygon ids are bigger or equal to ours then we need to add ours to the end of the list.

Definition at line 50 of file GooseMemoryMap.cpp.

{
        if (m_memorylocations.size() == 0)
        {
                m_memorylocations.push_back(a_gml);
                return;
        }
        int polyid = a_gml.m_polygonid;
        std::vector<GooseMemoryLocation>::iterator ci;
        for (ci = m_memorylocations.begin(); ci != m_memorylocations.end(); ++ci)
        {
                if (ci->m_polygonid>polyid)
                {
                        m_memorylocations.insert(ci, a_gml);
                        return;
                }
                if (ci->m_polygonid == polyid)
                {
                        // We have been here before so update memory
                        ci->m_grain = a_gml.m_grain;
                        ci->m_maize = a_gml.m_maize;
                        ci->m_grazing = a_gml.m_grazing;
                        ci->m_foodresource = a_gml.m_foodresource;
                        return;
                }
                // the only possibility left is that polyid is > than any on our list, so push it to the end
        }
        m_memorylocations.push_back(a_gml);
}

References GooseMemoryLocation::m_foodresource, GooseMemoryLocation::m_grain, GooseMemoryLocation::m_grazing, GooseMemoryLocation::m_maize, and GooseMemoryLocation::m_polygonid.

Referenced by Goose_Base::EvaluateForageToHopLoc(), Goose_Base::On_Bang(), and Goose_Base::st_ChooseForageLocation().

MemDel()

bool GooseMemoryMap::MemDel

(

int

a_polyid

)

Delete a memory location.

Parameters

a_polyid

[in] A unique polygon reference to a goose memory location.

Returns

success

Here we make use of the fact that there should only be one of each entry, so no need to read the whole list, just stop when we find the right one and remove it

Definition at line 87 of file GooseMemoryMap.cpp.

{
        for (std::vector<GooseMemoryLocation>::iterator ci = m_memorylocations.begin(); ci != m_memorylocations.end(); ++ci)
        {
                if (ci->m_polygonid == a_polyid)
                {
                        m_memorylocations.erase(ci);
                        return true;
                }
        }
        return false;
}

Referenced by Goose_Base::st_Forage().

Member Data Documentation

m_expectedforagingtime

int GooseMemoryMap::m_expectedforagingtime

protected

the time in minutes a goose expects to be able to forage when evaluating cost benefit of flying to a location.

Definition at line 101 of file GooseMemoryMap.h.

m_memorylocations

std::vector<GooseMemoryLocation> GooseMemoryMap::m_memorylocations

protected

The list of memory locations.

Definition at line 103 of file GooseMemoryMap.h.

Referenced by ~GooseMemoryMap().

m_myOwner

Goose_Base* GooseMemoryMap::m_myOwner

protected

pointer to the owner

Definition at line 97 of file GooseMemoryMap.h.

m_threatdecayrate

double GooseMemoryMap::m_threatdecayrate

protected

The decay rate per day for threats.

Definition at line 99 of file GooseMemoryMap.h.

---

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

• GooseMemoryMap.h
• GooseMemoryMap.cpp