double poisdev(const double xm)
{
const double PI=3.141592653589793238;
static double sq,alxm,g,oldm=(-1.0);
double em,t,y;
if (xm < 12.0) {
if (xm != oldm) {
oldm=xm;
g=exp(-xm);
}
em = -1;
t=1.0;
do {
++em;
t *= rnd.rand();;
} while (t > g);
} else {
if (xm != oldm) {
oldm=xm;
sq=sqrt(2.0*xm);
alxm=log(xm);
g=xm*alxm-gammln(xm+1.0);
}
do {
do {
y=tan(PI*rnd.rand());
em=sq*y+xm;
} while (em < 0.0);
em=floor(em);
t=0.9*(1.0+y*y)*exp(em*alxm-gammln(em+1.0)-g);
} while (rnd.rand() > t);
}
return em;
}
void runServerIO()
{
SOCKET c = Network::instance()->socket(AF_INET,SOCK_STREAM,IPPROTO_TCP,false);
sockaddr_in serverEP = {0};
serverEP.sin_family = AF_INET;
serverEP.sin_addr.s_addr = ::inet_addr("127.0.0.1");
serverEP.sin_port = ::htons(65534);
try {
Network::instance()->connect(c,serverEP);
} catch (const NetworkException& e) {
LOG(Error) << e.what();
Network::instance()->closeSocket(c);
::InterlockedIncrement(&failed);
return;
}
// Fill Data
MTRand r;
const int MAX = 1 >> 16;
std::vector<char> data(MAX);
for (int i = 0; i < MAX; ++i) {
data[i] = static_cast<char>(r.rand(255));
}
// Send and receive data in random chunks
int recvd = 0;
int sent = 0;
std::vector<char> echo(MAX);
while (sent < MAX) {
int nBytes = 1 + static_cast<int>(r.rand(MAX - sent - 1));
try {
sent += Network::instance()->send(c, &data[sent], nBytes);
} catch(const NetworkException& e) {
LOG(Error) << e.what();
}
while (recvd < sent) {
try {
recvd += Network::instance()->recv(c, &echo[recvd], nBytes);
} catch(const NetworkException& e) {
LOG(Error) << e.what();
}
}
CHECK(sent == recvd);
}
for (int i = 0; i < MAX; ++i) {
CHECK(data[i] == echo[i]);
}
Network::instance()->closeSocket(c);
::InterlockedIncrement(&succeeded);
}
Point GridDatabase2D::randomPositionInRegionWithoutCollisions(const AxisAlignedBox & region, float radius, bool excludeAgents, MTRand & randomNumberGenerator)
{
Point ret(0.0f, 0.0f, 0.0f);
bool notFoundYet;
unsigned int numTries = 0;
float xspan = region.xmax - region.xmin - 2*radius;
float zspan = region.zmax - region.zmin - 2*radius;
do {
ret.x = region.xmin + radius + ((float)randomNumberGenerator.rand(xspan));
ret.y = 0.0f;
ret.z = region.zmin + radius + ((float)randomNumberGenerator.rand(zspan));
// assume this new point has no collisions, until we find out below
notFoundYet = false;
// check if ret collides with anything
set<SpatialDatabaseItemPtr> neighbors;
neighbors.clear();
float _new_radius = radius;
getItemsInRange(neighbors, ret.x - _new_radius, ret.x + _new_radius, ret.z - _new_radius, ret.z + _new_radius, NULL);
set<SpatialDatabaseItemPtr>::iterator neighbor;
/*
* increment must be after loop body or (*neighbor)->isAgent()) will be called on an
* element that is beyond the set.
*/
for (neighbor = neighbors.begin(); neighbor != neighbors.end(); neighbor++)
{
if ((excludeAgents) && ((*neighbor)->isAgent()))
{
continue;
}
notFoundYet = (*neighbor)->overlaps(ret, radius);
if (notFoundYet)
{
break;
}
}
numTries++;
if (numTries > 1000)
{
cerr << "ERROR: trying too hard to find a random position in region. The region is probably already too dense." << endl;
if (numTries > 10000)
{
throw GenericException("Gave up trying to find a random position in region.");
}
}
} while (notFoundYet);
return ret;
}
Util::Point GridDatabase2D::randomPositionInRegion(const Util::AxisAlignedBox & region, float radius,MTRand & randomNumberGenerator)
{
Point ret(0.0f, 0.0f, 0.0f);
float xspan = region.xmax - region.xmin - 2*radius;
float zspan = region.zmax - region.zmin - 2*radius;
ret.x = region.xmin + radius + ((float)randomNumberGenerator.rand(xspan));
ret.y = 0.0f;
ret.z = region.zmin + radius + ((float)randomNumberGenerator.rand(zspan));
return ret;
}
double binldev(const double pp, const int n)
{
const double PI=3.141592653589793238;
int j;
static int nold=(-1);
double am,em,g,angle,p,bnl,sq,t,y;
static double pold=(-1.0),pc,plog,pclog,en,oldg;
p=(pp <= 0.5 ? pp : 1.0-pp);
am=n*p;
if (n < 25) {
bnl=0.0;
for (j=0;j<n;j++)
if (rnd.rand() < p) ++bnl;
} else if (am < 1.0) {
g=exp(-am);
t=1.0;
for (j=0;j<=n;j++) {
t *= rnd.rand();
if (t < g) break;
}
bnl=(j <= n ? j : n);
} else {
if (n != nold) {
en=n;
oldg=gammln(en+1.0);
nold=n;
} if (p != pold) {
pc=1.0-p;
plog=log(p);
pclog=log(pc);
pold=p;
}
sq=sqrt(2.0*am*pc);
do {
do {
angle=PI*rnd.rand();
y=tan(angle);
em=sq*y+am;
} while (em < 0.0 || em >= (en+1.0));
em=floor(em);
t=1.2*sq*(1.0+y*y)*exp(oldg-gammln(em+1.0)
-gammln(en-em+1.0)+em*plog+(en-em)*pclog);
} while (rnd.rand() > t);
bnl=em;
}
if (p != pp) bnl=n-bnl;
return bnl;
}
const TwitterEdge operator()(const TwitterEdge & x) const
{
short mycount = 1;
bool myfollow = 0;
time_t mylatest = static_cast<int64_t>(GlobalMT.rand() * 10000); // random.randrange(0,10000)
return TwitterEdge(mycount, myfollow, mylatest);
}
/**************************************************************************//**
* Return a random position close to the supplied one.
******************************************************************************/
dVec Cylinder::randUpdate (MTRand &random, const dVec &pos) const {
dVec randPos;
if (random.rand() < 0.5)
randPos = randUpdateJumpShell(random,pos);
else
randPos = randUpdateSmall(random,pos);
return randPos;
}
/**************************************************************************//**
* Return a random position close to the supplied one. Same Shell.
******************************************************************************/
dVec Cylinder::randUpdateSmall (MTRand &random, const dVec &pos) const {
dVec randPos;
randPos = pos;
for (int i = 0; i < NDIM; i++)
randPos[i] += constants()->displaceDelta()*(-0.5 + random.rand());
putInside(randPos);
return randPos;
}
double p3d_random(double a, double b)
{double v;
// C library implementation
// v = rand()/((double)RAND_MAX+1); /* nombre aleatoire [0.,1.] */
v = mersenne_twister_rng.rand();
v = (b-a)*v + a;
return(v);
}
void GenericLayer::initNeurons() {
this->neurons.clear();
this->neurons.resize(numNeurons);
MTRand mt;
// #pragma omp parallel for if(this->numNeurons > 500)
for (int i=0; i<this->numNeurons; ++i) {
this->neurons.at(i).biasWeight = mt.rand(2)-1.0f;
}
}
// a clock can be intialized with source data (parents)
bioClock::bioClock (bioClock source1, bioClock source2)
{
// creates an MTRand that can make random numbers
MTRand randGen;
double randNum;
double remainingPercent;
// initialize survival score
mSurvivalScore = 0;
// initialize number of working hands
mNumHands = 0;
// get the genome size from one of the parents (doesn't really matter which one)
mGenomeSize = source1.mGenomeSize;
mClockGenome.resize(mGenomeSize);
// get mutation rate from a parent (doesn't matter which one)
mMutationRate = source1.mMutationRate;
// fill genome with either a random (mutated) gene, or an equal chance of a mother's or father's gene
for (int i = 0; i < mGenomeSize; i++)
{
mClockGenome[i].resize(mGenomeSize);
for (int j = 0; j < mGenomeSize; j++)
{
// random real number from 0-1
randNum = randGen.rand();
// calculate remaining percent left after accounting for mutation rate
remainingPercent = 1 - (mMutationRate / 100);
// create a random piece upon mutation
if (randNum > remainingPercent)
{
clockPiece tempPiece;
mClockGenome[i][j] = tempPiece;
}
// otherwise it's split 50/50 for inheritance of traits from mother or father
// copy the piece from parent
else if (randNum > (remainingPercent / 2))
mClockGenome[i][j] = source1.mClockGenome[i][j];
else
mClockGenome[i][j] = source2.mClockGenome[i][j];
// reset connection status of copied piece
mClockGenome[i][j].mIsConnected = false;
// reset more data for gears
mClockGenome[i][j].setIsPowered(false);
mClockGenome[i][j].setIsAttToHand(false);
mClockGenome[i][j].setPieceInterval(0);
}
}
}
double ran(){
//<<<<<<< HEAD
MTRand random;
random.seed();
return random.rand();
// return rand()/double(RAND_MAX);
//=======
static MTRand my_mtrand;
return my_mtrand.randExc(); // which is the range of [0,1)
//>>>>>>> 2511a06ab322dcea9f3f70080c443d0938562932
}
void PhotonMapping::TracePhoton(const Vec3f &position, const Vec3f &direction,
const Vec3f &energy, int iter) {
// ==============================================
// ASSIGNMENT: IMPLEMENT RECURSIVE PHOTON TRACING
// ==============================================
// Trace the photon through the scene. At each diffuse or
// reflective bounce, store the photon in the kd tree.
// One optimization is to *not* store the first bounce, since that
// direct light can be efficiently computed using classic ray
// tracing.
//do ray cast
Ray r(position,direction*(1/direction.Length()));
Hit h;
raytracer->CastRay(r,h,true);
if (h.getT()>1000)
return;
MTRand mtrand;
Vec3f refl = h.getMaterial()->getReflectiveColor();
Vec3f diff = h.getMaterial()->getDiffuseColor();
double ran=mtrand.rand();
if (iter==0)
ran= mtrand.rand(refl.Length()+diff.Length());
//std::cout<<iter<<" "<<h.getT()<<" "<<refl.Length()+diff.Length()<<std::endl;
//send reflective photon
if (iter<args->num_bounces&&ran<=refl.Length())
TracePhoton(r.pointAtParameter(h.getT()),r.getDirection()-2*(r.getDirection().Dot3(h.getNormal()))*h.getNormal(),energy,iter+1);
else if (iter<args->num_bounces&&ran<=refl.Length()+diff.Length())
TracePhoton(r.pointAtParameter(h.getT()),RandomDiffuseDirection(h.getNormal()),energy,iter+1);
else
{
Photon p(position,direction,energy,iter);
kdtree->AddPhoton(p);
}
}
Vec3f Face::RandomPoint() const {
Vec3f a = (*this)[0]->get();
Vec3f b = (*this)[1]->get();
Vec3f c = (*this)[2]->get();
Vec3f d = (*this)[3]->get();
MTRand r;
double s = r.rand(); // random real in [0,1]
double t = r.rand(); // random real in [0,1]
Vec3f answer = s*t*a + s*(1-t)*b + (1-s)*t*d + (1-s)*(1-t)*c;
return answer;
}
int RandomBin::randInt(Stream_type Stream, int minInt, int maxInt)
{
double randNum = 0;
int retInt = 0;
MTRand *streamPtr = GetStream(Stream);
if (streamPtr != NULL) {
randNum = streamPtr->rand();
randNum = randNum * static_cast<double>((maxInt - minInt + 1));
retInt = static_cast<int>(ceil(randNum)) - 1 + minInt;
return retInt;
}
return 0;
}
/**************************************************************************//**
* Return a random position close to the supplied one. Shell Jump
******************************************************************************/
dVec Cylinder::randUpdateJumpShell (MTRand &random, const dVec &pos) const {
dVec randPos;
randPos = pos;
double theta = atan2(pos[1],pos[0]);
double oldr = sqrt(pos[0]*pos[0] + pos[1]*pos[1]);
double newr;
if (random.rand() > 0.5)
newr = oldr + (1.00 + 2.50*random.rand());
else
newr = oldr - (1.00 + 2.50*random.rand());
if (newr < 0.0)
newr *= -1.0;
double ranTheta = M_PI*(-0.05 + 0.1*random.rand());
randPos[0] = newr*cos(theta + ranTheta);
randPos[1] = newr*sin(theta + ranTheta);
randPos[2] += constants()->displaceDelta()*(-0.5 + random.rand());
putInside(randPos);
return randPos;
}
void setupInitalRandomPos(std::vector<Furniture> & fVec, Image<Color>& texture){
// Genereate Random Position
std::cout << "Randomizing"<< std::endl;
MTRand mtrand;
unsigned int curIndex = 0;
// for each piece of furnature
while(curIndex < fVec.size()){
std::cout << "Desk "<< curIndex<<" Tying" << std::endl;
// random x and y and rotation
float start_x = mtrand.rand(TEXTURE_SIZE_X);
float start_y = mtrand.rand(TEXTURE_SIZE_Y);
double start_rot = mtrand.rand(2* M_PI);
// set to that random values
fVec[curIndex].setPos(start_x, start_y);
fVec[curIndex].setAngle(start_rot);
// check if were good
if(insideSpace(fVec[curIndex], texture)){
//debug
Color avgColor = getApproxColor(fVec[curIndex] , texture);
std::cout << "Desk "<< curIndex<<" PASS ";
std::cout << static_cast<unsigned>(avgColor.r)<< ", ";
std::cout << static_cast<unsigned>(avgColor.g)<< ", ";
std::cout << static_cast<unsigned>(avgColor.b)<< std::endl;
curIndex++;
}else{
std::cout << "Desk "<< curIndex<<" FAIL"<< std::endl;
}
}
}
void GenericLayer::initWeights() {
int j(0);
MTRand mt;
if ( this->hasChild && this->numNeurons > 0 && this->childLayer->numNeurons > 0) {
this->weights.clear();
this->weights.resize(this->numNeurons);
// #pragma omp parallel for private(j) if(this->numNeurons > 500)
for (int i=0; i<this->numNeurons; ++i) {
this->weights.at(i).clear();
this->weights.at(i).resize(this->childLayer->numNeurons);
for (j=0; j<this->childLayer->numNeurons; ++j) {
this->weights.at(i).at(j) = mt.rand(2)-1.0f;
}
}
}
}
void deskMove(Furniture& item,double heat, Image<Color>& texture){
// Moves and saved to item, so long as it is inside
// Using
MTRand mtrand;
int TIRES = 100;
while(0 < TIRES){
double move_x = mtrand.rand(2*heat);
double move_y = mtrand.rand(2*heat);
//dummy item
Furniture dummy(-1, "dummy",
item.getAngle(),
item.getPos().x ,
item.getPos().y);
// we want to be able to fitter forward and backwards
dummy.setPos(
dummy.getPos().x - heat,
dummy.getPos().y - heat);
// jitter it
dummy.setPos(
dummy.getPos().x + move_x,
dummy.getPos().y + move_y);
if(insideSpace(dummy,texture) ){
// if we didn't fall off save
item.setPos(
dummy.getPos().x,
dummy.getPos().y);
break;
}else{
//dec
TIRES--;
}
}//while
}//deskMove
double gasdev()
{
static int iset=0;
static double gset;
double fac,rsq,v1,v2;
// if (idum < 0) iset=0;
if (iset == 0) {
do {
v1=2.0*rnd.rand()-1.0;
v2=2.0*rnd.rand()-1.0;
rsq=v1*v1+v2*v2;
} while (rsq >= 1.0 || rsq == 0.0);
fac=sqrt(-2.0*log(rsq)/rsq);
gset=v1*fac;
iset=1;
return v2*fac;
} else {
iset=0;
return gset;
}
};
// constructs a random clockpiece
clockPiece::clockPiece()
{
// creates an MTRand that can make random numbers
MTRand randGen;
// initialize data
mPieceType = randGen.randInt(PTYPE_AMT);
mPieceInterval = 0;
mPendulumLength = 0;
mNumTeeth = 0;
mIsConnected = false;
mIsPowered = false;
mIsAttToHand = false;
// determine other member variables based on the part type
if (mPieceType == PTYPE_PENDULUM)
// random length of pendulum between 0 and 1 meter
mPendulumLength = randGen.rand();
else if (mPieceType == PTYPE_GEAR)
// random number of gear teeth (physical minimum is 3)
mNumTeeth = randGen.randInt(MAX_TEETH - 3) + 3;
}
/// Finds a random 2D point, within the specified region, that has no other objects within the requested radius, using an exising (already seeded) Mersenne Twister random number generator.
bool GridDatabase2D::randomPositionInRegionWithoutCollisions(const Util::AxisAlignedBox & region, SpatialDatabaseItemPtr item, bool excludeAgents, MTRand & randomNumberGenerator)
{
Point ret(0.0f, 0.0f, 0.0f);
bool notFoundYet;
unsigned int numTries = 0;
float radius = 0.0f;
AgentInterface * ai;
AgentInitialConditions aic;
if ( item->isAgent() )
{
ai = dynamic_cast<AgentInterface*>(item);
radius = ai->radius();
aic = ai->getAgentConditions(ai);
}
float xspan = region.xmax - region.xmin - 2*radius;
float zspan = region.zmax - region.zmin - 2*radius;
do {
ret.x = region.xmin + radius + ((float)randomNumberGenerator.rand(xspan));
ret.y = 0.0f;
ret.z = region.zmin + radius + ((float)randomNumberGenerator.rand(zspan));
aic.position = ret;
// assume this new point has no collisions, until we find out below
notFoundYet = false;
// check if ret collides with anything
set<SpatialDatabaseItemPtr> neighbors;
neighbors.clear();
float _new_radius = radius;
getItemsInRange(neighbors, ret.x - _new_radius, ret.x + _new_radius, ret.z - _new_radius, ret.z + _new_radius, NULL);
set<SpatialDatabaseItemPtr>::iterator neighbor;
for (size_t dirs=0; dirs < 10; dirs++)
{
float theta = randomNumberGenerator.rand() * M_2_PI;
double directionX = cos(theta);
double directionZ = sin(theta);
aic.direction = Util::Vector(directionX, 0.0f, directionZ);
ai->reset(aic, ai->getSimulationEngine());
ai->disable();
/*
* increment must be after loop body or (*neighbor)->isAgent()) will be called on an
* element that is beyond the set.
*/
for (neighbor = neighbors.begin(); neighbor != neighbors.end(); neighbor++)
{
if ((excludeAgents) && ((*neighbor)->isAgent()))
{
continue;
}
notFoundYet = (*neighbor)->overlaps(ret, radius) || ai->overlaps((*neighbor));
if (notFoundYet)
{
std::cout << "Try again placing agent: " << std::endl;
break;
}
}
if (notFoundYet)
{ // no intersections
break;
}
}// dirs
numTries++;
if (numTries > 1000)
{
cerr << "ERROR: trying too hard to find a random position in region. The region is probably already too dense." << endl;
if (numTries > 10000)
{
throw GenericException("Gave up trying to find a random position in region.");
}
}
} while (notFoundYet);
return !notFoundYet;
}
static cell_t GetURandomFloat(IPluginContext *ctx, const cell_t *params)
{
MTRand *randobj = s_RandHelpers.RandObjForPlugin(ctx);
return sp_ftoc((float)randobj->rand());
}
void QFRDRFCSFitFunctionSimulator::replotFitFunction() {
JKQTPdatastore* ds=ui->pltFunction->getDatastore();
QScopedPointer<QFFitFunction> ffunc(getFitFunction(NULL));
if (!ffunc) return;
try {
ui->pltFunction->set_doDrawing(false);
ui->pltFunction->clearGraphs();
ds->clear();
updateTau();
if (tauN) {
/////////////////////////////////////////////////////////////////////////////////
// retrieve fit parameters and errors. run calcParameters to fill in calculated parameters and make sure
// we are working with a complete set of parameters
/////////////////////////////////////////////////////////////////////////////////
double* fullParams=(double*)qfCalloc(ffunc->paramCount(), sizeof(double));
double* errors=(double*)qfCalloc(ffunc->paramCount(), sizeof(double));
double Nparticle=0;
bool hasNParticle=false;
for (int p=0; p<ffunc->paramCount(); p++) {
QFFitFunction::ParameterDescription d=ffunc->getDescription(p);
QString id=d.id;
if (params.contains(id)) {
fullParams[p]=params[id].value;
errors[p]=params[id].error;
} else {
fullParams[p]=d.initialValue;
/*double value=0;
if (overrideFitFunctionPreset(id, value)) d.initialValue=value;*/
errors[p]=0;
}
}
ffunc->calcParameter(fullParams, errors);
used_params.clear();
for (int p=0; p<ffunc->paramCount(); p++) {
QFFitFunction::ParameterDescription d=ffunc->getDescription(p);
QString id=d.id.toLower();
bool visible=ffunc->isParameterVisible(ffunc->getParameterNum(id), fullParams);
if (visible) {
if (id=="n_particle") {
Nparticle=fullParams[p];
hasNParticle=true;
}
if (id=="1n_particle" && !hasNParticle) {
Nparticle=1.0/fullParams[p];
hasNParticle=true;
}
used_params[id]=fullParams[p];
}
}
used_params["tau_min"]=ui->edtMinTau->value();
used_params["tau_max"]=ui->edtMaxTau->value();
used_params["runs"]=ui->spinRuns->value();
used_params["noise_enabled"]=ui->chkNoise->isChecked();
used_params["model_function"]=ffunc->id();
csv="";
// evaluate correlation function and determine small-lag amplitude
double tau0avg=0;
for (int r=0; r<runs; r++) {
for (int i=0; i<tauN; i++) {
corr[r*tauN+i]=ffunc->evaluate(tau[i], fullParams);
}
tau0avg=tau0avg+corr[r*tauN];
}
tau0avg=tau0avg/double(runs);
if (!hasNParticle) Nparticle=1.0/tau0avg;
// calc noise
if (ui->chkNoise->isChecked()) {
MTRand rng;
if (ui->cmbNoiseModel->currentIndex()==0) {
double I=ui->spinAvgCountRate->value()*1000.0;
double I2=sqr(I);
double NN=Nparticle;
if (NN<=0) NN=1.0;
for (int r=0; r<runs; r++) {
double corr0=corr[r*tauN];
for (int i=0; i<tauN; i++) {
double corrT=corr[r*tauN+i];
double M=ui->spinMeasDuration->value()/tau[i];
double m=tau[0]/tau[i];
double var=((1.0+sqr(corr0))*(1.0+sqr(corrT))/(1.0-sqr(corr0))+2.0*m*sqr(corrT))/M/NN/NN+(2.0*(1.0+sqr(corrT))/NN/I+(1.0+corrT/NN)/I2)/M;
corr[r*tauN+i]=corr[r*tauN+i]+rng.randNorm(0,1)*sqrt(var);
}
}
used_params["noise_model"]=QString("Koppel");
used_params["noise_intensity_kHz"]=I;
used_params["noise_measurement_duration"]=ui->spinMeasDuration->value();
} else if (ui->cmbNoiseModel->currentIndex()==1) {
for (int r=0; r<runs; r++) {
for (int i=0; i<tauN; i++) {
corr[r*tauN+i]=corr[r*tauN+i]+rng.randNorm(0, 1)*(ui->spinNoiseLevel->value()/100.0*tau0avg);
}
}
used_params["noise_model"]=QString("gaussian");
used_params["noise_level"]=ui->spinNoiseLevel->value();
} else if (ui->cmbNoiseModel->currentIndex()==2) {
for (int r=0; r<runs; r++) {
for (int i=0; i<tauN; i++) {
corr[r*tauN+i]=corr[r*tauN+i]+(rng.rand()*2.0-1.0)*ui->spinNoiseLevel->value()/100.0*tau0avg;
}
}
used_params["noise_model"]=QString("uniform");
used_params["noise_level"]=ui->spinNoiseLevel->value();
} else if (ui->cmbNoiseModel->currentIndex()==3) {
for (int r=0; r<runs; r++) {
for (int i=0; i<tauN; i++) {
corr[r*tauN+i]=corr[r*tauN+i]+rng.randNorm(0, 1)*(ui->spinNoiseLevel->value()/100.0*corr[r*tauN+i]);
}
}
used_params["noise_model"]=QString("local gaussian");
used_params["noise_level"]=ui->spinNoiseLevel->value();
} else if (ui->cmbNoiseModel->currentIndex()==4) {
for (int r=0; r<runs; r++) {
for (int i=0; i<tauN; i++) {
corr[r*tauN+i]=corr[r*tauN+i]+(rng.rand()*2.0-1.0)*ui->spinNoiseLevel->value()/100.0*corr[r*tauN+i];
}
}
used_params["noise_model"]=QString("local uniform");
used_params["noise_level"]=ui->spinNoiseLevel->value();
}
}
for (int i=0; i<tauN; i++) {
csv=csv+CDoubleToQString(tau[i]);
for (int r=0; r<runs; r++) {
csv=csv+", "+CDoubleToQString(corr[r*tauN+i]);
}
csv=csv+"\n";
}
size_t c_tau = ds->addCopiedColumn(tau, tauN, "tau");
for (int r=0; r<runs; r++) {
size_t c_fit = ds->addCopiedColumn(&(corr[r*tauN]), tauN, QString("function_r%1").arg(r));
/////////////////////////////////////////////////////////////////////////////////
// plot fit model and additional function graphs
/////////////////////////////////////////////////////////////////////////////////
JKQTPxyLineGraph* g_fit=new JKQTPxyLineGraph(ui->pltFunction->get_plotter());
g_fit->set_drawLine(true);
g_fit->set_title(tr("run %1").arg(r));
g_fit->set_xColumn(c_tau);
g_fit->set_yColumn(c_fit);
ui->pltFunction->addGraph(g_fit);
}
}
ui->pltFunction->zoomToFit();
ui->pltFunction->set_doDrawing(true);
ui->pltFunction->update_plot();
} catch(std::exception& E) {
services->log_error(tr("error during plotting, error message: %1\n").arg(E.what()));
}
}
// real number in [0,n]
double SoarRand(const double& max)
{
return gSoarRand.rand(max);
}
// real number in [0,1]
double SoarRand()
{
return gSoarRand.rand();
}
void simulate(double runtime, double rand_seed, State init_state, double* init_position,
void (*job)(void* dyn, State s, void *job_msg, data_union* job_data,
long long iteration), void *job_msg, data_union* job_data) {
if (FP_EXCEPTION_FATAL) {
feenableexcept(FE_ALL_EXCEPT); // NaN generation kills program
signal(SIGFPE, FPE_signal_handler);
}
MTRand* rand = new MTRand(rand_seed);
Dynein_onebound *dyn_ob;
Dynein_bothbound *dyn_bb;
if (init_state == BOTHBOUND) {
dyn_ob = NULL;
dyn_bb = new Dynein_bothbound(
init_position[0], // nma_init
init_position[1], // fma_init
init_position[2], // nbx_init
init_position[3], // nby_init
init_position[4], // L
NULL, // internal forces
NULL, // brownian forces
NULL, // equilibrium angles
rand); // MTRand
} else {
dyn_ob = new Dynein_onebound(
init_position[0], // bba_init
init_position[1], // bma_init
init_position[2], // uma_init
init_position[3], // uba_init
init_position[4], // bbx_init
init_position[5], // bby_init
init_state, // Initial state
NULL, // Optional custom internal forces
NULL, // Optional custom brownian forces
NULL, // Optional custom equilibrium angles
rand);
dyn_bb = NULL;
}
double t = 0;
long long iter = 0;
State current_state = init_state;
// double rebinding_immune_until = 0; // to prevent immediate rebinding in BB->OB transitions
bool run_indefinite;
if (runtime == 0) {
run_indefinite = true;
printf("Running indefinitely.\n");
} else {
run_indefinite = false;
printf("Running for %g s\n", runtime);
}
double near_unbinding_prob_printing_average = 0;
int unbinding_prob_printing_n = 0;
while( t < runtime or run_indefinite) {
if (current_state == NEARBOUND or current_state == FARBOUND)
while (t < runtime or run_indefinite) { // loop as long as it is onebound
if (am_debugging_time) printf("\n==== t = %8g/%8g ====\n", t, runtime);
double unbinding_prob = dyn_ob->get_unbinding_rate()*dt;
double binding_prob = dyn_ob->get_binding_rate()*dt;
if (am_debugging_rates and binding_prob != 0 and rand->rand() < 1e-3) {
printf("binding probability: %g, uby %g at time %g s\n", binding_prob, dyn_ob->get_uby(), t);
}
if (rand->rand() < unbinding_prob) { // unbind, switch to unbound
delete dyn_ob;
dyn_ob = NULL;
current_state = UNBOUND;
break;
}
else if (rand->rand() < binding_prob) { // switch to bothbound
dyn_bb = new Dynein_bothbound(dyn_ob, rand);
if (am_debugging_state_transitions) printf("Transitioning from onebound to bothbound\n");
if (am_debugging_state_transitions) printf("just bound b/c binding probability was: %g, boltzmann factor: %g\n",
binding_prob, exp(-(dyn_bb->get_PE()-dyn_ob->get_PE())/kb/T));
delete dyn_ob;
dyn_ob = NULL;
current_state = BOTHBOUND;
job(dyn_bb, current_state, job_msg, job_data, iter);
t += dt;
iter++;
break;
}
else { // move like normal
job(dyn_ob, current_state, job_msg, job_data, iter);
t += dt;
iter++;
double old_bba = dyn_ob->get_bba() ;
double old_bma = dyn_ob->get_bma() ;
double old_uma = dyn_ob->get_uma() ;
double old_uba = dyn_ob->get_uba() ;
bool accept_step = false;
int attempts = 0;
const long long max_attempts = 1e6;
while(!accept_step){
if (attempts > max_attempts) {
printf("Over %lld attempts needed to avoid a NaN state in onebound at time %g, something must be wrong. Exiting.\n",
max_attempts, t);
fprintf(stderr, "Over %lld attempts needed to avoid a NaN state at time %g, something must be wrong. Exiting.\n",
max_attempts, t);
if (am_only_writing_on_crash) on_crash_write_movie_buffer();
exit(1);
}
// if (attempts > 0 and attempts % 1000 == 0) printf("Taking %g rerolls to avoid a NaN velocity at time %g\n", (double) attempts, t);
if(attempts > 0){
dyn_ob->set_bba(old_bba);
dyn_ob->set_bma(old_bma);
dyn_ob->set_uma(old_uma);
dyn_ob->set_uba(old_uba);
dyn_ob->update_velocities();
}
double temp_bba = dyn_ob->get_bba() + dyn_ob->get_d_bba() * dt;
double temp_bma = dyn_ob->get_bma() + dyn_ob->get_d_bma() * dt;
double temp_uma = dyn_ob->get_uma() + dyn_ob->get_d_uma() * dt;
double temp_uba = dyn_ob->get_uba() + dyn_ob->get_d_uba() * dt;
dyn_ob->set_bba(temp_bba);
dyn_ob->set_bma(temp_bma);
dyn_ob->set_uma(temp_uma);
dyn_ob->set_uba(temp_uba);
accept_step = dyn_ob->update_velocities();
attempts++;
total_attempts += 1;
}
// if (attempts > 1) {
// printf("NaN avoiding code: (onebound) At time t=%g, took %d attempts to timestep without NaNs\n", t, attempts);
// }
}
}
if (current_state == BOTHBOUND) {
while (t < runtime or run_indefinite) { // loop as long as it is bothbound
if (am_debugging_time) printf("\n==== t = %8g/%8g ====\n", t, runtime);
double near_unbinding_prob = dyn_bb->get_near_unbinding_rate()*dt;
double far_unbinding_prob = dyn_bb->get_far_unbinding_rate()*dt;
double roll = rand->rand();
while (roll == 0) roll = rand->rand();
if (am_debugging_rates and roll < 1e-8) {
near_unbinding_prob_printing_average = (near_unbinding_prob_printing_average*unbinding_prob_printing_n + near_unbinding_prob);
near_unbinding_prob_printing_average /= (unbinding_prob_printing_n + 1);
unbinding_prob_printing_n++;
printf("BB near unbinding probability: %g\n", near_unbinding_prob_printing_average);
}
bool unbind_near = roll < near_unbinding_prob;
bool unbind_far = roll < far_unbinding_prob;
if (unbind_near && unbind_far) {
if (debug_stepping) printf("both MTBDs want to fall off!\n");
if (iter % 2 == 0) unbind_far = false;
else unbind_near = false;
}
if (unbind_near and not frozen_in_bothbound) { // switch to farbound
dyn_ob = new Dynein_onebound(dyn_bb, rand, FARBOUND);
if (am_debugging_state_transitions) printf("Transitioning from bothbound to farbound\n");
if (am_debugging_state_transitions) printf("just unbound b/c unbinding probability was: %g, roll was: %g, boltzmann factor: %g\n",
near_unbinding_prob, roll, exp(-(dyn_ob->get_PE()-dyn_bb->get_PE())/kb/T));
delete dyn_bb;
dyn_bb = NULL;
current_state = FARBOUND;
job(dyn_ob, current_state, job_msg, job_data, iter);
t += dt;
iter++;
// rebinding_immune_until = t + REBINDING_IMMUNITY_TIME;
break;
}
else if (unbind_far and not frozen_in_bothbound) { // switch to nearbound
dyn_ob = new Dynein_onebound(dyn_bb, rand, NEARBOUND);
if (am_debugging_state_transitions) printf("Transitioning from bothbound to nearbound\n");
if (am_debugging_state_transitions) printf("just unbound b/c unbinding probability was: %g, roll as: %g, boltzmann factor: %g\n",
far_unbinding_prob, roll, exp(-(dyn_ob->get_PE()-dyn_bb->get_PE())/kb/T));
delete dyn_bb;
dyn_bb = NULL;
current_state = NEARBOUND;
job(dyn_ob, current_state, job_msg, job_data, iter);
t += dt;
iter++;
// rebinding_immune_until = t + REBINDING_IMMUNITY_TIME;
break;
}
else { // move like normal
job(dyn_bb, BOTHBOUND, job_msg, job_data, iter);
t += dt;
iter++;
// double temp_nma = dyn_bb->get_nma() + dyn_bb->get_d_nma()*dt;
// double temp_fma = dyn_bb->get_fma() + dyn_bb->get_d_fma()*dt;
// dyn_bb->set_nma(temp_nma);
// dyn_bb->set_fma(temp_fma);
// dyn_bb->update_velocities();
double old_nma = dyn_bb->get_nma();
double old_fma = dyn_bb->get_fma();
bool accept_step = false;
int attempts = 0;
const long long max_attempts = 1e6;
while(!accept_step){
if (attempts > max_attempts) {
printf("Over %lld attempts needed to avoid a NaN state in bothbound at time %g, something must be wrong. Exiting.\n",
max_attempts, t);
fprintf(stderr, "Over %lld attempts needed to avoid a NaN state at time %g, something must be wrong. Exiting.\n",
max_attempts, t);
if (am_only_writing_on_crash) on_crash_write_movie_buffer();
exit(1);
}
// if (attempts > 0 and attempts % 100 == 0) printf("Taking %g rerolls to avoid a NaN velocity at time %g\n", (double) attempts, t);
if(attempts > 0){
dyn_bb->set_nma(old_nma);
dyn_bb->set_fma(old_fma);
dyn_bb->update_velocities();
}
double temp_nma = dyn_bb->get_nma() + dyn_bb->get_d_nma() * dt;
double temp_fma = dyn_bb->get_fma() + dyn_bb->get_d_fma() * dt;
dyn_bb->set_nma(temp_nma);
dyn_bb->set_fma(temp_fma);
accept_step = dyn_bb->update_velocities();
attempts++;
total_attempts += 1;
}
// if (attempts > 1) {
// printf("NaN avoiding code: (bothbound) At time t=%g, took %d attempts to timestep without NaNs\n", t, attempts);
// }
}
}
}
if (current_state == UNBOUND) {
job(NULL, UNBOUND, job_msg, job_data, iter);
goto end_simulation;
}
}
printf("Simulation exited successfully.\n");
printf("Executed %f NaN retries, or %g retries per step.\n", total_attempts, total_attempts / t * dt);
end_simulation:
delete rand;
if (dyn_bb == NULL) delete dyn_ob;
else delete dyn_bb;
}
double myrand () { return gen.rand(); }
const double operator()(const double & ignore)
{
return GlobalMT.rand();
}
int TissueCell::TakeStep(RealType dt, RealType v0, RealType mob, RealType t_relax, RealType noise, RealType box_size, MTRand& rng, bool eq){
int rtn = 0;
// Handle invalid arguments
if (mob < 0){ throw std::invalid_argument("mob < 0"); }
if (t_relax < 0){ throw std::invalid_argument("t_relax < 0"); }
if (noise < 0){ throw std::invalid_argument("noise < 0"); }
//RealType ffffx = this->Fx;
//RealType ffffy = this->Fy;
//RealType xxxxx = this->x;
//RealType yyyyy = this->y;
//RealType aaaangle = this->angle;
RealType dxF = (mob * Fx) * dt;
RealType dxV = (std::cos(this->angle) * v0) * dt;
RealType dx = dxF + dxV;
RealType dyF = (mob * Fy) * dt;
RealType dyV = (std::sin(this->angle) * v0) * dt;
RealType dy = dyF + dyV;
RealType vmag = sqrt(dx * dx + dy * dy);
RealType dtheta = 0;
// arcsin of a cross product of two normalized vecors will give the deflection in theta.
RealType step_noise = (rng.rand() - .5) * noise;
if (vmag != 0){
try{
dtheta = (dt / t_relax) * std::asin( (std::cos(angle) * dy - std::sin(angle) * dx) / vmag);
if (isnan(dtheta)){
throw (std::cos(angle) * dy - std::sin(angle) * dx) / vmag;
}
}
catch(RealType arcarg){
std::cout << "Caught bad arctan." <<std::endl;
if (arcarg >= 1 && arcarg <= 1.00001){
dtheta = (dt / t_relax) * 3.141592865358979 / 2.0;
}
else if (arcarg <=-1 && arcarg >=-1.00001){
dtheta = - (dt / t_relax) * 3.141592865358979 / 2.0;
}
else{
throw std::domain_error("Arctangent argument outside of allowed extended domain from floating point arithmetic");
}
}
}
this->angle += step_noise;
#ifndef FORCE_WARN_OFF
if (vmag > 10){
std::cout << "WARNING: Assuming Req of 1: Single step is on the order of Req; vmag = " << vmag <<". Check your timestep and interaction parameters." << std::endl;
}
#endif
this->x += dx;
this->y += dy;
// =========================================================================================
// Apply periodic topology:
// Map x and y [0, box_size) periodically
// e.g. box_size = 10.0, sends 10.0 -> 0.0
// For a non-equilibration step:
if (!eq){
if (this->x >= box_size){ this->x -= box_size ;}
if (this->y >= box_size){ this->y -= box_size; }
// e.g. box_size = 10.0, then -10.0 -> ceil(1) -> 0 and -10.1 -> ceil(1.01) -> 9.99
if (this->x < 0){ this->x += box_size; }
if (this->y < 0){ this->y += box_size; }
}
// For an equilibration step:
if (eq){
RealType beforex = this->x;
RealType beforey = this->y;
this->x = fmod(fmod(this->x, box_size) + box_size, box_size);
this->y = fmod(fmod(this->y, box_size) + box_size, box_size);
if (beforex != this->x or beforey != this->y){
rtn = 1;
}
}
RealType twoPi = 2.0 * 3.141592865358979;
if (!(this->angle + dtheta >= 0)){
this->angle += twoPi;
}
if (!(this->angle + dtheta < twoPi)){
this->angle -= twoPi;
}
this->angle += dtheta;
// Assertions to match the above definitions
// Furthermore: Do not allow a particle to step more than a box width.
// (angle can rotate artibrarily)
assert(fmod( 0 + twoPi, twoPi) == 0);
assert(this->x < box_size);
assert(this->x >= 0);
assert(this->y < box_size);
assert(this->y >= 0);
if (!(this-> angle < twoPi)){
std::cout << "Current angle is " << this->angle << " which is apparently larger than or equal to " << twoPi << std::endl;
assert(this-> angle < twoPi);
}
if (!(this-> angle >= 0)){
std::cout << "Current angle is " << this->angle << " which is apparently smaller than 0." << std::endl;
assert(this->angle >= 0);
}
// Clear the old forces;
this->Fx = 0;
this->Fy = 0;
return rtn;
}