//this function will print a samfile from the bamfile
int motherView(bufReader *rd,int nFiles,std::vector<regs>regions) {
aRead b;
b.vDat=new uint8_t[RLEN];
kstring_t str; str.s=NULL; str.l=str.m=0;
if(regions.size()==0) {//print all
int block_size;
while(SIG_COND && bgzf_read(rd[0].fp,&block_size,sizeof(int))){
getAlign(rd[0].fp,block_size,b);
printReadBuffered(b,rd[0].hd,str);
fprintf(stdout,"%s",str.s);
}
}else {
for(int i=0;i<(int)regions.size();i++){
int tmpRef = regions[i].refID;
int tmpStart = regions[i].start;
int tmpStop = regions[i].stop;
getOffsets(rd[0].bamfname,rd[0].hd,rd[0].it,tmpRef,tmpStart,tmpStop);
int ret =0;
while(SIG_COND){
ret = bam_iter_read(rd[0].fp, &rd[0].it, b);
if(ret<0)
break;
printReadBuffered(b,rd[0].hd,str);
fprintf(stdout,"%s",str.s);
}
free(rd[0].it.off);//the offsets
}
free(str.s);
delete [] b.vDat;
}
return 0;
}
double SimpleRMSD::calc( const std::vector<Vector>& pos, ReferenceValuePack& myder, const bool& squared ) const {
if( myder.getAtomsDisplacementVector().size()!=pos.size() ) myder.getAtomsDisplacementVector().resize( pos.size() );
double d=myrmsd.simpleAlignment( getAlign(), getDisplace(), pos, getReferencePositions(), myder.getAtomVector(), myder.getAtomsDisplacementVector(), squared );
myder.clear(); for(unsigned i=0;i<pos.size();++i) myder.setAtomDerivatives( i, myder.getAtomVector()[i] );
if( !myder.updateComplete() ) myder.updateDynamicLists();
return d;
}
void PopupWindow::onPreferredSize(PreferredSizeEvent& ev)
{
ScreenGraphics g;
g.setFont(getFont());
Size resultSize(0, 0);
if (hasText())
resultSize = g.fitString(getText(),
(getClientBounds() - getBorder()).w,
getAlign());
resultSize.w += border_width.l + border_width.r;
resultSize.h += border_width.t + border_width.b;
if (!getChildren().empty()) {
Size maxSize(0, 0);
Size reqSize;
UI_FOREACH_WIDGET(getChildren(), it) {
Widget* child = *it;
reqSize = child->getPreferredSize();
maxSize.w = MAX(maxSize.w, reqSize.w);
maxSize.h = MAX(maxSize.h, reqSize.h);
}
void ImageView::onPreferredSize(PreferredSizeEvent& ev)
{
gfx::Rect box;
getTextIconInfo(&box, NULL, NULL,
getAlign(), m_bmp->w, m_bmp->h);
ev.setPreferredSize(gfx::Size(border_width.l + box.w + border_width.r,
border_width.t + box.h + border_width.b));
}
void ImageView::onPreferredSize(PreferredSizeEvent& ev)
{
struct jrect box, text, icon;
jwidget_get_texticon_info(this, &box, &text, &icon,
getAlign(), m_bmp->w, m_bmp->h);
ev.setPreferredSize(gfx::Size(border_width.l + jrect_w(&box) + border_width.r,
border_width.t + jrect_h(&box) + border_width.b));
}
void ImageView::onPaint(PaintEvent& ev)
{
Graphics* g = ev.getGraphics();
gfx::Rect bounds = getClientBounds();
gfx::Rect icon;
getTextIconInfo(NULL, NULL, &icon, getAlign(), m_bmp->w, m_bmp->h);
g->fillRect(getBgColor(), bounds);
g->blit(m_bmp, 0, 0, icon.x, icon.y, icon.w, icon.h);
}
void ImageView::onPreferredSize(PreferredSizeEvent& ev)
{
gfx::Rect box;
getTextIconInfo(&box, NULL, NULL,
getAlign(), m_sur->width(), m_sur->height());
ev.setPreferredSize(
gfx::Size(
box.w + border().width(),
box.h + border().height()));
}
void ImageView::onPaint(PaintEvent& ev)
{
Graphics* g = ev.getGraphics();
gfx::Rect bounds = getClientBounds();
gfx::Rect icon;
getTextIconInfo(NULL, NULL, &icon, getAlign(),
m_sur->width(), m_sur->height());
g->fillRect(getBgColor(), bounds);
g->drawRgbaSurface(m_sur, icon.x, icon.y);
}
static void lambda_insert(SYMBOL *sym, LAMBDA *lambdas)
{
int align = getAlign(sc_member, sym->tp);
if (align && lambdas->cls->tp->size % align)
lambdas->cls->tp->size += align - lambdas->cls->tp->size % align;
if (align > lambdas->cls->structAlign)
lambdas->cls->structAlign = align;
sym->parentClass = lambdas->cls;
sym->offset = lambdas->cls->tp->size;
insert(sym, lambdas->cls->tp->syms);
lambdas->cls->tp->size += sym->tp->size;
}
void ImageView::onPaint(PaintEvent& ev)
{
struct jrect box, text, icon;
jwidget_get_texticon_info(this, &box, &text, &icon,
getAlign(), m_bmp->w, m_bmp->h);
jdraw_rectexclude(rc, &icon, getBgColor());
blit(m_bmp, ji_screen, 0, 0,
icon.x1, icon.y1, jrect_w(&icon), jrect_h(&icon));
}
double OptimalRMSD::calc( const std::vector<Vector>& pos, const bool& squared ){
if( fast ){
if( getAlign()==getDisplace() ) return myrmsd.optimalAlignment<false,true>(getAlign(),getDisplace(),pos,getReferencePositions(),atom_ders,squared);
return myrmsd.optimalAlignment<false,false>(getAlign(),getDisplace(),pos,getReferencePositions(),atom_ders,squared);
} else {
if( getAlign()==getDisplace() ) return myrmsd.optimalAlignment<true,true>(getAlign(),getDisplace(),pos,getReferencePositions(),atom_ders,squared);
return myrmsd.optimalAlignment<true,false>(getAlign(),getDisplace(),pos,getReferencePositions(),atom_ders,squared);
}
}
double SimpleRMSD::projectAtomicDisplacementOnVector( const unsigned& iv, const Matrix<Vector>& vecs, const std::vector<Vector>& pos, std::vector<Vector>& derivatives ){
Vector comder; comder.zero();
for(unsigned j=0;j<displacement.size();++j){
for(unsigned k=0;k<3;++k) comder[k] += getAlign()[j]*vecs(iv,j)[k];
}
double proj=0;
for(unsigned j=0;j<displacement.size();++j){
for(unsigned k=0;k<3;++k){
proj += vecs(iv,j)[k]*displacement[j][k];
derivatives[j][k] = vecs(iv,j)[k] - comder[k];
}
}
return proj;
}
double SimpleRMSD::projectAtomicDisplacementOnVector( const std::vector<Vector>& vecs, const std::vector<Vector>& pos, ReferenceValuePack& mypack ) const {
plumed_dbg_assert( mypack.calcUsingPCAOption() ); Vector comder; comder.zero();
for(unsigned j=0;j<pos.size();++j){
for(unsigned k=0;k<3;++k) comder[k] += getAlign()[j]*vecs[j][k];
}
double proj=0; mypack.clear();
for(unsigned j=0;j<pos.size();++j){
for(unsigned k=0;k<3;++k){
proj += vecs[j][k]*mypack.getAtomsDisplacementVector()[j][k];
}
mypack.setAtomDerivatives( j, vecs[j] - comder );
}
if( !mypack.updateComplete() ) mypack.updateDynamicLists();
return proj;
}
double OptimalRMSD::calc( const std::vector<Vector>& pos, ReferenceValuePack& myder, const bool& squared ) const {
double d;
if( myder.calcUsingPCAOption() ) {
std::vector<Vector> centeredreference( getNumberOfAtoms () );
d=myrmsd.calc_PCAelements(pos,myder.getAtomVector(),myder.rot[0],myder.DRotDPos,myder.getAtomsDisplacementVector(),myder.centeredpos,centeredreference,squared);
unsigned nat = pos.size();
for(unsigned i=0; i<nat; ++i) { myder.getAtomsDisplacementVector()[i] -= getReferencePosition(i); myder.getAtomsDisplacementVector()[i] *= getDisplace()[i]; }
} else if( fast ) {
if( getAlign()==getDisplace() ) d=myrmsd.optimalAlignment<false,true>(getAlign(),getDisplace(),pos,getReferencePositions(),myder.getAtomVector(),squared);
else d=myrmsd.optimalAlignment<false,false>(getAlign(),getDisplace(),pos,getReferencePositions(),myder.getAtomVector(),squared);
} else {
if( getAlign()==getDisplace() ) d=myrmsd.optimalAlignment<true,true>(getAlign(),getDisplace(),pos,getReferencePositions(),myder.getAtomVector(),squared);
else d=myrmsd.optimalAlignment<true,false>(getAlign(),getDisplace(),pos,getReferencePositions(),myder.getAtomVector(),squared);
}
myder.clear(); for(unsigned i=0; i<pos.size(); ++i) myder.setAtomDerivatives( i, myder.getAtomVector()[i] );
if( !myder.updateComplete() ) myder.updateDynamicLists();
return d;
}
void SimpleRMSD::extractAtomicDisplacement( const std::vector<Vector>& pos, const bool& anflag, std::vector<Vector>& direction ) const {
std::vector<Vector> tder( getNumberOfAtoms() );
double d=myrmsd.simpleAlignment( getAlign(), getDisplace(), pos, getReferencePositions(), tder, direction, true );
double scale=1.0; if( anflag ) scale = 1.0 / static_cast<double>( pos.size() );
for(unsigned i=0;i<pos.size();++i) direction[i] = scale*direction[i];
}
Ogre::WorkQueue::Response* World::handleRequest(const Ogre::WorkQueue::Request *req, const Ogre::WorkQueue *srcQ)
{
if (req->getType() == REQ_ID_CHUNK)
{
const LoadRequestData data = Ogre::any_cast<LoadRequestData>(req->getData());
QuadTreeNode* node = data.mNode;
LoadResponseData* responseData = new LoadResponseData();
getStorage()->fillVertexBuffers(node->getNativeLodLevel(), node->getSize(), node->getCenter(), getAlign(),
responseData->mPositions, responseData->mNormals, responseData->mColours);
return OGRE_NEW Ogre::WorkQueue::Response(req, true, Ogre::Any(responseData));
}
else // REQ_ID_LAYERS
{
const LayersRequestData data = Ogre::any_cast<LayersRequestData>(req->getData());
LayersResponseData* responseData = new LayersResponseData();
getStorage()->getBlendmaps(data.mNodes, responseData->mLayerCollections, data.mPack);
return OGRE_NEW Ogre::WorkQueue::Response(req, true, Ogre::Any(responseData));
}
}
LEXEME *expression_lambda(LEXEME *lex, SYMBOL *funcsp, TYPE *atp, TYPE **tp, EXPRESSION **exp, int flags)
{
LAMBDA *self;
SYMBOL *vpl, *ths;
HASHREC *hrl;
TYPE *ltp;
STRUCTSYM ssl;
if (funcsp)
funcsp->noinline = TRUE;
IncGlobalFlag();
self = Alloc(sizeof(LAMBDA));
ltp = Alloc(sizeof(TYPE));
ltp->type = bt_struct;
ltp->syms = CreateHashTable(1);
ltp->tags = CreateHashTable(1);
ltp->size = 0;
self->captured = CreateHashTable(1);
self->oldSyms = localNameSpace->syms;
self->oldTags = localNameSpace->tags;
self->index = lambdaIndex;
self->captureMode = cmNone;
self->isMutable = FALSE;
self->captureThis = FALSE;
self->cls = makeID(sc_type, ltp, NULL, LambdaName());
ltp->sp = self->cls;
SetLinkerNames(self->cls, lk_cdecl);
self->cls->islambda = TRUE;
self->cls->structAlign = getAlign(sc_global, &stdpointer);
self->func = makeID(sc_member, ltp, NULL, "$internalFunc");
self->func->parentClass = self->cls;
self->functp = &stdauto;
self->enclosingFunc = theCurrentFunc;
if (lambdas)
lambdas->prev = self;
self->next = lambdas;
lambdas = self;
localNameSpace->syms = CreateHashTable(1);
localNameSpace->tags = CreateHashTable(1);
if (lambdas->next)
{
self->lthis = lambdas->next->lthis;
}
else if (funcsp && funcsp->parentClass)
{
self->lthis = ((SYMBOL *)funcsp->tp->syms->table[0]->p);
}
lex = getsym(); // past [
if (funcsp)
{
// can have a capture list;
if (MATCHKW(lex, assign))
{
lex = getsym();
if (MATCHKW(lex, comma) || MATCHKW(lex, closebr))
{
self->captureMode = cmValue;
skip(&lex, comma);
}
else
{
lex = backupsym();
}
}
else if (MATCHKW(lex, and))
{
lex = getsym();
if (MATCHKW(lex, comma) || MATCHKW(lex, closebr))
{
self->captureMode = cmRef;
skip(&lex, comma);
}
else
{
lex = backupsym();
}
}
if (!MATCHKW(lex, comma) && !MATCHKW(lex, closebr))
{
do
{
enum e_cm localMode = self->captureMode;
if (MATCHKW(lex, comma))
skip(&lex, comma);
if (MATCHKW(lex, kw_this))
{
lex = getsym();
if (localMode == cmValue || !self->lthis)
{
error(ERR_CANNOT_CAPTURE_THIS);
}
else
{
if (self->captureThis)
{
error(ERR_CAPTURE_ITEM_LISTED_MULTIPLE_TIMES);
}
self->captureThis = TRUE;
lambda_capture(NULL, cmThis, TRUE);
}
continue;
}
else if (MATCHKW(lex, and))
{
if (localMode == cmRef)
{
error(ERR_INVALID_LAMBDA_CAPTURE_MODE);
}
localMode = cmRef;
lex = getsym();
}
else
{
if (localMode == cmValue)
{
error(ERR_INVALID_LAMBDA_CAPTURE_MODE);
}
localMode = cmValue;
}
if (ISID(lex))
{
SYMBOL *sp = search(lex->value.s.a, localNameSpace->syms);
LAMBDA *current = lambdas;
while (current && !sp)
{
sp = search(lex->value.s.a, current->oldSyms);
current = current->next;
}
lex = getsym();
if (sp)
{
if (sp->packed)
{
if (!MATCHKW(lex, ellipse))
error(ERR_PACK_SPECIFIER_REQUIRED_HERE);
else
lex = getsym();
}
if (sp->packed)
{
int n;
TEMPLATEPARAMLIST * templateParam = sp->tp->templateParam->p->byPack.pack;
HASHREC *hr;
for (n=0; templateParam; templateParam = templateParam->next, n++);
hr = funcsp->tp->syms->table[0];
while (hr && ((SYMBOL *)hr->p) != sp)
hr = hr->next;
while (hr && n)
{
lambda_capture((SYMBOL *)hr->p, localMode, TRUE);
hr = hr->next;
n--;
}
}
else
{
lambda_capture(sp, localMode, TRUE);
}
}
else
errorstr(ERR_UNDEFINED_IDENTIFIER, lex->value.s.a);
}
else
{
error(ERR_INVALID_LAMBDA_CAPTURE_MODE);
}
} while (MATCHKW(lex, comma));
}
needkw(&lex, closebr);
}
else
{
if (!MATCHKW(lex, closebr))
{
error(ERR_LAMBDA_CANNOT_CAPTURE);
}
else
{
lex = getsym();
}
}
if (MATCHKW(lex, openpa))
{
TYPE *tpx = &stdvoid;
HASHREC *hr;
lex = getFunctionParams(lex, NULL, &self->func, &tpx, FALSE, sc_auto);
self->funcargs = self->func->tp->syms->table[0];
hr = self->func->tp->syms->table[0];
while (hr)
{
SYMBOL *sym = (SYMBOL *)hr->p;
if (sym->init)
{
error(ERR_CANNOT_DEFAULT_PARAMETERS_WITH_LAMBDA);
}
hr = hr->next;
}
if (MATCHKW(lex, kw_mutable))
{
HASHREC *hr = self->captured->table[0];
while (hr)
{
LAMBDASP *lsp = (LAMBDASP *)hr->p;
if (lsp->sym->lambdaMode == cmValue)
{
lsp->sym->tp = basetype(lsp->sym->tp);
}
hr = hr->next;
}
self->isMutable = TRUE;
lex = getsym();
}
ParseAttributeSpecifiers(&lex, funcsp, TRUE);
if (MATCHKW(lex, pointsto))
{
lex = getsym();
lex = get_type_id(lex, &self->functp, funcsp, sc_cast, FALSE, TRUE);
}
}
else
{
TYPE *tp1 = Alloc(sizeof(TYPE));
SYMBOL *spi;
tp1->type = bt_func;
tp1->size = getSize(bt_pointer);
tp1->btp = &stdvoid;
tp1->sp = self->func;
self->func->tp = tp1;
spi = makeID(sc_parameter, tp1, NULL, AnonymousName());
spi->anonymous = TRUE;
spi->tp = Alloc(sizeof(TYPE));
spi->tp->type = bt_void;
insert(spi, localNameSpace->syms);
SetLinkerNames(spi, lk_cpp);
self->func->tp->syms = localNameSpace->syms;
self->funcargs = self->func->tp->syms->table[0];
self->func->tp->syms->table[0] = NULL;
}
vpl = makeID(sc_parameter, &stdpointer, NULL, AnonymousName());
vpl->assigned = vpl->used = TRUE;
SetLinkerNames(vpl, lk_cdecl);
hrl = Alloc(sizeof(HASHREC));
hrl->p = (struct _hrintern_ *)vpl;
hrl->next = lambdas->func->tp->syms->table[0];
lambdas->func->tp->syms->table[0] = hrl;
vpl = makeID(sc_parameter, &stdpointer, NULL, AnonymousName());
vpl->assigned = vpl->used = TRUE;
SetLinkerNames(vpl, lk_cdecl);
hrl = Alloc(sizeof(HASHREC));
hrl->p = (struct _hrintern_ *)vpl;
hrl->next = lambdas->func->tp->syms->table[0];
lambdas->func->tp->syms->table[0] = hrl;
SetLinkerNames(lambdas->func, lk_cdecl);
injectThisPtr(lambdas->func, basetype(lambdas->func->tp)->syms);
lambdas->func->tp->btp = self->functp;
lambdas->func->linkage = lk_virtual;
lambdas->func->isInline = TRUE;
ssl.str = self->cls;
ssl.tmpl = NULL;
addStructureDeclaration(&ssl);
ths = makeID(sc_member, &stdpointer, NULL, "$this");
lambda_insert(ths, lambdas);
if (MATCHKW(lex, begin))
{
lex = body(lex, self->func);
}
else
{
error(ERR_LAMBDA_FUNCTION_BODY_EXPECTED);
}
dropStructureDeclaration();
localNameSpace->syms = self->oldSyms;
localNameSpace->tags = self->oldTags;
inferType();
finishClass();
*exp = createLambda(0);
*tp = lambdas->cls->tp;
lambdas = lambdas->next;
if (lambdas)
lambdas->prev = NULL;
DecGlobalFlag();
return lex;
}
double SimpleRMSD::calc( const std::vector<Vector>& pos, const bool& squared ){
return myrmsd.simpleAlignment( getAlign(), getDisplace(), pos, getReferencePositions(), atom_ders, displacement, squared );
}
