Cell.cpp

/*----------------------------------------------------------------------------
 *
 *	Copyright (C) 2026 Greta Bocedi, Stephen C.F. Palmer, Justin M.J. Travis, Anne-Kathleen Malchow, Roslyn Henry, Théo Pannetier, Jette Wolff, Damaris Zurell
 *
 *	This file is part of RangeShifter.
 *
 *	RangeShifter is free software: you can redistribute it and/or modify
 *	it under the terms of the GNU General Public License as published by
 *	the Free Software Foundation, either version 3 of the License, or
 *	(at your option) any later version.
 *
 *	RangeShifter is distributed in the hope that it will be useful,
 *	but WITHOUT ANY WARRANTY; without even the implied warranty of
 *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *	GNU General Public License for more details.
 *
 *	You should have received a copy of the GNU General Public License
 *	along with RangeShifter. If not, see <https://www.gnu.org/licenses/>.
 *
 --------------------------------------------------------------------------*/


//---------------------------------------------------------------------------

#include "Cell.h"

//---------------------------------------------------------------------------

//---------------------------------------------------------------------------

// Cell functions

Cell::Cell(int xx,int yy,Patch *patch,int hab)
{
	x = xx; y = yy;
	pPatch = patch;
	envVal = 1.0; // default - no effect of any gradient
	envDev = eps = 0.0;
	habIxx.push_back(hab);
	visits = 0;
	smsData = 0;
}

Cell::Cell(int xx,int yy,Patch *patch,float hab)
{
	x = xx; y = yy;
	pPatch = patch;
	envVal = 1.0; // default - no effect of any gradient
	envDev = eps = 0.0;
	habitats.push_back(hab);
	visits = 0;
	smsData = 0;
}

Cell::~Cell() {
	habIxx.clear();
	habitats.clear();
	if (smsData != 0) {
		if (smsData->effcosts != 0) delete smsData->effcosts;
		delete smsData;
	}
demoScalings.clear();

#if RSDEBUG
//DEBUGLOG << "Cell::~Cell(): deleted" << endl;
#endif
}

void Cell::setHabIndex(short hx) {
	if (hx < 0) habIxx.push_back(0);
	else habIxx.push_back(hx);
}

void Cell::changeHabIndex(short ix,short hx) {
	if (ix >= 0 && ix < (short)habIxx.size() && hx >= 0) habIxx[ix] = hx;
	else habIxx[ix] = 0;
}

int Cell::getHabIndex(int ix) {
	if (ix < 0 || ix >= (int)habIxx.size())
		// nodata cell OR should not occur, but treat as such
		return -1;
	else return habIxx[ix];
}
int Cell::nHabitats(void) {
	int nh = (int)habIxx.size();
	if ((int)habitats.size() > nh) nh = (int)habitats.size();
	return nh;
}

void Cell::setHabitat(float q) {
	if (q >= 0.0 && q <= 100.0) habitats.push_back(q);
	else habitats.push_back(0.0);
}

float Cell::getHabitat(int ix) {
	if (ix < 0 || ix >= (int)habitats.size())
		// nodata cell OR should not occur, but treat as such
		return -1.0;
	else return habitats[ix];
}

void Cell::setPatch(Patch *p) {
	pPatch = p;
}
Patch *Cell::getPatch(void)
{
	return pPatch;
}

locn Cell::getLocn(void) { locn q; q.x = x; q.y = y; return q; }

void Cell::setEnvDev(float d) { envDev = d; }

float Cell::getEnvDev(void) { return envDev; }

void Cell::setEnvVal(float e) {
	if (e >= 0.0) envVal = e;
}

float Cell::getEnvVal(void) { return envVal; }

void Cell::updateEps(float ac,float randpart) {
	eps = eps * ac + randpart;
}

float Cell::getEps(void) { return eps; }

// Functions to handle costs for SMS

#ifdef _OPENMP
std::unique_lock<std::mutex> Cell::lockCost() {
	return std::unique_lock<std::mutex>(cost_mutex);
}
#endif

int Cell::getCost(void) {
	int c;
	if (smsData == 0) c = 0; // costs not yet set up
	else c = smsData->cost;
	return c;
}

void Cell::setCost(int c) {
	if (smsData == 0) {
		smsData = new smscosts;
		smsData->effcosts = 0;
	}
	smsData->cost = c;
}

// Reset the cost and the effective cost of the cell
void Cell::resetCost(void) {
	if (smsData != 0) { resetEffCosts(); delete smsData; }
	smsData = 0;
}

array3x3f Cell::getEffCosts(void) {
	array3x3f a;
	if (smsData == 0 || smsData->effcosts == 0) { // effective costs have not been calculated
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 3; j++) {
				a.cell[i][j] = -1.0;
			}
		}
	}
	else
		a = *smsData->effcosts;
	return a;
}

void Cell::setEffCosts(array3x3f a) {
	if (smsData->effcosts == 0) smsData->effcosts = new array3x3f;
	*smsData->effcosts = a;
}

// Reset the effective cost, but not the cost, of the cell
void Cell::resetEffCosts(void) {
	if (smsData != 0) {
		if (smsData->effcosts != 0) {
			delete smsData->effcosts;
			smsData->effcosts = 0;
		}
	}
}

void Cell::resetVisits(void) { visits = 0; }
void Cell::incrVisits(void) { visits++; }
unsigned long int Cell::getVisits(void) { return visits; }


void Cell::addchgDemoScaling(std::vector<float> ds) {
	std::for_each(ds.begin(), ds.end(), [](float& perc){ if(perc < 0.0 || perc > 100.0) perc=100; });
	demoScalings.push_back(ds);
	return;
}

std::vector<float> Cell::getDemoScaling(short chgyear) {
	if (chgyear < 0 || chgyear >= (int)demoScalings.size()) {
		std::vector<float> ret(1, -1);
		return ret;
	}
	else return demoScalings[chgyear];
}



//---------------------------------------------------------------------------

// Initial species distribution cell functions

DistCell::DistCell(int xx,int yy) {
	x = xx;
	y = yy;
	initialise = false;
}

DistCell::~DistCell() {

}

void DistCell::setCell(bool init) {
	initialise = init;
}

bool DistCell::toInitialise(locn loc) {
	if (loc.x == x && loc.y == y) return initialise;
	else return false;
}

bool DistCell::selected(void) { return initialise; }

locn DistCell::getLocn(void) {
	locn loc;
	loc.x = x;
	loc.y = y;
	return loc;
}

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------