/**
* Returns the last ministep of the given option in the subchain starting
* with the given ministep, or pFirst, if there is no such a ministep.
*/
MiniStep * Chain::pLastMiniStepForLink(const MiniStep * pLinkMiniStep) const
{
int ego = pLinkMiniStep->ego();
const NetworkChange * pLinkNetworkChange =
dynamic_cast<const NetworkChange *>(pLinkMiniStep);
int alter = pLinkNetworkChange->alter();
const ActorSet * pActorSet1 =
this->lpData->pNetworkData(pLinkMiniStep->variableName())->pSenders();
const ActorSet * pActorSet2 =
this->lpData->pNetworkData(pLinkMiniStep->variableName())->pReceivers();
MiniStep * pLastMiniStep = this->lpFirst;
MiniStep * pMiniStep = this->lpFirst->pNext();
while (pMiniStep != this->lpLast)
{
if (pMiniStep->networkMiniStep())
{
const NetworkChange * pNetworkChange =
dynamic_cast<const NetworkChange *>(pMiniStep);
if (pMiniStep->ego() == ego &&
pNetworkChange->alter() == alter)
{
NetworkLongitudinalData * pNetwork =
this->lpData->pNetworkData(pMiniStep->variableName());
if (pNetwork->pSenders() == pActorSet1 &&
pNetwork->pReceivers() == pActorSet2)
{
pLastMiniStep = pMiniStep;
}
}
}
pMiniStep = pMiniStep->pNext();
}
return pLastMiniStep;
}
/**
* Initializes this function.
* @param[in] pData the observed data
* @param[in] pState the current state of the dependent variables
* @param[in] period the period of interest
* @param[in] pCache the cache object to be used to speed up calculations
*/
void OutdegreePopularityEffect::initialize(const Data * pData,
State * pState,
int period,
Cache * pCache)
{
NetworkEffect::initialize(pData, pState, period, pCache);
if (this->lcentered)
{
NetworkLongitudinalData * pNetworkData =
pData->pNetworkData(this->lvariableName);
this->lcentering = pNetworkData->averageOutDegree();
}
}
/**
* Returns the first ministep of the ego, alter, actor set1, actor set 2,
* or pLast if there is no such a ministep.
*/
MiniStep * Chain::pFirstMiniStepForLink(const MiniStep * pLinkMiniStep) const
{
int ego = pLinkMiniStep->ego();
const NetworkChange * pLinkNetworkChange =
dynamic_cast<const NetworkChange *>(pLinkMiniStep);
int alter = pLinkNetworkChange->alter();
const ActorSet * pActorSet1 =
this->lpData->pNetworkData(pLinkMiniStep->variableName())->pSenders();
const ActorSet * pActorSet2 =
this->lpData->pNetworkData(pLinkMiniStep->variableName())->pReceivers();
bool done = false;
MiniStep * pMiniStep = this->lpFirst->pNext();
while (pMiniStep != this->lpLast && !done)
{
if (pMiniStep->networkMiniStep())
{
const NetworkChange * pNetworkChange =
dynamic_cast<const NetworkChange *>(pMiniStep);
if (pMiniStep->ego() == ego &&
pNetworkChange->alter() == alter)
{
NetworkLongitudinalData * pNetwork =
this->lpData->pNetworkData(pMiniStep->variableName());
if (pNetwork->pSenders() == pActorSet1 &&
pNetwork->pReceivers() == pActorSet2)
{
done = true;
break;
}
}
}
pMiniStep = pMiniStep->pNext();
}
if (pMiniStep != this->lpLast)
{
PrintValue(getMiniStepDF(*pMiniStep));
}
else
Rprintf("last\n");
return pMiniStep;
}
int approxNetworkLongitudinalData(const NetworkLongitudinalData& r) {
int size = sizeof(r);
// networks
for (int i = 0; i < r.observationCount(); ++i) {
size += approxNetwork(*r.pNetwork(i));
size += approxNetwork(*r.pStructuralTieNetwork(i));
size += approxNetwork(*r.pMissingTieNetwork(i));
size += approxNetwork(*r.pNetworkLessMissing(i));
size += approxNetwork(*r.pNetworkLessMissingStart(i));
}
// ldensity
size += r.observationCount() * sizeof(double);
LOGF(Priority::DEBUG, "NetworkLongitudinalData\t%s\t%d b", r.name().c_str(),
size);
return size;
}
/**
* sets up the model options of MAXDEGREE, UNIVERSALOFFSET, CONDITIONAL
*/
SEXP setupModelOptions(SEXP DATAPTR, SEXP MODELPTR, SEXP MAXDEGREE,
SEXP UNIVERSALOFFSET,
SEXP CONDVAR, SEXP CONDTARGETS, SEXP PROFILEDATA, SEXP PARALLELRUN,
SEXP MODELTYPE, SEXP SIMPLERATES, SEXP NORMSETRATES)
{
/* get hold of the data vector */
vector<Data *> * pGroupData = (vector<Data *> *)
R_ExternalPtrAddr(DATAPTR);
int nGroups = pGroupData->size();
/* get hold of the model object */
Model * pModel = (Model *) R_ExternalPtrAddr(MODELPTR);
if(!isNull(NORMSETRATES)){
pModel->normalizeSettingRates(*(LOGICAL(NORMSETRATES)));
}
int totObservations = totalPeriods(*pGroupData);
pModel->numberOfPeriods(totObservations);
if (!isNull(CONDVAR))
{
int *change = INTEGER(CONDTARGETS);
pModel->conditional(true);
pModel->conditionalDependentVariable(CHAR(STRING_ELT(CONDVAR,0)));
int i = 0;
for (int group = 0; group < nGroups; group++)
{
Data * pData = (*pGroupData)[group];
for (int period = 0;
period < pData->observationCount() - 1;
period++)
{
pModel->targetChange(pData, period, change[i]);
i++;
}
}
}
/* get names vector for max degree */
if (!isNull(MAXDEGREE))
{
SEXP Names = getAttrib(MAXDEGREE, R_NamesSymbol);
for (int group = 0; group < nGroups; group++)
{
for (int i = 0; i < length(Names); i++)
{
Data * pData = (*pGroupData)[group];
NetworkLongitudinalData * pNetworkData =
pData->pNetworkData(CHAR(STRING_ELT(Names, i)));
pNetworkData->maxDegree(INTEGER(MAXDEGREE)[i]);
}
}
}
/* get names vector for UniversalOffset */
if (!isNull(UNIVERSALOFFSET))
{
SEXP Names = getAttrib(UNIVERSALOFFSET, R_NamesSymbol);
for (int group = 0; group < nGroups; group++)
{
for (int i = 0; i < length(Names); i++)
{
Data * pData = (*pGroupData)[group];
NetworkLongitudinalData * pNetworkData =
pData->pNetworkData(CHAR(STRING_ELT(Names, i)));
pNetworkData->universalOffset(REAL(UNIVERSALOFFSET)[i]);
}
}
}
/* set the parallel run flag on the model */
if (!isNull(PARALLELRUN))
{
pModel->parallelRun(true);
}
if (!isNull(MODELTYPE))
{
pModel->modelType(asInteger(MODELTYPE));
}
// print out Data for profiling
if (asInteger(PROFILEDATA))
{
printOutData((*pGroupData)[0]);
}
pModel->simpleRates(asInteger(SIMPLERATES));
return R_NilValue;
}
/**
* Generates a chain connecting the original and simulated initial
* observations of the given data object for the given period.
* The chain is simple in the sense that no two ministeps cancel each other out.
*/
void Chain::createInitialStateDifferences()
{
deallocateVector(this->linitialStateDifferences);
//Rprintf("******** %d create initial\n",this->linitialStateDifferences.size() );
Data * pData = this->lpData;
State * initialState = this->lpInitialState;
int period = this->lperiod;
// Create the required ministeps
for (unsigned variableIndex = 0;
variableIndex < pData->rDependentVariableData().size();
variableIndex++)
{
LongitudinalData * pVariableData =
pData->rDependentVariableData()[variableIndex];
NetworkLongitudinalData * pNetworkData =
dynamic_cast<NetworkLongitudinalData *>(pVariableData);
BehaviorLongitudinalData * pBehaviorData =
dynamic_cast<BehaviorLongitudinalData *>(pVariableData);
if (pNetworkData)
{
const Network * pNetwork1 = pNetworkData->pNetwork(period);
const Network * pNetwork2 =
initialState->pNetwork(pNetworkData->name());
for (int i = 0; i < pNetwork1->n(); i++)
{
IncidentTieIterator iter1 = pNetwork1->outTies(i);
IncidentTieIterator iter2 = pNetwork2->outTies(i);
while (iter1.valid() || iter2.valid())
{
if (iter1.valid() &&
(!iter2.valid() || iter1.actor() < iter2.actor()))
{
if (!pNetworkData->structural(i, iter1.actor(),
period)
// || !pNetworkData->structural(i, iter1.actor(),
// period + 1)
)
{
NetworkChange * pMiniStep =
new NetworkChange(pNetworkData,
i,
iter1.actor(), false);
// PrintValue(getMiniStepDF(*pMiniStep));
this->linitialStateDifferences.
push_back(pMiniStep);
iter1.next();
// PrintValue(getMiniStepDF(
// *this->linitialStateDifferences.back()));
}
else
{
// create step in structural subchain?
}
}
else if (iter2.valid() &&
(!iter1.valid() || iter2.actor() < iter1.actor()))
{
if (!pNetworkData->structural(i, iter2.actor(),
period)
// || !pNetworkData->structural(i, iter2.actor(),
// period + 1)
)
{
this->linitialStateDifferences.push_back(
new NetworkChange(pNetworkData,
i,
iter2.actor(), false));
iter2.next();
//PrintValue(getMiniStepDF(
// *this->linitialStateDifferences.back()));
}
else
{
// create step in structural subchain?
}
}
else
{
iter1.next();
iter2.next();
}
}
}
}
else if (pBehaviorData)
{
for (int i = 0; i < pBehaviorData->n(); i++)
{
int delta = initialState->
behaviorValues(pBehaviorData->name())[i]
- pBehaviorData->value(period, i);
int singleChange = 1;
if (delta < 0)
{
delta = -delta;
singleChange = -1;
}
for (int j = 0; j < delta; j++)
{
if (!pBehaviorData->structural(period, j)
//|| !pBehaviorData->structural(period, j + 1)
)
{
this->linitialStateDifferences.push_back(
new BehaviorChange(pBehaviorData,
i,
singleChange));
// Rprintf(" %d %d in beh\n", i, singleChange);
}
else
{
// create step in structural subchain?
}
}
}
}
}
// Rprintf("xx ********%d %d end create initial diff\n", this->linitialStateDifferences.size(), period);
}
/**
* Generates a random chain connecting the start and end observations of the
* given data object for the given period. The chain is simple in the sense
* that no two ministeps cancel each other out.
*/
void Chain::connect(int period, MLSimulation * pMLSimulation)
{
this->clear();
this->lperiod = period;
vector<MiniStep *> miniSteps;
// Create the required ministeps
for (unsigned variableIndex = 0;
variableIndex < this->lpData->rDependentVariableData().size();
variableIndex++)
{
LongitudinalData * pVariableData =
this->lpData->rDependentVariableData()[variableIndex];
NetworkLongitudinalData * pNetworkData =
dynamic_cast<NetworkLongitudinalData *>(pVariableData);
BehaviorLongitudinalData * pBehaviorData =
dynamic_cast<BehaviorLongitudinalData *>(pVariableData);
if (pNetworkData)
{
const Network * pNetwork1 = pNetworkData->pNetwork(period);
const Network * pNetwork2 = pNetworkData->pNetwork(period + 1);
for (int i = 0; i < pNetwork1->n(); i++)
{
IncidentTieIterator iter1 = pNetwork1->outTies(i);
IncidentTieIterator iter2 = pNetwork2->outTies(i);
while (iter1.valid() || iter2.valid())
{
if (iter1.valid() &&
(!iter2.valid() || iter1.actor() < iter2.actor()))
{
if (!pNetworkData->structural(i, iter1.actor(),
period)
// || !pNetworkData->structural(i, iter1.actor(),
// period + 1)
)
{
miniSteps.push_back(
new NetworkChange(pNetworkData,
i,
iter1.actor(), false));
iter1.next();
}
else
{
// create step in structural subchain?
}
}
else if (iter2.valid() &&
(!iter1.valid() || iter2.actor() < iter1.actor()))
{
if (!pNetworkData->structural(i, iter2.actor(),
period)
// || !pNetworkData->structural(i, iter2.actor(),
// period + 1)
)
{
miniSteps.push_back(
new NetworkChange(pNetworkData,
i,
iter2.actor(), false));
iter2.next();
}
else
{
// create step in structural subchain?
}
}
else
{
iter1.next();
iter2.next();
}
}
}
}
else if (pBehaviorData)
{
for (int i = 0; i < pBehaviorData->n(); i++)
{
int delta = pBehaviorData->value(period + 1, i) -
pBehaviorData->value(period, i);
int singleChange = 1;
if (delta < 0)
{
delta = -delta;
singleChange = -1;
}
for (int j = 0; j < delta; j++)
{
if (!pBehaviorData->structural(period, j)
//|| !pBehaviorData->structural(period, j + 1)
)
{
miniSteps.push_back(
new BehaviorChange(pBehaviorData,
i,
singleChange));
}
else
{
// create step in structural subchain?
}
}
}
}
}
// If we have no constraints we can go ahead and add to the chain in a
// random order. If we do have contraints we need to make sure our chain
// is valid. For now we have two distinct loops:
if (this->lpData->rNetworkConstraints().size() == 0)
{
// Randomize the ministeps
for (unsigned i = 1; i < miniSteps.size(); i++)
{
int j = nextInt(i + 1);
MiniStep * pTempMiniStep = miniSteps[i];
miniSteps[i] = miniSteps[j];
miniSteps[j] = pTempMiniStep;
}
// And finally add the ministeps to this chain
for (unsigned i = 0; i < miniSteps.size(); i++)
{
this->insertBefore(miniSteps[i], this->lpLast);
}
}
else
{
unsigned count = 0;
vector<MiniStep *> remainingMiniSteps;
while(miniSteps.size() > 0 &&
count < this->lpData->rDependentVariableData().size())
{
count++;
remainingMiniSteps.clear();
for (unsigned i = 0; i < miniSteps.size(); i++)
{
// first try random insert
//const NetworkChange * pNetworkChange =
// dynamic_cast<const NetworkChange *>(miniSteps[i]);
MiniStep * pMiniStep =
this->randomMiniStep(this->lpFirst->pNext(),
this->lpLast);
bool valid = false;
if (miniSteps[i]->behaviorMiniStep())
{
valid = true;
}
else
{
// get current state at this place
pMLSimulation->initialize(this->lperiod);
pMLSimulation->executeMiniSteps(this->lpFirst->pNext(),
pMiniStep);
// see if valid here
DependentVariable * pVariable =
pMLSimulation->rVariables()[miniSteps[i]->variableId()];
// PrintValue(getMiniStepDF(*miniSteps[i]));
if (!pVariable->validMiniStep(miniSteps[i]))
{
// Rprintf("first inval\n");
// no go, so try to find somewhere else to put it
MiniStep * pLastMiniStep =
this->pLastMiniStepForLink(miniSteps[i]);
if (pLastMiniStep != this->lpFirst)
{
// Rprintf("lastl\n");
// PrintValue(getMiniStepDF(*pLastMiniStep));
pMiniStep =
this->randomMiniStep(pLastMiniStep->pNext(),
this->lpLast);
// PrintValue(getMiniStepDF(*pMiniStep));
pMLSimulation->initialize(this->lperiod);
pMLSimulation->executeMiniSteps(this->lpFirst->
pNext(), pMiniStep);
// see if valid here
if (!pVariable->validMiniStep(miniSteps[i]))
{
// Rprintf("second inval\n");
// no go, so try to find somewhere else to put
// it
MiniStep * pFirstMiniStep =
this->pFirstMiniStepForLink(miniSteps[i]);
// if (pFirstMiniStep != this->lpFirst)
//{
// PrintValue(getMiniStepDF(*pFirstMiniStep));
pMiniStep =
this->randomMiniStep(this->
lpFirst->pNext(),
pFirstMiniStep);
// PrintValue(getMiniStepDF(*pMiniStep));
pMLSimulation->initialize(this->lperiod);
pMLSimulation->
executeMiniSteps(pFirstMiniStep,
pMiniStep);
// see if valid here
if (pVariable->validMiniStep(miniSteps[i]))
{
Rprintf("thirsd true val\n");
valid = true;
}
// }
}
else
{
valid = true;
}
}
}
else
{
valid = true;
}
}
if (valid)
{
this->insertBefore(miniSteps[i], pMiniStep);
}
else
{
remainingMiniSteps.push_back(miniSteps[i]);
}
}
miniSteps = remainingMiniSteps;
}
// PrintValue(getChainDF(*this, false));
// Rprintf("****** count %d\n", count);
if (miniSteps.size() > 0)
{
for (unsigned i = 0; i < miniSteps.size(); i++)
{
PrintValue(getMiniStepDF(*miniSteps[i]));
}
error("Cannot create minimal chain due to constraints");
}
}
}
