heapified vector throws invalid heap on push_heap call - c++

Question

I am working on a simple 4 neighbour c++ implementation of A* path finding, using an stl heapified vector(with a less than predicate). When I run the program, It throws an invalid heap debug assertation. I can run through the code in the debugger, and inspected the data stored in the vector, which is correctly storing positions in ascending order of F cost. I can't quite see what I'm doing wrong:
//simple function for finding the index of a position in a vector that matches a search position
int find(std::vector<AStarPosition*>& p_Vec,AStarPosition* p_SearchParam)
{
for (size_t i = 0; i < p_Vec.size();i++)
{
if(p_Vec[i]->equals(p_SearchParam))
return i;
}
return -1;
}
//min heap predicate function
bool less(AStarPosition* a, AStarPosition* b)
{
return (a->F < b->F);
}
void AIManager::getNextPathCell(glm::vec3 p_startPosition, glm::vec3 p_targetPosition,std::vector<glm::ivec2>& path)
{
glm::ivec2 startPos = m_maze->getGridCell(p_startPosition);
glm::ivec2 goalPos = m_maze->getGridCell(p_targetPosition);
AStarPosition* start = m_Pool->getPosition(nullptr,startPos.x,startPos.y);
AStarPosition* goal = m_Pool->getPosition(nullptr,goalPos.x,goalPos.y);
start->estimateCost(goal);
bool pathFound = false;
//used to hold positions representing visited grid positions
std::vector<AStarPosition*> usedList;
//create a min heap to hold positions
std::vector<AStarPosition*> openList;
//add the start to the min heap
openList.push_back(start);
std::make_heap(openList.begin(),openList.end(),less);
//set all closed list values to zero (false)
for (size_t i = 0; i < m_closedList.size();i++)
{
std::fill(m_closedList[i].begin(),m_closedList[i].end(),0);
}
//main algorithm:
while(openList.size() > 0)
{
//remove root from openList (position with lowest F cost)
AStarPosition* parent = openList.front();
std::pop_heap(openList.begin(),openList.end(),less);
openList.pop_back();
usedList.push_back(parent);
//if current position == goal
if(parent->equals(goal))
{
pathFound = true;
break;
}
//get successor positions (4)
m_closedList[parent->x][parent->y] = 1;
AStarPosition* successors[4];
//NORTH
successors[0] = m_Pool->getPosition(parent,0,1);
//WEST
successors[1] = m_Pool->getPosition(parent,1,0);
//SOUTH
successors[2] = m_Pool->getPosition(parent,0,-1);
//EAST
successors[3] = m_Pool->getPosition(parent,-1,0);
//for each successor loop
for (int i = 0; i < 4;i++)
{
//if position is a wall or outside maze maze
if(!m_maze->isOk(glm::ivec2(successors[i]->x,successors[i]->y)))
{
//continue
successors[i]->inUse = false;
successors[i] = nullptr;
continue;
}
//if position has been visited
if(m_closedList[successors[i]->x][successors[i]->y]==1)
{
//find position within used list, as more checks are needed
int pos = find(usedList,successors[i]);
//if it has
if(pos!=-1)
{
//and the closed list is less or equal to the successor
//ie a better path than successor
if(usedList[pos]->G <= successors[i]->m_Parent->G+10)
{
//return position to pool and skip to next successor
successors[i]->inUse = false;
successors[i] = nullptr;
continue;
}
else
{
//remove position from the closed list, and return position to pool
usedList[pos]->inUse = false;
m_closedList[successors[i]->x][successors[i]->y] = 0;
usedList.erase(usedList.begin()+pos);
}
}
}
//else if current exists within openlist
int pos = find(openList,successors[i]);
if(pos!=-1)
{
//if current G cost is lower (closer to start, so better path), set openlist entry G as current G and copy parent
if(openList[pos]->G > successors[i]->G)
{
//recalculate F score of openlist entry
openList[pos]->G=successors[i]->G;
openList[pos]->m_Parent=successors[i]->m_Parent;
openList[pos]->estimateCost(goal);
//and resort list
std::sort_heap(openList.begin(),openList.end(),less);
}
successors[i]->inUse = false;
successors[i] = nullptr;
continue;
}
//else not in open list
else
{
//insert successor into open list
openList.push_back(successors[i]);
successors[i]->estimateCost(goal);
////////////////////////////////////////////////////
//line below crashes program
std::push_heap(openList.begin(),openList.end(),less);
}
}
}
if(pathFound)
{
//reconstruct path
AStarPosition* current = usedList.back();
while(!start->equals(current))
{
path.push_back(glm::ivec2(current->x,current->y));
current=current->m_Parent;
}
}
//and clean up
for (std::vector<AStarPosition*>::iterator it = openList.begin();it!=openList.end();)
{
(*it)->inUse=false;
it = openList.erase(it);
}
for (std::vector<AStarPosition*>::iterator it = usedList.begin();it!=usedList.end();)
{
(*it)->inUse=false;
it = usedList.erase(it);
}
}
I've marked the line that is causing the crash. Am I using the heap functions incorrectly?