// Calculates the probability density of finding the particle at location r at
// time t.
const Real FirstPassageGreensFunction1DRad::prob_r (const Real r, const Real t)
const
{
const Real L(this->getL());
const Real D(this->getD());
const Real h(this->getk()/D);
const Real r0(this->getr0());
THROW_UNLESS( std::invalid_argument, t >= 0.0 );
THROW_UNLESS( std::invalid_argument, 0 <= r && r <= L);
// if there was no time or no movement
if (t == 0 || D == 0)
{
// the probability density function is a delta function
if (r == r0)
{
return INFINITY;
}
else
{
return 0.0;
}
}
// if you're looking on the boundary
if ( fabs (r - L) < EPSILON*L )
{
return 0.0;
}
Real root_n, An_r;
Real sum = 0, term = 0, prev_term = 0;
int n=1;
do
{
if ( n >= MAX_TERMEN )
{
std::cerr << "Too many terms needed for GF1DRad::prob_r. N: "
<< n << std::endl;
break;
}
root_n = this->a_n(n);
An_r = root_n*r;
prev_term = term;
term = Cn(root_n, t) * An(root_n) * (root_n*cos(An_r) + h*sin(An_r));
sum += term;
n++;
}
// PDENS_TYPICAL is now 1e3, is this any good?!
while (fabs(term/sum) > EPSILON*PDENS_TYPICAL ||
fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
n <= MIN_TERMEN );
return 2.0*sum;
}
// Determine which event has occured, an escape or a reaction. Based on the
// fluxes through the boundaries at the given time. Beware: if t is not a
// first passage time you still get an answer!
GreensFunction1DRadAbs::EventKind
GreensFunction1DRadAbs::drawEventType( Real rnd, Real t )
const
{
THROW_UNLESS( std::invalid_argument, rnd < 1.0 && rnd >= 0.0 );
THROW_UNLESS( std::invalid_argument, t > 0.0 );
// if t=0 nothing has happened => no event
const Real a(this->geta());
const Real L(this->geta()-this->getsigma());
const Real r0(this->getr0());
// if the radiative boundary is impermeable (k==0) or
// the particle is at the absorbing boundary (at a) => IV_ESCAPE event
if ( k == 0 || fabs(a-r0) < EPSILON*L )
{
return IV_ESCAPE;
}
// Else the event is sampled from the flux ratio
const Real fluxratio (this->fluxRatioRadTot(t));
if (rnd > fluxratio )
{
return IV_ESCAPE;
}
else
{
return IV_REACTION;
}
}
// Determine which event has occured, an escape or a reaction. Based on the
// fluxes through the boundaries at the given time. Beware: if t is not a
// first passage time you still get an answer!
const EventType
FirstPassageGreensFunction1DRad::drawEventType( const Real rnd, const Real t )
const
{
const Real L(this->getL());
const Real r0(this->getr0());
THROW_UNLESS( std::invalid_argument, rnd < 1.0 && rnd >= 0.0 );
// if t=0 nothing has happened->no event!!
THROW_UNLESS( std::invalid_argument, t > 0.0 );
if ( k == 0 || fabs( r0 - L ) < EPSILON*L )
{
return ESCAPE;
}
const Real fluxratio (this->fluxRatioRadTot(t));
if (rnd > fluxratio )
{
return ESCAPE;
}
else
{
return REACTION;
}
}
int blan_fd_function_enable (struct usbd_function_instance *function_instance)
{
struct usbd_class_network_channel_descriptor *channel = &blan_class_5 ;
struct usb_network_private *npd = NULL;
u32 recv_urb_flags;
#if 0
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,17)
struct usbd_class_ethernet_networking_descriptor *ethernet = &blan_class_4;
char address_str[14];
snprintf(address_str, 13, "%02x%02x%02x%02x%02x%02x",
local_dev_addr[0], local_dev_addr[1], local_dev_addr[2],
local_dev_addr[3], local_dev_addr[4], local_dev_addr[5]);
#else
char address_str[20];
sprintf(address_str, "%02x%02x%02x%02x%02x%02x",
local_dev_addr[0], local_dev_addr[1], local_dev_addr[2],
local_dev_addr[3], local_dev_addr[4], local_dev_addr[5]);
#endif
ethernet->iMACAddress = usbd_alloc_string(address_str);
#endif
struct usbd_class_ethernet_networking_descriptor *ethernet = &blan_class_4;
char address_str[20];
sprintf(address_str, "%02x%02x%02x%02x%02x%02x", 0, 0, 0, 0, 0, 0);
ethernet->iMACAddress = usbd_alloc_string(function_instance, address_str);
//channel->iName = usbd_alloc_string(function_instance, system_utsname.nodename);
//TRACE_MSG3(NTT, "name: %s strings index imac: %d name: %d",
// system_utsname.nodename, ethernet->iMACAddress, channel->iName);
#if defined(CONFIG_OTG_NETWORK_BLAN_CRC) || defined(CONFIG_OTG_NETWORK_SAFE_CRC)
recv_urb_flags = 0;
#else /* defined(CONFIG_OTG_NETWORK_BLAN_CRC) || defined(CONFIG_OTG_NETWORK_SAFE_CRC) */
recv_urb_flags = USBD_URB_FAST_RETURN | USBD_URB_FAST_FINISH;
#endif /* defined(CONFIG_OTG_NETWORK_BLAN_CRC) || defined(CONFIG_OTG_NETWORK_SAFE_CRC) */
THROW_IF(net_fd_function_enable(function_instance,
network_blan, net_fd_recv_urb_mdlm,
net_fd_start_xmit_mdlm,
blan_start_recv, recv_urb_flags
), error);
THROW_UNLESS((npd = function_instance->privdata), error);
#if !defined(CONFIG_OTG_NETWORK_BLAN_CRC) && !defined(CONFIG_OTG_NETWORK_SAFE_CRC)
THROW_UNLESS((npd->blan_recv_task = otg_task_init2("blanrcv", blan_start_recv_task, function_instance, NTT)), error);
//npd->blan_recv_task->taskdebug = TRUE;
otg_task_start(npd->blan_recv_task);
#endif /* !defined(CONFIG_OTG_NETWORK_BLAN_CRC) && !defined(CONFIG_OTG_NETWORK_SAFE_CRC) */
return 0;
CATCH(error) {
return -EINVAL;
}
}
/*! arc_udc_init
*/
static struct arcotg_udc *arc_udc_init (struct otg_dev *otg_dev)
{
struct device *device = otg_dev_get_drvdata(otg_dev);
struct platform_device *pdev = to_platform_device(device);
struct fsl_usb2_platform_data *pdata = (struct fsl_usb2_platform_data*)pdev->dev.platform_data;
struct otg_instance *otg = otg_dev->otg_instance;
struct pcd_instance *pcd = otg_dev->pcd_instance;
struct arcotg_udc *udc = NULL;
int timeout;
/* Setting up the udc structure */
THROW_UNLESS((udc = (struct arcotg_udc *) CKMALLOC(sizeof(struct arcotg_udc))), error);
/* Allocate queue */
THROW_UNLESS((udc->ep_qh = (struct ep_queue_head *) KMALLOC_ALIGN( USB_MAX_PIPES * sizeof(struct ep_queue_head),
GFP_KERNEL | GFP_DMA, 2 * 1024, (void **)&ep_qh_base)), error);
THROW_UNLESS(ep_qh_base, error);
THROW_UNLESS((udc->ep_dtd = (struct ep_td_struct *) CKMALLOC(USB_MAX_PIPES * sizeof(struct ep_td_struct))), error);
/* Stop, reset and wait for the UDC to reset */
UOG_USBCMD &= ~USB_CMD_RUN_STOP;
UOG_USBCMD |= USB_CMD_CTRL_RESET;
timeout = 10000000; // XXX This needs to be fixed, should not need to resort to timeout
while ((UOG_USBCMD & USB_CMD_CTRL_RESET) && --timeout) { continue; }
if (timeout == 0) {
printk(KERN_DEBUG "%s: TIMEOUT\n", __FUNCTION__);
return NULL;
}
/* Setup UDC mode and disable lock out mode*/
UOG_USBMODE |= USB_MODE_CTRL_MODE_DEVICE | USB_MODE_SETUP_LOCK_OFF;
UOG_EPLISTADDR = virt_to_phys(udc->ep_qh);
UOG_EPLISTADDR &= USB_EP_LIST_ADDRESS_MASK;
/* Setup transceiver type, N.B. this must be done in one assignment */
UOG_PORTSC1 = (UOG_PORTSC1 & ~PORTSCX_PHY_TYPE_SEL) | pdata->xcvr_type;
#if !defined(CONFIG_OTG_HIGH_SPEED)
UOG_PORTSC1 |= (0x01000000);
#endif
fsl_platform_set_vbus_power(pdata, 0);
CATCH(error) {
if (ep_qh_base) kfree(ep_qh_base);
if (udc) {
if (udc->ep_dtd) LKFREE(udc->ep_dtd);
LKFREE(udc);
}
udc = NULL;
}
return udc;
}
// Calculates the probability of finding the particle inside the domain at
// time t, the survival probability The domein is from -r to r (r0 is in
// between!!)
const Real FirstPassageGreensFunction1DRad::p_survival (const Real t) const
{
const Real D(this->getD());
THROW_UNLESS( std::invalid_argument, t >= 0.0 );
if (t == 0 || D == 0)
{
// if there was no time or no movement the particle was always
// in the domain
return 1.0;
}
Real An;
Real sum = 0, term = 0, term_prev = 0;
int n = 1;
do
{
An = this->a_n(n);
term_prev = term;
term = Cn(An, t) * this->An(An) * Bn(An);
sum += term;
n++;
}
// Is 1.0 a good measure for the scale of probability or will this
// fail at some point?
while ( fabs(term/sum) > EPSILON*1.0 ||
fabs(term_prev/sum) > EPSILON*1.0 ||
n <= MIN_TERMEN);
return 2.0*sum;
}
// Calculates the probability of finding the particle inside the domain
// at time t, the survival probability.
Real
GreensFunction1DRadAbs::p_survival (Real t) const
{
THROW_UNLESS( std::invalid_argument, t >= 0.0 );
const Real D(this->getD());
const Real v(this->getv());
const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D);
if (t == 0.0 || (D == 0.0 && v == 0.0) )
{
// if there was no time or no movement the particle was always
// in the domain
return 1.0;
}
Real root_n;
Real sum = 0, term = 0, term_prev = 0;
int n = 1;
do
{
root_n = this->root_n(n);
term_prev = term;
term = this->Cn(root_n, t) * this->An(root_n) * this->Bn(root_n);
sum += term;
n++;
}
while ( fabs(term/sum) > EPSILON ||
fabs(term_prev/sum) > EPSILON ||
n <= MIN_TERMS);
return 2.0*exp(vexpo)*sum;
}
const Real GreensFunction2DAbs::drawTheta(const Real rnd,
const Real r,
const Real t) const
{
THROW_UNLESS(std::invalid_argument, 0.0<=rnd && rnd <= 1.0);
if(rnd == 1e0)
return 2e0 * M_PI;
if(fabs(r) < CUTOFF)// r == 0e0 ?
{
throw std::invalid_argument(
(boost::format("2DAbs::drawTheta r is too small: r=%f10") % r).str());
}
if(fabs(r-a) < CUTOFF)// r == a ?
{
//when R equal a, p_int_theta is zero at any theta
throw std::invalid_argument(
(boost::format("2DAbs::drawTheta r is nealy a: r=%f10, a=%f10") % r % a).str());
}
if(t == 0e0 || D == 0e0)
return 0e0;
Real int_2pi = p_int_2pi(r, t);
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* When t is too large, int_2pi become zero and drawR returns 2pi *
* at any value of rnd. To avoid this, return rnd * theta / 2pi *
* because when t -> \infty the probability density function of theta*
* become uniform distribution *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
if(int_2pi == 0e0)
{
std::cout << dump();
std::cout << "Warning: t is too large. t = " << t << std::endl;
}
p_theta_params params = {this, t, r, rnd * int_2pi};
gsl_function F =
{
reinterpret_cast<double (*)(double, void*)>(&p_theta_F), ¶ms
};
const Real low(0e0);
const Real high(2e0 * M_PI);
const gsl_root_fsolver_type* solverType(gsl_root_fsolver_brent);
gsl_root_fsolver* solver(gsl_root_fsolver_alloc(solverType));
const Real theta(findRoot(F, solver, low, high, 1e-18, 1e-12,
"GreensFunction2DAbsSym::drawTheta"));
gsl_root_fsolver_free(solver);
return theta;
}
const Real GreensFunction2DAbs::drawTime(const Real rnd) const
{
THROW_UNLESS(std::invalid_argument, 0.0<=rnd && rnd <= 1.0);
if(D == 0e0 || a == std::numeric_limits<Real>::infinity() || rnd == 1e0)
return std::numeric_limits<Real>::infinity();
if(a == r0 || rnd == 0e0)
return 0e0;
p_survival_params params = {this, rnd};
gsl_function F =
{
reinterpret_cast<double (*)(double, void*)>(&p_survival_F), ¶ms
};
// this is not so accurate because
// initial position is not the center of this system.
const Real t_guess(a * a * 0.25 / D);
Real value(GSL_FN_EVAL(&F, t_guess));
Real low(t_guess);
Real high(t_guess);
// to determine high and low border
if(value < 0.0)
{
do
{
high *= 1e1;
value = GSL_FN_EVAL(&F, high);
if(fabs(high) > t_guess * 1e6)
throw std::invalid_argument("could not adjust higher border");
}
while(value <= 0e0);
}
else
{
Real value_prev = value;
do
{
low *= 1e-1;
value = GSL_FN_EVAL(&F, low);
if(fabs(low) <= t_guess * 1e-6 || fabs(value - value_prev) < CUTOFF)
throw std::invalid_argument("could not adjust lower border");
value_prev = value;
}
while(value >= 0e0);
}
//find the root
const gsl_root_fsolver_type* solverType(gsl_root_fsolver_brent);
gsl_root_fsolver* solver(gsl_root_fsolver_alloc(solverType));
const Real t(findRoot(F, solver, low, high, 1e-18, 1e-12,
"GreensFunction2DAbs::drawTime"));
gsl_root_fsolver_free(solver);
return t;
}
void setr0(Real r0)
{
if ( this->a - this->sigma < 0.0 )
{
// if the domain had zero size
THROW_UNLESS( std::invalid_argument,
0.0 <= (r0-sigma) && (r0-sigma) <= EPSILON * l_scale );
this->r0 = 0.0;
}
else
{
// The normal case
THROW_UNLESS( std::invalid_argument,
0.0 <= (r0-sigma) && r0 <= this->a);
this->r0 = r0;
}
}
/*! acm_l26_modinit - module init
*
* This is called immediately after the module is loaded or during
* the kernel driver initialization if linked into the kernel.
*
*/
static int acm_l26_modinit (void)
{
BOOL tty_l26 = FALSE, tty_if = FALSE;
int minor_numbers=1;
/* register tty and usb interface function drivers
*/
TTY = otg_trace_obtain_tag();
THROW_UNLESS(tty_l26 = BOOLEAN(!tty_l26_init(ACM_DRIVER_PROCFS_NAME, ACM_TTY_MINORS)), error);
THROW_UNLESS(tty_if = BOOLEAN(!tty_if_init()), error);
CATCH(error) {
if (tty_l26) tty_l26_exit();
if (tty_if) tty_if_exit();
otg_trace_invalidate_tag(TTY);
return -EINVAL;
}
return 0;
}
/*! mcpc_l26_modinit - module init
*
* This is called immediately after the module is loaded or during
* the kernel driver initialization if linked into the kernel.
*
*/
STATIC int mcpc_l26_modinit (void)
{
BOOL tty_l26 = FALSE, dun_if = FALSE, obex_if = FALSE, atcom_if = FALSE;
TTY = otg_trace_obtain_tag();
THROW_UNLESS (tty_l26 = BOOLEAN(!tty_l26_init("mcpc_if", 6)), error);
THROW_UNLESS (tty_l26 = BOOLEAN(!dun_if_init()), error);
THROW_UNLESS (tty_l26 = BOOLEAN(!obex_if_init()), error);
THROW_UNLESS (tty_l26 = BOOLEAN(!atcom_if_init()), error);
CATCH(error) {
printk(KERN_ERR"%s: ERROR\n", __FUNCTION__);
if (tty_l26) tty_l26_exit();
if (dun_if) dun_if_exit();
if (obex_if) obex_if_exit();
if (atcom_if) atcom_if_exit();
otg_trace_invalidate_tag(TTY);
return -EINVAL;
}
return 0;
}
// Calculates the amount of flux leaving the right boundary at time t
Real
GreensFunction1DAbsAbs::leavea(Real t) const
{
THROW_UNLESS( std::invalid_argument, t >= 0.0 );
const Real a(this->geta());
const Real sigma(this->getsigma());
const Real L(this->geta() - this->getsigma());
const Real r0(this->getr0());
const Real D(this->getD());
const Real v(this->getv());
if ( fabs(r0-sigma) < L*EPSILON || fabs(a-r0) < L*EPSILON || L < 0.0 )
{
// The flux of a zero domain is INFINITY. Also if the particle
// started on the right boundary (leaking out immediately).
return INFINITY;
}
else if ( t < EPSILON*this->t_scale )
{
// if t=0.0 the flux must be zero
return 0.0;
}
Real sum = 0, term = 0, prev_term = 0;
Real nPI;
const Real D_L_sq(D/(L*L));
const Real expo(-D_L_sq*t); // exponent -D n^2 PI^2 t / l^2
const Real r0s_L((r0-sigma)/L);
const Real vexpo(-v*v*t/4.0/D + v*(a-r0)/2.0/D);
Real n=1;
do
{
if (n >= MAX_TERMS )
{
std::cerr << "Too many terms for leaves. N: " << n << std::endl;
break;
}
nPI = n*M_PI;
prev_term = term;
term = nPI * exp(nPI*nPI*expo) * cos(nPI) * sin(nPI*r0s_L);
sum += term;
n++;
}
while (fabs(term/sum) > EPSILON*PDENS_TYPICAL ||
fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
n < MIN_TERMS );
return -2.0*D_L_sq * exp(vexpo) * sum;
}
// This draws an eventtype of time t based on the flux through the left (z=sigma)
// and right (z=a) boundary. Although not completely accurate, it returns an
// IV_ESCAPE for an escape through the right boundary and a IV_REACTION for an
// escape through the left boundary.
GreensFunction1DAbsAbs::EventKind
GreensFunction1DAbsAbs::drawEventType( Real rnd, Real t ) const
{
THROW_UNLESS( std::invalid_argument, rnd < 1.0 && rnd >= 0.0 );
THROW_UNLESS( std::invalid_argument, t > 0.0 );
// if t=0 nothing has happened => no event
const Real a(this->geta());
const Real sigma(this->getsigma());
const Real L(this->geta() - this->getsigma());
const Real r0(this->getr0());
// For particles at the boundaries
if ( fabs(a-r0) < EPSILON*L )
{
// if the particle started on the right boundary
return IV_ESCAPE;
}
else if ( fabs(r0-sigma) < EPSILON*L )
{
// if the particle started on the left boundary
return IV_REACTION;
}
const Real leaves_s (this->leaves(t));
const Real leaves_a (this->leavea(t));
const Real flux_total (leaves_s + leaves_a);
const Real fluxratio (leaves_s/flux_total);
if (rnd > fluxratio )
{
return IV_ESCAPE;
}
else
{
return IV_REACTION;
}
}
/* pcd_ocd_modinit - linux module initialization
*
* This needs to initialize the ocd, pcd and tcd drivers.
*
* Specifically for each driver:
*
* obtain tag
* pass ops table address to state machine and get instance address
* call ops.mod_init
*
* Note that we automatically provide a default tcd_init if
* none is set.
*/
static int pcd_ocd_modinit (void)
{
printk(KERN_INFO"%s\n", __FUNCTION__);
#if !defined(OTG_C99)
pcd_global_init();
#endif /* !defined(OTG_C99) */
UNLESS(pcd_ops.pcd_init_func) pcd_ops.pcd_init_func = pcd_init_func;
PCD = otg_trace_obtain_tag();
THROW_UNLESS(pcd_instance = otg_set_pcd_ops(&pcd_ops), error);
THROW_IF((pcd_ops.mod_init) ? pcd_ops.mod_init() : 0, error);
OCD = otg_trace_obtain_tag();
THROW_UNLESS(ocd_instance = otg_set_ocd_ops(&ocd_ops), error);
THROW_IF((ocd_ops.mod_init) ? ocd_ops.mod_init() : 0, error);
CATCH(error) {
pcd_ocd_modexit();
return -EINVAL;
}
return 0;
}
/*! otg_task_init
*@brief Create otg task structure, create workqueue, initialize it.
*@param name - name of task or workqueue
*@param proc - handler
*@param data - parameter pointer for handler
*@param tag-
*@return initialized otg_task instance pointer
*/
struct otg_task *otg_task_init2(char *name, otg_task_proc_t proc, otg_task_arg_t data, otg_tag_t tag)
{
struct otg_task *task;
//TRACE_STRING(tag, "INIT: %s", name);
RETURN_NULL_UNLESS((task = CKMALLOC(sizeof (struct otg_task))));
task->tag = tag;
task->data = data;
task->name = name;
task->proc = proc;
#if defined(OTG_TASK_WORK)
task->terminated = task->terminate = TRUE;
#else /* defined(OTG_TASK_WORK) */
task->terminated = task->terminate = FALSE;
#if defined(LINUX26)
THROW_UNLESS((task->work_queue = create_singlethread_workqueue(name)), error);
#else /* LINUX26 */
THROW_UNLESS((task->work_queue = create_workqueue(name)), error);
#endif /* LINUX26 */
init_MUTEX_LOCKED(&task->admin_sem);
init_MUTEX_LOCKED(&task->work_sem);
#endif /* defined(OTG_TASK_WORK) */
INIT_WORK(&task->work, otg_task_proc, task);
return task;
CATCH(error) {
printk(KERN_INFO"%s: ERROR\n", __FUNCTION__);
if (task) LKFREE(task);
return NULL;
}
}
void
SCOCacheMountPoint::scanNamespace(SCOCacheNamespace* nspace)
{
VERIFY(initialised_);
const fs::path p(path_ / nspace->getName().str());
LOG_DEBUG(path_ << ": scanning mountpoint for namespace " <<
nspace->getName() << "( " << p << ")");
THROW_UNLESS(hasNamespace(nspace->getName()));
fs::directory_iterator end;
for (fs::directory_iterator it(p); it != end; ++it)
{
if (!fs::is_regular_file(it->status()))
{
LOG_WARN("ignoring non-file entry " << it->path());
continue;
}
const std::string fname(it->path().filename().string());
if (!SCO::isSCOString(fname))
{
LOG_WARN("ignoring non-SCO entry " << it->path());
continue;
}
SCO scoName(fname);
LOG_DEBUG(path_ << ": found SCO " << fname << " in " << p);
CachedSCOPtr sco(new CachedSCO(nspace,
scoName,
this,
it->path()));
scoCache_.insertScannedSCO(sco);
}
LOG_DEBUG(path_ << ": namespace " << nspace->getName() << " scanned");
}
// This also sets the scale
void seta(Real a)
{
THROW_UNLESS( std::invalid_argument, (a-this->sigma) >= 0.0 && this->r0 <= a);
// Use a typical domain size to determine if we are here
// defining a domain of size 0.
if ( (a-this->sigma) < EPSILON*this->l_scale )
{
// just some random value to show that the domain is zero
this->a = -1.0;
}
else
{
// set the l_scale to the given one
this->l_scale = a-sigma;
// set the typical time scale (MSD = sqrt(2*d*D*t) )
this->t_scale = (l_scale*l_scale)/this->getD();
this->a = a;
}
}
// This also sets the scale
void seta(Real a)
{
Real L( a - this->sigma );
THROW_UNLESS( std::invalid_argument, L >= 0.0 && (this->r0 - sigma) <= L);
// Use a typical domain size to determine if we are here
// defining a domain of size 0.
if ( L <= EPSILON * l_scale )
{
// just some random value to show that the domain is zero
this->a = -INT_MAX;
}
else
{
// set the typical time scale (msd = sqrt(2*d*D*t) )
// this is needed by drawTime_f, do not get rid of it!
this->t_scale = (L*L)/this->getD();
// set a
this->a = a;
}
}
void
ClientNG::ping(const std::vector<uint8_t>& out,
std::vector<uint8_t>& in)
{
auto b([&](mdsproto::Methods::PingParams::Builder& builder)
{
capnp::Data::Reader r(out.data(),
out.size());
builder.setData(r);
});
auto r([&](mdsproto::Methods::PingResults::Reader& reader)
{
auto data(reader.getData());
THROW_UNLESS(data.size() <= in.size());
memcpy(in.data(),
data.begin(),
data.size());
});
interact_<mdsproto::RequestHeader::Type::Ping>(std::move(b),
std::move(r));
}
const Real GreensFunction2DAbs::drawR(const Real rnd, const Real t) const
{
THROW_UNLESS(std::invalid_argument, 0.0<=rnd && rnd <= 1.0);
if(a == r0)
throw std::invalid_argument("a equal r0");
if(t == 0e0 || D == 0e0)
return r0;
if(rnd == 1e0)
return a;//!?
Real p_surv(p_survival(t));
assert(p_surv > 0e0);
p_r_params params = {this, t, rnd * p_surv};
gsl_function F =
{
reinterpret_cast<double (*)(double, void*)>(&p_r_F), ¶ms
};
const Real low(0e0);
const Real high(a);
const gsl_root_fsolver_type* solverType(gsl_root_fsolver_brent);
gsl_root_fsolver* solver(gsl_root_fsolver_alloc(solverType));
const Real r(findRoot(F, solver, low, high, 1e-18, 1e-12,
"GreensFunction2DAbsSym::drawR"));
gsl_root_fsolver_free(solver);
return r;
}
const Real
GreensFunction2DAbsSym::drawTime( const Real rnd ) const
{
THROW_UNLESS( std::invalid_argument, rnd < 1.0 && rnd >= 0.0 );
const Real a( geta() );
if( getD() == 0.0 || a == std::numeric_limits<Real>::infinity() )
{
return std::numeric_limits<Real>::infinity();
}
if( a == 0.0 )
{
return 0.0;
}
p_survival_params params = { this, rnd };
gsl_function F =
{
reinterpret_cast<double (*)(double, void*)>( &p_survival_F ), ¶ms
};
//for (Real t=0.0001; t<=1; t+=0.0001)
//{ std::cout << t << " " << GSL_FN_EVAL( &F, t) << std::endl;
//}
// Find a good interval to determine the first passage time in
const Real t_guess( a * a / ( 4. * D ) ); // construct a guess: msd = sqrt (2*d*D*t)
Real value( GSL_FN_EVAL( &F, t_guess ) );
Real low( t_guess );
Real high( t_guess );
// scale the interval around the guess such that the function straddles
if( value < 0.0 ) // if the guess was too low
{
do
{ high *= 10; // keep increasing the upper boundary until the function straddles
value = GSL_FN_EVAL( &F, high );
if( fabs( high ) >= t_guess * 1e6 )
{
// log_.warn("Couldn't adjust high. F(%.16g) = %.16g", high, value);
throw std::exception();
}
}
while ( value <= 0.0 );
}
else // if the guess was too high
{
Real value_prev( value );
do
{ low *= .1; // keep decreasing the lower boundary until the function straddles
value = GSL_FN_EVAL( &F, low ); // get the accompanying value
if( fabs( low ) <= t_guess * 1e-6 || fabs( value - value_prev ) < CUTOFF )
{
// log_.warn("Couldn't adjust high. F(%.16g) = %.16g", low, value);
return low;
}
value_prev = value;
}
while ( value >= 0.0 );
}
// find the root
const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent ); // a new solver type brent
gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) ); // make a new solver instance
const Real t( findRoot( F, solver, low, high, 1e-18, 1e-12,
"GreensFunction2DAbsSym::drawTime" ) );
gsl_root_fsolver_free( solver );
return t;
}
void seta( const Real a )
{
THROW_UNLESS( std::invalid_argument, a >= 0.0 );
this->a = a;
}
// Draws the position of the particle at a given time from p(r,t), assuming
// that the particle is still in the domain
Real
GreensFunction1DAbsAbs::drawR (Real rnd, Real t) const
{
THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
THROW_UNLESS( std::invalid_argument, t >= 0.0 );
const Real a(this->geta());
const Real sigma(this->getsigma());
const Real L(this->geta() - this->getsigma());
const Real r0(this->getr0());
const Real D(this->getD());
const Real v(this->getv());
// the trivial case: if there was no movement or the domain was zero
if ( (D==0.0 && v==0.0) || L<0.0 || t==0.0)
{
return r0;
}
else
{
// if the initial condition is at the boundary, raise an error
// The particle can only be at the boundary in the ABOVE cases
THROW_UNLESS( std::invalid_argument,
(r0-sigma) >= L*EPSILON && (r0-sigma) <= L*(1.0-EPSILON) );
}
// else the normal case
// From here on the problem is well defined
// structure to store the numbers to calculate numbers for 1-S(t)
struct drawR_params parameters;
Real S_Cn_An;
Real nPI;
const Real expo (-D*t/(L*L));
const Real r0s_L((r0-sigma)/L);
const Real v2D(v/2.0/D);
const Real Lv2D(L*v/2.0/D);
const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D); // exponent of the drift-prefactor, same as in survival prob.
const Real S = 2.0*exp(vexpo)/p_survival(t); // This is a prefactor to every term, so it also contains there
// exponential drift-prefactor.
// Construct the coefficients and the terms in the exponent and put them
// in the params structure
int n=0;
do
{
nPI = ((Real)(n+1))*M_PI; // note: summation starting with n=1, indexing with n=0, therefore we need n+1 here
if(v==0.0) S_Cn_An = S * exp(nPI*nPI*expo) * sin(nPI*r0s_L) / nPI;
else S_Cn_An = S * exp(nPI*nPI*expo) * sin(nPI*r0s_L) * nPI/(nPI*nPI + Lv2D*Lv2D);
// The rest is the z-dependent part, which has to be defined directly in drawR_f(z).
// Of course also the summation happens there because the terms now are z-dependent.
// The last term originates from the integrated prob. density including drift.
//
// In case of zero drift this expression becomes: 2.0/p_survival(t) * exp(nPI*nPI*expo) * sin(nPI*r0s_L) / nPI
// also store the values for the exponent, so they don't have to be recalculated in drawR_f
parameters.S_Cn_An[n]= S_Cn_An;
parameters.n_L[n] = nPI/L;
n++;
}
while (n<MAX_TERMS);
// store the random number for the probability
parameters.rnd = rnd ;
// store the number of terms used
parameters.terms = MAX_TERMS;
// store needed constants
parameters.H[0] = sigma;
parameters.H[1] = v2D;
// find the intersection on the y-axis between the random number and
// the function
gsl_function F;
F.function = &drawR_f;
F.params = ¶meters;
// define a new solver type brent
const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
// make a new solver instance
// TODO: incl typecast?
gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
const Real r( findRoot( F, solver, sigma, a, L*EPSILON, EPSILON,
"GreensFunction1DAbsAbs::drawR" ) );
// return the drawn time
return r;
}
const Real
GreensFunction2DAbsSym::drawR( const Real rnd, const Real t ) const
{
THROW_UNLESS( std::invalid_argument, rnd <= 1.0 && rnd >= 0.0 );
THROW_UNLESS( std::invalid_argument, t >= 0.0 );
const Real a( geta() );
const Real D( getD() );
if( a == 0.0 || t == 0.0 || D == 0.0 )
{
return 0.0;
}
//const Real thresholdDistance( this->CUTOFF_H * sqrt( 4.0 * D * t ) );
gsl_function F;
Real psurv;
// if( a <= thresholdDistance ) // if the domain is not so big, the boundaries are felt
// {
psurv = p_survival( t );
//psurv = p_int_r( a, t );
//printf("dr %g %g\n",psurv, p_survival( t ));
//assert( fabs(psurv - p_int_r( a, t )) < psurv * 1e-8 );
assert( psurv > 0.0 );
F.function = reinterpret_cast<double (*)(double, void*)>( &p_r_F );
/* }
else // if the domain is very big, just use the free solution
{
// p_int_r < p_int_r_free
if( p_int_r_free( a, t ) < rnd ) // if the particle is outside the domain?
{
std::cerr << "p_int_r_free( a, t ) < rnd, returning a."
<< std::endl;
return a;
}
psurv = 1.0;
F.function = reinterpret_cast<double (*)(double, void*)>( &p_r_free_F );
}
*/
const Real target( psurv * rnd );
p_r_params params = { this, t, target };
F.params = ¶ms;
const Real low( 0.0 );
const Real high( a );
//const Real high( std::min( thresholdDistance, a ) );
const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
const Real r( findRoot( F, solver, low, high, 1e-18, 1e-12,
"GreensFunction2DAbsSym::drawR" ) );
gsl_root_fsolver_free( solver );
return r;
}
// Draws the first passage time from the propensity function.
// Uses the help routine drawT_f and structure drawT_params for some technical
// reasons related to the way to input a function and parameters required by
// the GSL library.
Real
GreensFunction1DAbsAbs::drawTime (Real rnd) const
{
THROW_UNLESS( std::invalid_argument, 0.0 <= rnd && rnd < 1.0 );
const Real a(this->geta());
const Real sigma(this->getsigma());
const Real L(this->geta() - this->getsigma());
const Real r0(this->getr0());
const Real D(this->getD());
const Real v(this->getv());
if (D == 0.0 )
{
return INFINITY;
}
else if ( L < 0.0 || fabs(a-r0) < EPSILON*L || fabs(r0-sigma) > (1.0 - EPSILON)*L )
{
// if the domain had zero size
return 0.0;
}
const Real expo(-D/(L*L));
const Real r0s_L((r0-sigma)/L);
// some abbreviations for terms appearing in the sums with drift<>0
const Real sigmav2D(sigma*v/2.0/D);
const Real av2D(a*v/2.0/D);
const Real Lv2D(L*v/2.0/D);
// exponent of the prefactor present in case of v<>0; has to be split because it has a t-dep. and t-indep. part
const Real vexpo_t(-v*v/4.0/D);
const Real vexpo_pref(-v*r0/2.0/D);
// the structure to store the numbers to calculate the numbers for 1-S
struct drawT_params parameters;
Real Xn, exponent, prefactor;
Real nPI;
// Construct the coefficients and the terms in the exponent and put them
// into the params structure
int n = 0;
// a simpler sum has to be computed for the case w/o drift, so distinguish here
if(v==0)
{
do
{
nPI = ((Real)(n+1))*M_PI; // why n+1 : this loop starts at n=0 (1st index of the arrays), while the sum starts at n=1 !
Xn = sin(nPI*r0s_L) * (1.0 - cos(nPI)) / nPI;
exponent = nPI*nPI*expo;
// store the coefficients in the structure
parameters.Xn[n] = Xn;
// also store the values for the exponent
parameters.exponent[n]=exponent;
n++;
}
// TODO: Modify this later to include a cutoff when changes are small
while (n<MAX_TERMS);
}
else // case with drift<>0
{
do
{
nPI = ((Real)(n+1))*M_PI; // why n+1 : this loop starts at n=0 (1st index of the arrays), while the sum starts at n=1 !
Xn = (exp(sigmav2D) - cos(nPI)*exp(av2D)) * nPI/(Lv2D*Lv2D+nPI*nPI) * sin(nPI*r0s_L);
exponent = nPI*nPI*expo + vexpo_t;
// store the coefficients in the structure
parameters.Xn[n] = Xn;
// also store the values for the exponent
parameters.exponent[n]=exponent;
n++;
}
// TODO: Modify this later to include a cutoff when changes are small
while (n<MAX_TERMS);
}
// the prefactor of the sum is also different in case of drift<>0 :
if(v==0) prefactor = 2.0*exp(vexpo_pref);
else prefactor = 2.0;
parameters.prefactor = prefactor;
parameters.rnd = rnd;
parameters.terms = MAX_TERMS;
parameters.tscale = this->t_scale;
gsl_function F;
F.function = &drawT_f;
F.params = ¶meters;
// Find a good interval to determine the first passage time in
const Real dist( std::min(r0-sigma, a-r0) );
// construct a guess: MSD = sqrt (2*d*D*t)
Real t_guess( dist * dist / ( 2.0 * D ) );
// A different guess has to be made in case of nonzero drift to account for the displacement due to it
// When drifting towards the closest boundary...
if( ( r0-sigma >= L/2.0 && v > 0.0 ) || ( r0-sigma <= L/2.0 && v < 0.0 ) ) t_guess = sqrt(D*D/(v*v*v*v)+dist*dist/(v*v)) - D/(v*v);
// When drifting away from the closest boundary...
if( ( r0-sigma < L/2.0 && v > 0.0 ) || ( r0-sigma > L/2.0 && v < 0.0 ) ) t_guess = D/(v*v) - sqrt(D*D/(v*v*v*v)-dist*dist/(v*v));
Real value( GSL_FN_EVAL( &F, t_guess ) );
Real low( t_guess );
Real high( t_guess );
if( value < 0.0 )
{
// scale the interval around the guess such that the function
// straddles if the guess was too low
do
{
// keep increasing the upper boundary until the
// function straddles
high *= 10.0;
value = GSL_FN_EVAL( &F, high );
if( fabs( high ) >= t_guess * 1e6 )
{
std::cerr << "Couldn't adjust high. F(" << high << ") = "
<< value << std::endl;
throw std::exception();
}
}
while ( value <= 0.0 );
}
else
{
// if the guess was too high initialize with 2 so the test
// below survives the first iteration
Real value_prev( 2.0 );
do
{
if( fabs( low ) <= t_guess * 1.0e-6 ||
fabs(value-value_prev) < EPSILON*this->t_scale )
{
std::cerr << "Couldn't adjust low. F(" << low << ") = "
<< value << " t_guess: " << t_guess << " diff: "
<< (value - value_prev) << " value: " << value
<< " value_prev: " << value_prev << " t_scale: "
<< this->t_scale << std::endl;
return low;
}
value_prev = value;
// keep decreasing the lower boundary until the
// function straddles
low *= 0.1;
// get the accompanying value
value = GSL_FN_EVAL( &F, low );
}
while ( value >= 0.0 );
}
// find the intersection on the y-axis between the random number and
// the function
// define a new solver type brent
const gsl_root_fsolver_type* solverType( gsl_root_fsolver_brent );
// make a new solver instance
// TODO: incl typecast?
gsl_root_fsolver* solver( gsl_root_fsolver_alloc( solverType ) );
const Real t( findRoot( F, solver, low, high, EPSILON*t_scale, EPSILON,
"GreensFunction1DAbsAbs::drawTime" ) );
// return the drawn time
return t;
}
/*! net_fd_recv_urb_ecm
* @brief - callback to process a received URB
*
* @param urb - received urb
* @param rc dummy
* @return non-zero for failure.
*/
int net_fd_recv_urb_ecm(struct usbd_urb *urb, int rc)
{
struct usbd_function_instance *function_instance = urb->function_instance;
struct usb_network_private *npd = function_instance->privdata;
void *os_data = NULL;
u8 *os_buffer, *net_frame;
int crc_bad = 0;
int trim = 0;
int len;
u32 crc;
#ifndef CONFIG_OTG_NETWORK_DOUBLE_OUT
int endpoint_index = BULK_OUT_A;
#else /* CONFIG_OTG_NETWORK_DOUBLE_OUT */
int endpoint_index = BULK_OUT_A;
#endif /* CONFIG_OTG_NETWORK_DOUBLE_OUT */
int out_pkt_sz = usbd_endpoint_wMaxPacketSize(function_instance, endpoint_index, usbd_high_speed(function_instance));
len = urb->actual_length;
trim = 0;
TRACE_MSG2(NTT, "status: %d actual_length: %d", urb->status, urb->actual_length);
//RETURN_EINVAL_IF (urb->status == USBD_URB_OK);
THROW_UNLESS((os_data = net_os_alloc_buffer(function_instance, &os_buffer, len)), error);
net_frame = os_buffer;
//TRACE_MSG2(NTT, "os_data: %x os_buffer: %x", os_data, os_buffer);
/*
* The CRC can be sent in two ways when the size of the transfer
* ends up being a multiple of the packetsize:
*
* |
* <data> <CRC><CRC><CRC><CRC>|<???> case 1
* <data> <NUL><CRC><CRC><CRC>|<CRC> case 2
* <data> <NUL><CRC><CRC><CRC><CRC>| case 3
* <data> <NUL><CRC><CRC><CRC>|<CRC> | case 4
* |
*
* This complicates CRC checking, there are four scenarios:
*
* 1. length is 1 more than multiple of packetsize with a trailing byte
* 2. length is 1 more than multiple of packetsize
* 3. length is multiple of packetsize
* 4. none of the above
*
* Finally, even though we always compute CRC, we do not actually throw
* things away until and unless we have previously seen a good CRC.
* This allows backwards compatibility with hosts that do not support
* adding a CRC to the frame.
*
*/
// test if 1 more than packetsize multiple
if (1 == (len % out_pkt_sz)) {
#if defined(CONFIG_OTG_NETWORK_BLAN_CRC) || defined(CONFIG_OTG_NETWORK_SAFE_CRC)
// copy and CRC up to the packetsize boundary
crc = crc32_copy(os_buffer, urb->buffer, len - 1, CRC32_INIT);
os_buffer += len - 1;
// if the CRC is good then this is case 1
if (CRC32_GOOD != crc) {
crc = crc32_copy(os_buffer, urb->buffer + len - 1, 1, crc);
os_buffer += 1;
if (CRC32_GOOD != crc) {
//crc_errors[len%64]++;
TRACE_MSG2(NTT,"A CRC error %08x %03x", crc, urb->framenum);
THROW_IF(npd->seen_crc, crc_error);
}
else
npd->seen_crc = 1;
}
else
npd->seen_crc = 1;
#endif /* defined(CONFIG_OTG_NETWORK_BLAN_CRC) ...*/
}
else {
#if defined(CONFIG_OTG_NETWORK_BLAN_CRC) || defined(CONFIG_OTG_NETWORK_SAFE_CRC)
crc = crc32_copy(os_buffer, urb->buffer, len, CRC32_INIT);
os_buffer += len;
if (CRC32_GOOD != crc) {
//crc_errors[len%64]++;
TRACE_MSG2(NTT,"B CRC error %08x %03x", crc, urb->framenum);
THROW_IF(npd->seen_crc, crc_error);
}
else
npd->seen_crc = 1;
#else /* !defined(CONFIG_OTG_NETWORK_BLAN_CRC) ...*/
memcpy (os_buffer, urb->buffer, len);
#endif /* !defined(CONFIG_OTG_NETWORK_BLAN_CRC) ...*/
}
// trim IFF we are paying attention to crc
#if defined(CONFIG_OTG_NETWORK_BLAN_CRC) || defined(CONFIG_OTG_NETWORK_SAFE_CRC)
if (npd->seen_crc)
trim = 4;
#endif /* defined(CONFIG_OTG_NETWORK_BLAN_CRC) ...*/
if (net_fd_recv_buffer(function_instance, net_frame, len, os_data, crc_bad, trim)) {
TRACE_MSG0(NTT, "FAILED");
net_os_dealloc_buffer(function_instance, os_data, os_buffer);
}
// catch a simple error, just increment missed error and general error
CATCH(error) {
//TRACE_MSG4(NTT,"CATCH(error) urb: %p status: %d len: %d function: %p",
// urb, urb->status, urb->actual_length, function_instance);
// catch a CRC error
CATCH(crc_error) {
crc_bad = 1;
}
}
return 0;
//return usbd_start_out_urb (urb);
}
// Calculates the probability of finding the particle inside the domain at
// time t
Real
GreensFunction1DAbsAbs::p_survival (Real t) const
{
THROW_UNLESS( std::invalid_argument, t >= 0.0 );
const Real a(this->geta());
const Real sigma(this->getsigma());
const Real L(this->geta() - this->getsigma());
const Real r0(this->getr0());
const Real D(this->getD());
const Real v(this->getv());
if ( fabs(r0-sigma) < L*EPSILON || fabs(a-r0) < L*EPSILON || L < 0.0 )
{
// The survival probability of a zero domain is zero
return 0.0;
}
// Set values that are constant in this calculation
const Real expo(-D*t/(L*L)); // part of the exponent -D n^2 PI^2 t / L^2
const Real r0s(r0 - sigma);
const Real r0s_L(r0s/L);
// some abbreviations for terms appearing in the sums with drift<>0
const Real sigmav2D(sigma*v/2.0/D);
const Real av2D(a*v/2.0/D);
const Real Lv2D(L*v/2.0/D);
const Real vexpo(-v*v*t/4.0/D - v*r0/2.0/D); // exponent of the drift-prefactor
// Initialize summation
Real sum = 0, term = 0, prev_term = 0;
Real nPI;
// Sum
Real n=1;
// different calculations depending on whether v=0 or not
if(v==0.0) // case without drift (v==0); in this case the summation is simpler, so do the complicated caluclation only if necessary
{
do
{
if (n >= MAX_TERMS )
{
std::cerr << "Too many terms for p_survival. N: " << n << std::endl;
break;
}
prev_term = term;
nPI = (double)n*M_PI;
term = exp(nPI*nPI*expo) * sin(nPI*r0s_L) * (1.0 - cos(nPI)) / nPI;
sum += term;
n++;
}
// Is 1 a good measure or will this fail at some point?
while ( fabs(term/sum) > EPSILON*1.0 ||
fabs(prev_term/sum) > EPSILON*1.0 ||
n < MIN_TERMS );
sum = 2.0*sum; // This is a prefactor of every term, so do only one multiplication here
}
else // case with drift (v<>0)
{
do
{
if (n >= MAX_TERMS )
{
std::cerr << "Too many terms for p_survival. N: " << n << std::endl;
break;
}
nPI = (double)n*M_PI;
prev_term = term;
term = exp(nPI*nPI*expo) * (exp(sigmav2D) - cos(nPI)*exp(av2D)) * nPI/(Lv2D*Lv2D+nPI*nPI) * sin(nPI*r0s_L);
sum += term;
n++;
}
// TODO: Is 1 a good measure or will this fail at some point?
while ( fabs(term/sum) > EPSILON*1.0 ||
fabs(prev_term/sum) > EPSILON*1.0 ||
n < MIN_TERMS );
sum = 2.0*exp(vexpo) * sum; // prefactor containing the drift
}
return sum;
}
/*!
* generic_cf_register()
*
*/
void generic_cf_register(struct generic_config *config, char *match)
{
char *cp, *sp, *lp;
int i;
char **interface_list = NULL;
int interfaces = 0;
//printk(KERN_INFO"%s: Driver: \"%s\" idVendor: %04x idProduct: %04x interface_names: \"%s\" match: \"%s\"\n",
// __FUNCTION__,
// config->composite_driver.driver.name, MODPARM(idVendor), MODPARM(idProduct), config->interface_names,
// match ? match : "");
TRACE_MSG5(GENERIC, "Driver: \"%s\" idVendor: %04x idProduct: %04x interface_names: \"%s\" match: \"%s\"",
config->composite_driver.driver.name, MODPARM(idVendor), MODPARM(idProduct), config->interface_names,
match ? match : "");
RETURN_IF (match && strlen(match) && strcmp(match, config->composite_driver.driver.name));
//printk(KERN_INFO"%s: MATCHED\n", __FUNCTION__);
/* decompose interface names to construct interface_list
*/
RETURN_UNLESS (config->interface_names && strlen(config->interface_names));
/* count interface names and allocate _interface_names array
*/
for (cp = sp = config->interface_names, interfaces = 0; cp && *cp; ) {
for (; *cp && *cp == ':'; cp++); // skip white space
sp = cp; // save start of token
for (; *cp && *cp != ':'; cp++); // find end of token
BREAK_IF (sp == cp);
if (*cp) cp++;
interfaces++;
}
THROW_UNLESS(interfaces, error);
TRACE_MSG1(GENERIC, "interfaces: %d", interfaces);
THROW_UNLESS((interface_list = (char **) CKMALLOC (sizeof (char *) * (interfaces + 1), GFP_KERNEL)), error);
for (cp = sp = config->interface_names, interfaces = 0; cp && *cp; interfaces++) {
for (; *cp && *cp == ':'; cp++); // skip white space
sp = cp; // save start of token
for (; *cp && *cp != ':'; cp++); // find end of token
BREAK_IF (sp == cp);
lp = cp;
if (*cp) cp++;
*lp = '\0';
lp = CKMALLOC(strlen(sp), GFP_KERNEL);
strcpy(lp, sp);
interface_list[interfaces] = lp;
TRACE_MSG3(GENERIC, "INTERFACE[%2d] %x \"%s\"",
interfaces, interface_list[interfaces], interface_list[interfaces]);
}
config->composite_driver.device_description = &config->device_description;
config->composite_driver.configuration_description = &config->configuration_description;
config->composite_driver.driver.fops = &generic_function_ops;
config->interface_list = interface_list;
THROW_IF (usbd_register_composite_function (
&config->composite_driver,
config->composite_driver.driver.name,
config->class_name,
config->interface_list, NULL), error);
config->registered++;
TRACE_MSG0(GENERIC, "REGISTER FINISHED");
CATCH(error) {
otg_trace_invalidate_tag(GENERIC);
}
}
// Calculates the probability density of finding the particle at location r at
// time t.
Real
GreensFunction1DAbsAbs::prob_r (Real r, Real t) const
{
THROW_UNLESS( std::invalid_argument, 0.0 <= (r-sigma) && r <= a );
THROW_UNLESS( std::invalid_argument, t >= 0.0 );
const Real a(this->geta());
const Real sigma(this->getsigma());
const Real L(this->geta() - this->getsigma());
const Real r0(this->getr0());
const Real D(this->getD());
const Real v(this->getv());
// if there was no time change or no diffusivity => no movement
if (t == 0 || D == 0)
{
// the probability density function is a delta function
if (r == r0)
{
return INFINITY;
}
else
{
return 0.0;
}
}
else if ( fabs(r-sigma) < L*EPSILON || fabs(a-r) < L*EPSILON || L < 0.0 )
{
return 0.0;
}
// Set values that are constant in this calculation
const Real expo(-D*t/(L*L));
const Real rs_L((r-sigma)/L);
const Real r0s_L((r0-sigma)/L);
const Real vexpo(-v*v*t/4.0/D + v*(r-r0)/2.0/D); // exponent of the drift-prefactor
// Initialize summation
Real nPI;
Real sum = 0, term = 0, prev_term = 0;
// Sum
int n=1;
do
{
if (n >= MAX_TERMS )
{
std::cerr << "Too many terms for prob_r. N: " << n << std::endl;
break;
}
prev_term = term;
nPI = n*M_PI;
term = exp(nPI*nPI*expo) * sin(nPI*r0s_L) * sin(nPI*rs_L);
sum += term;
n++;
}
while (fabs(term/sum) > EPSILON*PDENS_TYPICAL ||
fabs(prev_term/sum) > EPSILON*PDENS_TYPICAL ||
n <= MIN_TERMS);
return 2.0/L * exp(vexpo) * sum;
}
