int
main(int argc, char *argv[])
{
char *infile, *swf, *outfile;
long work_factor;
char *cptr;
unsigned char *param, *dp;
size_t param_len, dp_len;
if (argc != 4) {
usage();
}
infile = argv[1];
swf = argv[2];
outfile = argv[3];
work_factor = strtol(swf, &cptr, 0);
if (*swf == 0 || *cptr != 0 || work_factor < 0) {
usage();
}
param = read_file(infile, ¶m_len);
CF(makwa_delegation_generate(param, param_len,
work_factor, NULL, &dp_len));
dp = xmalloc(dp_len);
CF(makwa_delegation_generate(param, param_len,
work_factor, dp, &dp_len));
write_file(outfile, dp, dp_len);
xfree(param);
xfree(dp);
return 0;
}
Word CF(Word L,Word F,Word P)
{
Word Fp,A,Ap,f;
switch(FIRST(F)) {
case (TRUE) : Fp = F; break;
case (FALSE) : Fp = F; break;
case (ANDOP) :
A = RED(F);
for(Ap = NIL; A != NIL; A = RED(A)) {
f = CF(L,FIRST(A),P);
if (FIRST(f) == FALSE) {
Fp = f;
goto Return; }
if (FIRST(f) != TRUE)
Ap = COMP(f,Ap); }
if (Ap == NIL)
Fp = LIST1(TRUE);
else if (LENGTH(Ap) == 1)
Fp = FIRST(Ap);
else
Fp = COMP(ANDOP,Ap);
break;
case (OROP) :
A = RED(F);
for(Ap = NIL; A != NIL; A = RED(A)) {
f = CF(L,FIRST(A),P);
if (FIRST(f) == TRUE) {
Fp = f;
goto Return; }
if (FIRST(f) != FALSE)
Ap = COMP(f,Ap); }
if (Ap == NIL)
Fp = LIST1(FALSE);
else if (LENGTH(Ap) == 1)
Fp = FIRST(Ap);
else
Fp = COMP(OROP,Ap);
break;
default:
f = UNIFORMTV(L,F,P);
if (f == UNDET)
Fp = F;
else
Fp = LIST1(f);
break; }
Return:
return Fp;
}
int
main(int argc, char *argv[])
{
char *nargv[3];
int i, nargc;
char *infile, *swf, *outfile;
long work_factor;
char *cptr;
unsigned char *param, *dp;
size_t param_len, dp_len;
int param_type;
nargc = 0;
param_type = MAKWA_RANDOM_PAIRS;
for (i = 1; i < argc; i ++) {
if (eq_nocase(argv[i], "-genX")) {
param_type = MAKWA_GENERATOR_EXPAND;
} else if (eq_nocase(argv[i], "-gen1")) {
param_type = MAKWA_GENERATOR_ONLY;
} else {
if (nargc >= 3) {
usage();
}
nargv[nargc ++] = argv[i];
}
}
if (nargc != 3) {
usage();
}
infile = nargv[0];
swf = nargv[1];
outfile = nargv[2];
work_factor = strtol(swf, &cptr, 0);
if (*swf == 0 || *cptr != 0 || work_factor < 0) {
usage();
}
param = read_file(infile, ¶m_len);
CF(makwa_delegation_generate_gen(param, param_len,
work_factor, param_type, NULL, &dp_len));
dp = xmalloc(dp_len);
CF(makwa_delegation_generate_gen(param, param_len,
work_factor, param_type, dp, &dp_len));
write_file(outfile, dp, dp_len);
xfree(param);
xfree(dp);
return 0;
}
/*
Inputs
S: a set of cells of level k - 1.
F: a DNF formula (formally speaking!)
P: the projection factors that go with the cells in S.
Outputs
Fp: a formula that, restricted to the children of S, is
equivalent to F.
*/
Word CLEANUPFORM(Word S,Word F,Word P)
{
Word Sp,L,Fp;
for(Sp = S, L = NIL; Sp != NIL; Sp = RED(Sp))
L = CCONC(LELTI(FIRST(Sp),SC_CDTV),L);
Fp = CF(L,F,P);
return Fp;
}
void Cells::add( const char* row, const char* columnFamily, const char* columnQualifier, uint64_t timestamp, const void* value, uint32_t valueLength, uint8_t flag ) {
if( valueLength > Cell::MaxSize ) {
HT4C_THROW_ARGUMENT("cell value exceeds the limit", "valueLength");
}
flag = FLAG( columnFamily, columnQualifier, flag );
Cell cell( row
, CF(columnFamily)
, columnQualifier
, TIMESTAMP(timestamp, flag)
, value
, valueLength
, flag);
cellsBuilder->add( cell.get(), true );
}
static void
c_f_conversion(double *cels_arr, double *far_arr, int arr_len)
{
int val_len;
int sign;
int dot_pos;
char buff[BUFF_SIZE+1];
for (int i = 0; i < arr_len; i++) {
val_len = 0;
sign = 0;
dot_pos = 0;
for (int j = 0; j < BUFF_SIZE; j++) { buff[j] = '0'; }
double_to_buff(cels_arr[i], buff, &val_len, &dot_pos, &sign);
CF(buff, &val_len, &dot_pos, &sign);
far_arr[i] = buff_to_double(buff, dot_pos, sign);
}
}
void Node::Print_Summary(Stat *Stats, std::ofstream &fo) const
{
Entry tmpent;
tmpent.Init(entry[0].sx.dim);
CF(tmpent);
fo<<"Root CF\t"<<tmpent<<std::endl;
fo<<"FootPrint\t"<<sqrt(tmpent.Radius())<<std::endl;
#ifdef RECTANGLE
Rectangle tmprect;
tmprect.Init(entry[0].sx.dim);
Rect(tmprect);
fo<<"Root Rectangle\t"<<tmprect<<std::endl;
#endif RECTANGLE
fo<<"Leaf Nodes\t"<<LeafNum()<<std::endl;
fo<<"Nonleaf Nodes\t"<<NonleafNum()<<std::endl;
fo<<"Tree Size\t"<<Size()<<std::endl;
fo<<"Tree Depth\t"<<Depth()<<std::endl;
fo<<"Leaf Entries\t"<<NumLeafEntry()<<std::endl;
fo<<"Nonleaf Entries\t"<<NumNonleafEntry()<<std::endl;
fo<<"Occupancy\t"<<Occupancy(Stats)<<std::endl;
}
//===================
// PRIVATE
//===================
bool WebServer::setupWebSocket(quint16 port){
WSServer = new QWebSocketServer("sysadm-server", QWebSocketServer::SecureMode, this);
//SSL Configuration
QSslConfiguration config = QSslConfiguration::defaultConfiguration();
QFile CF( QStringLiteral(SSLCERTFILE) );
if(CF.open(QIODevice::ReadOnly) ){
QSslCertificate CERT(&CF,QSsl::Pem);
config.setLocalCertificate( CERT );
CF.close();
}else{
qWarning() << "Could not read WS certificate file:" << CF.fileName();
}
QFile KF( QStringLiteral(SSLKEYFILE));
if(KF.open(QIODevice::ReadOnly) ){
QSslKey KEY(&KF, QSsl::Rsa, QSsl::Pem);
config.setPrivateKey( KEY );
KF.close();
}else{
qWarning() << "Could not read WS key file:" << KF.fileName();
}
config.setPeerVerifyMode(QSslSocket::VerifyNone);
config.setProtocol(SSLVERSION);
WSServer->setSslConfiguration(config);
//Setup Connections
connect(WSServer, SIGNAL(newConnection()), this, SLOT(NewSocketConnection()) );
connect(WSServer, SIGNAL(acceptError(QAbstractSocket::SocketError)), this, SLOT(NewConnectError(QAbstractSocket::SocketError)) );
// -- websocket specific signals
connect(WSServer, SIGNAL(closed()), this, SLOT(ServerClosed()) );
connect(WSServer, SIGNAL(serverError(QWebSocketProtocol::CloseCode)), this, SLOT(ServerError(QWebSocketProtocol::CloseCode)) );
connect(WSServer, SIGNAL(originAuthenticationRequired(QWebSocketCorsAuthenticator*)), this, SLOT(OriginAuthRequired(QWebSocketCorsAuthenticator*)) );
connect(WSServer, SIGNAL(peerVerifyError(const QSslError&)), this, SLOT(PeerVerifyError(const QSslError&)) );
connect(WSServer, SIGNAL(sslErrors(const QList<QSslError>&)), this, SLOT(SslErrors(const QList<QSslError>&)) );
connect(WSServer, SIGNAL(acceptError(QAbstractSocket::SocketError)), this, SLOT(ConnectError(QAbstractSocket::SocketError)) );
//Now start the server
return WSServer->listen(QHostAddress::Any, port);
}
void MODEL::Boundary()
{
char text[200];
// initializations ---------------------------------------------------------------------
if( !boundList )
{
boundList = new ELEM* [region->Getnp()];
if( !boundList )
REPORT::rpt.Error( kMemoryFault, "can not allocate memory - MODEL::Boundary(1)" );
}
for( int n=0; n<region->Getnp(); n++ )
{
NODE* nd = region->Getnode(n);
CF( nd->flag, NODE::kBound );
nd->mark = false;
// remove slip boundary conditions ---------------------------------------------------
if( isFS(nd->bc.kind, BCON::kAutoSlip) )
{
CF( nd->bc.kind, BCON::kAutoSlip | BCON::kFixU | BCON::kFixV );
}
if( isFS(nd->bc.kind, BCON::kAutoKD) )
{
CF( nd->bc.kind, BCON::kAutoKD | BCON::kFixK | BCON::kFixD );
}
}
// determine boundary midside nodes ----------------------------------------------------
for( int n=0; n<region->Getnp(); n++ )
{
NODE* nd = region->Getnode(n);
// midside nodes which are connected to only one element are boundary nodes ----------
if( nd->noel == 1 && isFS(nd->flag, NODE::kMidsNode) )
{
if( !isFS(nd->flag, NODE::kInface) ) SF( nd->flag, NODE::kBound );
}
}
// determine number of boundary elements: nb -------------------------------------------
int nb = 0;
for( int n=0; n<region->Getnp(); n++ )
{
if( isFS(region->Getnode(n)->flag,NODE::kBound) ) nb++;
}
// allocate memory for boundary elements -----------------------------------------------
bound->Free();
bound->Alloc( 0, nb );
// set up boundary elements ------------------------------------------------------------
int be = 0; // counter for boundary elements
for( int re=0; re<region->Getne(); re++ )
{
ELEM* el = region->Getelem(re);
if( isFS(el->flag, ELEM::kDry) ) continue;
int ncn = el->Getncn();
int nnd = el->Getnnd();
for( int i=ncn; i<nnd; i++ )
{
// check, if el->nd[i] is a midside boundary node ----------------------------------
if( isFS(el->nd[i]->flag, NODE::kBound) )
{
ELEM* bd = bound->Getelem(be);
boundList[el->nd[i]->Getno()] = bd;
int left = i - ncn;
int rght = (left + 1) % ncn;
bd->nd[0] = el->nd[left]; // corner nodes
bd->nd[1] = el->nd[rght];
bd->nd[2] = el->nd[i]; // midside node
SF( bd->nd[0]->flag, NODE::kBound );
SF( bd->nd[1]->flag, NODE::kBound );
// set shape specifications ------------------------------------------------------
bd->Setshape( kLine );
bd->Setname( el->Getname() );
SF( bd->flag, ELEM::kBound );
bd->type = el->type;
bd->areaFact = 1.0;
be++;
}
}
}
////////////////////////////////////////////////////////////////////////////////////////
// communicate boundary nodes
//# ifdef _MPI_DBG
// REPORT::rpt.Output( " (MODEL::Boundary) communication of boundary nodes", 1 );
//# endif
# ifdef _MPI_
if( subdom->npr > 1 )
{
INFACE* inface = subdom->inface;
// loop on all interfaces: exchange bound flag ---------------------------------------
for( int s=0; s<subdom->npr; s++ )
{
MPI_Status status;
int npinf = inface[s].np;
if( npinf > 0 )
{
for( int n=0; n<npinf; n++ )
{
NODE* nd = inface[s].node[n];
if( isFS(nd->flag, NODE::kBound) ) inface[s].sia1[n] = true;
else inface[s].sia1[n] = false;
}
MPI_Sendrecv( inface[s].sia1, npinf, MPI_CHAR, s, 1,
inface[s].ria1, npinf, MPI_CHAR, s, 1,
MPI_COMM_WORLD, &status );
for( int n=0; n<npinf; n++ )
{
NODE* nd = inface[s].node[n];
if( inface[s].ria1[n] ) SF( nd->flag, NODE::kBound );
}
}
}
}
# endif
////////////////////////////////////////////////////////////////////////////////////////
// -------------------------------------------------------------------------------------
// count for newly required boundary conditions
// note: (sc, 30.10.2004)
// a boundary condition is needed for marsh-nodes in case of dry-rewet-method 3
int nbc = 0;
for( int n=0; n<region->Getnp(); n++ )
{
NODE* nd = region->Getnode(n);
if( isFS(nd->flag, NODE::kBound) ) nbc++;
}
sprintf( text,"\n (MODEL::Boundary) number of boundary elements: %d\n", nb );
REPORT::rpt.Output( text, 3 );
# ifdef kDebug
{
int pid;
MPI_Comm_rank( MPI_COMM_WORLD, &pid );
char fname[40];
sprintf( fname, "bound_%02d.inp", pid+1 );
FILE* id = fopen( fname, "w" );
for( int n=0; n<region->Getnp(); n++ )
{
NODE* nd = region->Getnode(n);
CF( nd->flag, NODE::kMarker );
}
for( int e=0; e<bound->Getne(); e++ )
{
ELEM* el = bound->Getelem(e);
for( int i=0; i<el->getnnd(); i++ )
{
SF( el->nd[i]->flag, NODE::kMarker );
}
}
int j = 0;
for( int n=0; n<region->Getnp(); n++ )
{
NODE* nd = region->Getnode(n);
if( isFS(nd->flag, NODE::kMarker) ) j++;
}
fprintf( id, "%6d %6d 0 0 0\n", j, nb );
for( int n=0; n<region->Getnp(); n++ )
{
NODE* nd = region->Getnode(n);
if( isFS(nd->flag, NODE::kMarker) )
{
fprintf( id, "%6d %17.9le %17.9le %17.9le\n",
nd->Getname(), nd->x, nd->y, nd->z );
}
}
for( int e=0; e<bound->Getne(); e++ )
{
ELEM* el = bound->Getelem(e);
fprintf( id, "%6d %3d line %6d %6d %6d\n",
el->Getname(), TYPE::getid(el->type),
el->nd[0]->Getname(), el->nd[1]->Getname(), el->nd[2]->Getname() );
}
fclose( id );
}
# endif
}
void ThriftTableMutator::set( const char* columnFamily, const char* columnQualifier, uint64_t timestamp, const void* value, uint32_t valueLength, std::string& row ) {
row = Common::KeyBuilder();
set( row.c_str(), CF(columnFamily), columnQualifier, timestamp, value, valueLength, Hypertable::FLAG_INSERT );
}
TESTLAYER_CREATE_FUNC(SchedulerPauseResume)
TESTLAYER_CREATE_FUNC(SchedulerPauseResumeAll)
TESTLAYER_CREATE_FUNC(SchedulerPauseResumeAllUser)
TESTLAYER_CREATE_FUNC(SchedulerUnscheduleAll)
TESTLAYER_CREATE_FUNC(SchedulerUnscheduleAllHard)
TESTLAYER_CREATE_FUNC(SchedulerUnscheduleAllUserLevel)
TESTLAYER_CREATE_FUNC(SchedulerSchedulesAndRemove)
TESTLAYER_CREATE_FUNC(SchedulerUpdate)
TESTLAYER_CREATE_FUNC(SchedulerUpdateAndCustom)
TESTLAYER_CREATE_FUNC(SchedulerUpdateFromCustom)
TESTLAYER_CREATE_FUNC(RescheduleSelector)
TESTLAYER_CREATE_FUNC(SchedulerDelayAndRepeat)
TESTLAYER_CREATE_FUNC(SchedulerIssue2268)
static NEWTESTFUNC createFunctions[] = {
CF(SchedulerTimeScale),
CF(TwoSchedulers),
CF(SchedulerAutoremove),
CF(SchedulerPauseResume),
CF(SchedulerPauseResumeAll),
CF(SchedulerPauseResumeAllUser),
CF(SchedulerUnscheduleAll),
CF(SchedulerUnscheduleAllHard),
CF(SchedulerUnscheduleAllUserLevel),
CF(SchedulerSchedulesAndRemove),
CF(SchedulerUpdate),
CF(SchedulerUpdateAndCustom),
CF(SchedulerUpdateFromCustom),
CF(RescheduleSelector),
CF(SchedulerDelayAndRepeat),
CF(SchedulerIssue2268)
TESTLAYER_CREATE_FUNC(CommonLayerClip);
TESTLAYER_CREATE_FUNC(CommonLocale);
TESTLAYER_CREATE_FUNC(CommonLocalization);
TESTLAYER_CREATE_FUNC(CommonMenuItemColor);
TESTLAYER_CREATE_FUNC(CommonProgressHUD);
TESTLAYER_CREATE_FUNC(CommonRichLabel);
TESTLAYER_CREATE_FUNC(CommonRichLabel2);
TESTLAYER_CREATE_FUNC(CommonResourceLoader);
TESTLAYER_CREATE_FUNC(CommonRookieGuide);
TESTLAYER_CREATE_FUNC(CommonScreenshot);
TESTLAYER_CREATE_FUNC(CommonSlider);
TESTLAYER_CREATE_FUNC(CommonTiledSprite);
TESTLAYER_CREATE_FUNC(CommonToast);
static NEWTESTFUNC createFunctions[] = {
CF(CommonCalendar),
CF(CommonCallFuncT),
CF(CommonCatmullRomSprite),
CF(CommonGradientSprite),
CF(CommonImagePicker),
CF(CommonLaserSprite),
CF(CommonLayerClip),
CF(CommonLocale),
CF(CommonLocalization),
CF(CommonMenuItemColor),
CF(CommonProgressHUD),
CF(CommonRichLabel),
CF(CommonRichLabel2),
CF(CommonResourceLoader),
CF(CommonRookieGuide),
CF(CommonScreenshot),
#include "CommonTest.h"
#include "../testResource.h"
#include "cocos2d.h"
TESTLAYER_CREATE_FUNC(CommonCalendar);
TESTLAYER_CREATE_FUNC(CommonGradientSprite);
TESTLAYER_CREATE_FUNC(CommonLocale);
TESTLAYER_CREATE_FUNC(CommonLocalization);
TESTLAYER_CREATE_FUNC(CommonMissile);
TESTLAYER_CREATE_FUNC(CommonRichLabel);
TESTLAYER_CREATE_FUNC(CommonShake);
TESTLAYER_CREATE_FUNC(CommonTiledSprite);
TESTLAYER_CREATE_FUNC(CommonTreeFadeInOut);
static NEWTESTFUNC createFunctions[] = {
CF(CommonCalendar),
CF(CommonGradientSprite),
CF(CommonLocale),
CF(CommonLocalization),
CF(CommonMissile),
CF(CommonRichLabel),
CF(CommonShake),
CF(CommonTiledSprite),
CF(CommonTreeFadeInOut),
};
static int sceneIdx=-1;
#define MAX_LAYER (sizeof(createFunctions) / sizeof(createFunctions[0]))
static CCLayer* nextAction()
{
static VALUE FuncTable[10][10];
DEFCALLBACK(0)
DEFCALLBACK(1)
DEFCALLBACK(2)
DEFCALLBACK(3)
DEFCALLBACK(4)
DEFCALLBACK(5)
DEFCALLBACK(6)
DEFCALLBACK(7)
DEFCALLBACK(8)
DEFCALLBACK(9)
void *CallbackTable[10][10] = {
{CF(0,0),CF(0,1),CF(0,2),CF(0,3),CF(0,4),CF(0,5),CF(0,6),CF(0,7),CF(0,8),CF(0,9)},
{CF(1,0),CF(1,1),CF(1,2),CF(1,3),CF(1,4),CF(1,5),CF(1,6),CF(1,7),CF(1,8),CF(1,9)},
{CF(2,0),CF(2,1),CF(2,2),CF(2,3),CF(2,4),CF(2,5),CF(2,6),CF(2,7),CF(2,8),CF(2,9)},
{CF(3,0),CF(3,1),CF(3,2),CF(3,3),CF(3,4),CF(3,5),CF(3,6),CF(3,7),CF(3,8),CF(3,9)},
{CF(4,0),CF(4,1),CF(4,2),CF(4,3),CF(4,4),CF(4,5),CF(4,6),CF(4,7),CF(4,8),CF(4,9)},
{CF(5,0),CF(5,1),CF(5,2),CF(5,3),CF(5,4),CF(5,5),CF(5,6),CF(5,7),CF(5,8),CF(5,9)},
{CF(6,0),CF(6,1),CF(6,2),CF(6,3),CF(6,4),CF(6,5),CF(6,6),CF(6,7),CF(6,8),CF(6,9)},
{CF(7,0),CF(7,1),CF(7,2),CF(7,3),CF(7,4),CF(7,5),CF(7,6),CF(7,7),CF(7,8),CF(7,9)},
{CF(8,0),CF(8,1),CF(8,2),CF(8,3),CF(8,4),CF(8,5),CF(8,6),CF(8,7),CF(8,8),CF(8,9)},
{CF(9,0),CF(9,1),CF(9,2),CF(9,3),CF(9,4),CF(9,5),CF(9,6),CF(9,7),CF(9,8),CF(9,9)}};
void *find_callback(VALUE obj,int len)
{
int i;
for(i=0;i<10;i++)
char *
mnote_pentax_entry_get_value (MnotePentaxEntry *entry,
char *val, unsigned int maxlen)
{
ExifLong vl;
ExifShort vs, vs2;
int i = 0, j = 0;
if (!entry) return (NULL);
memset (val, 0, maxlen);
maxlen--;
switch (entry->tag) {
case MNOTE_PENTAX_TAG_MODE:
case MNOTE_PENTAX_TAG_QUALITY:
case MNOTE_PENTAX_TAG_FOCUS:
case MNOTE_PENTAX_TAG_FLASH:
case MNOTE_PENTAX_TAG_WHITE_BALANCE:
case MNOTE_PENTAX_TAG_SHARPNESS:
case MNOTE_PENTAX_TAG_CONTRAST:
case MNOTE_PENTAX_TAG_SATURATION:
case MNOTE_PENTAX_TAG_ISO_SPEED:
case MNOTE_PENTAX_TAG_COLOR:
case MNOTE_PENTAX2_TAG_MODE:
case MNOTE_PENTAX2_TAG_QUALITY:
case MNOTE_PENTAX2_TAG_FLASH_MODE:
case MNOTE_PENTAX2_TAG_FOCUS_MODE:
case MNOTE_PENTAX2_TAG_AFPOINT_SELECTED:
case MNOTE_PENTAX2_TAG_AUTO_AFPOINT:
case MNOTE_PENTAX2_TAG_WHITE_BALANCE:
case MNOTE_PENTAX2_TAG_PICTURE_MODE:
case MNOTE_PENTAX2_TAG_IMAGE_SIZE:
case MNOTE_CASIO2_TAG_BESTSHOT_MODE:
CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
CC2 (entry->components, 1, 2, val, maxlen);
if (entry->components == 1) {
vs = exif_get_short (entry->data, entry->order);
/* search the tag */
for (i = 0; (items[i].tag && items[i].tag != entry->tag); i++);
if (!items[i].tag) {
snprintf (val, maxlen,
_("Internal error (unknown value %i)"), vs);
break;
}
/* find the value */
for (j = 0; items[i].elem[j].string &&
(items[i].elem[j].index < vs); j++);
if (items[i].elem[j].index != vs) {
snprintf (val, maxlen,
_("Internal error (unknown value %i)"), vs);
break;
}
strncpy (val, _(items[i].elem[j].string), maxlen);
} else {
/* Two-component values */
CF (entry->format, EXIF_FORMAT_SHORT, val, maxlen);
CC2 (entry->components, 1, 2, val, maxlen);
vs = exif_get_short (entry->data, entry->order);
vs2 = exif_get_short (entry->data+2, entry->order) << 16;
/* search the tag */
for (i = 0; (items2[i].tag && items2[i].tag != entry->tag); i++);
if (!items2[i].tag) {
snprintf (val, maxlen,
_("Internal error (unknown value %i %i)"), vs, vs2);
break;
}
/* find the value */
for (j = 0; items2[i].elem[j].string && ((items2[i].elem[j].index2 < vs2)
|| ((items2[i].elem[j].index2 == vs2) && (items2[i].elem[j].index1 < vs))); j++);
if ((items2[i].elem[j].index1 != vs) || (items2[i].elem[j].index2 != vs2)) {
snprintf (val, maxlen,
_("Internal error (unknown value %i %i)"), vs, vs2);
break;
}
strncpy (val, _(items2[i].elem[j].string), maxlen);
}
break;
case MNOTE_PENTAX_TAG_ZOOM:
CF (entry->format, EXIF_FORMAT_LONG, val, maxlen);
CC (entry->components, 1, val, maxlen);
vl = exif_get_long (entry->data, entry->order);
snprintf (val, maxlen, "%li", (long int) vl);
break;
case MNOTE_PENTAX_TAG_PRINTIM:
CF (entry->format, EXIF_FORMAT_UNDEFINED, val, maxlen);
CC (entry->components, 124, val, maxlen);
snprintf (val, maxlen, _("%i bytes unknown data"),
entry->size);
break;
case MNOTE_PENTAX_TAG_TZ_CITY:
case MNOTE_PENTAX_TAG_TZ_DST:
CF (entry->format, EXIF_FORMAT_UNDEFINED, val, maxlen);
CC (entry->components, 4, val, maxlen);
strncpy (val, (char*)entry->data, MIN(maxlen, entry->size));
break;
case MNOTE_PENTAX2_TAG_DATE:
CF (entry->format, EXIF_FORMAT_UNDEFINED, val, maxlen);
CC (entry->components, 4, val, maxlen);
/* Note: format is UNDEFINED, not SHORT -> order is fixed: MOTOROLA */
vs = exif_get_short (entry->data, EXIF_BYTE_ORDER_MOTOROLA);
snprintf (val, maxlen, "%i:%02i:%02i", vs, entry->data[2], entry->data[3]);
break;
case MNOTE_PENTAX2_TAG_TIME:
CF (entry->format, EXIF_FORMAT_UNDEFINED, val, maxlen);
CC2 (entry->components, 3, 4, val, maxlen);
snprintf (val, maxlen, "%02i:%02i:%02i", entry->data[0], entry->data[1], entry->data[2]);
break;
default:
switch (entry->format) {
case EXIF_FORMAT_ASCII:
strncpy (val, (char *)entry->data, MIN(maxlen, entry->size));
break;
case EXIF_FORMAT_SHORT:
{
const unsigned char *data = entry->data;
size_t k, len = strlen(val);
for(k=0; k<entry->components; k++) {
vs = exif_get_short (data, entry->order);
snprintf (val+len, maxlen-len, "%i ", vs);
len = strlen(val);
data += 2;
}
}
break;
case EXIF_FORMAT_LONG:
{
const unsigned char *data = entry->data;
size_t k, len = strlen(val);
for(k=0; k<entry->components; k++) {
vl = exif_get_long (data, entry->order);
snprintf (val+len, maxlen-len, "%li", (long int) vl);
len = strlen(val);
data += 4;
}
}
break;
case EXIF_FORMAT_UNDEFINED:
default:
snprintf (val, maxlen, _("%i bytes unknown data"),
entry->size);
break;
}
break;
}
return (val);
}
TESTLAYER_CREATE_FUNC(HoleDemo);
TESTLAYER_CREATE_FUNC(ShapeTest);
TESTLAYER_CREATE_FUNC(ShapeInvertedTest);
TESTLAYER_CREATE_FUNC(SpriteTest);
TESTLAYER_CREATE_FUNC(SpriteNoAlphaTest);
TESTLAYER_CREATE_FUNC(SpriteInvertedTest);
TESTLAYER_CREATE_FUNC(NestedTest);
TESTLAYER_CREATE_FUNC(RawStencilBufferTest);
TESTLAYER_CREATE_FUNC(RawStencilBufferTest2);
TESTLAYER_CREATE_FUNC(RawStencilBufferTest3);
TESTLAYER_CREATE_FUNC(RawStencilBufferTest4);
TESTLAYER_CREATE_FUNC(RawStencilBufferTest5);
TESTLAYER_CREATE_FUNC(RawStencilBufferTest6);
static NEWTESTFUNC createFunctions[] = {
CF(ScrollViewDemo),
CF(HoleDemo),
CF(ShapeTest),
CF(ShapeInvertedTest),
CF(SpriteTest),
CF(SpriteNoAlphaTest),
CF(SpriteInvertedTest),
CF(NestedTest),
CF(RawStencilBufferTest),
CF(RawStencilBufferTest2),
CF(RawStencilBufferTest3),
CF(RawStencilBufferTest4),
CF(RawStencilBufferTest5),
CF(RawStencilBufferTest6)
};
int GRID::Dry( double dryLimit,
int countDown )
{
// initialization: mark all dry nodes and elements -------------------------------------
for( int n=0; n<Getnp(); n++ )
{
NODE* nd = Getnode(n);
if( isFS(nd->flag, NODE::kDry) ) nd->mark = true;
else nd->mark = false;
SF( nd->flag, NODE::kDry );
}
for( int e=0; e<Getne(); e++ )
{
ELEM* el = Getelem(e);
if ( isFS(el->flag, ELEM::kDry) ) el->mark = true;
else el->mark = false;
CF( el->flag, ELEM::kDry );
}
// loop on all elements ----------------------------------------------------------------
for( int e=0; e<Getne(); e++ )
{
ELEM* el = Getelem(e);
int ncn = el->Getncn();
for( int i=0; i<ncn; i++ )
{
// set element dry, if flow depth is less than dry limit ---------------------------
// or the node was already dry
double H = el->nd[i]->v.S - el->nd[i]->z;
if( H < dryLimit || el->nd[i]->mark )
{
SF( el->flag, ELEM::kDry );
}
}
}
// loop on all elements: all nodes at wet elements are wet -----------------------------
for( int e=0; e<Getne(); e++ )
{
ELEM* el = Getelem(e);
if( !isFS(el->flag, ELEM::kDry) )
{
int nnd = el->Getnnd();
for( int i=0; i<nnd; i++ ) CF( el->nd[i]->flag, NODE::kDry );
}
}
// report all nodes that have got newly dry --------------------------------------------
REPORT::rpt.Output( "\n (dry) the following nodes have got dry\n", 5 );
int jdry = 0;
for( int n=0; n<Getnp(); n++ )
{
NODE* nd = Getnode(n);
if( isFS(nd->flag, NODE::kDry) )
{
nd->v.U = 0.0;
nd->v.V = 0.0;
nd->v.S = nd->z;
nd->v.K = 0.0;
nd->v.D = 0.0;
nd->v.dUdt = 0.0;
nd->v.dVdt = 0.0;
nd->v.dSdt = 0.0;
if( !nd->mark )
{
nd->countDown = countDown;
char text[20];
sprintf( text, " %5d", nd->Getname() );
REPORT::rpt.Output( text, 2 );
jdry++;
if( !( jdry % 10) ) REPORT::rpt.Output( "\n", 5 );
}
}
nd->mark = false;
}
if( jdry % 10 ) REPORT::rpt.Output( "\n", 5 );
// report all elements that have got newly dry -------------------------------------------
REPORT::rpt.Output( "\n (dry) the following elements have got dry\n", 5 );
int idry = 0;
for( int e=0; e<Getne(); e++ )
{
ELEM* el = Getelem( e );
if( isFS(el->flag, ELEM::kDry) && !el->mark )
{
char text[20];
sprintf( text, " %5d", el->Getname() );
REPORT::rpt.Output( text, 5 );
idry++;
if( !( idry % 10) ) REPORT::rpt.Output( "\n", 5 );
}
el->mark = false;
}
if( idry % 10 ) REPORT::rpt.Output( "\n", 5 );
return idry + jdry;
}
int GRID::Rewet( double rewetLimit,
int rewetPasses,
PROJECT* project )
{
int i, j, k;
int l, m, pass, ncn, nnd, rewetFlag;
double wElev, K, D, cm, cd, vt;
char text[80];
cm = project->KD.cm;
cd = project->KD.cd;
// initialization: mark all dry elements -----------------------------------------------
for( int e=0; e<Getne(); e++ )
{
ELEM* el = Getelem(e);
el->mark = false;
if( isFS(el->flag, ELEM::kDry) )
{
el->mark = true;
}
}
REPORT::rpt.Output( "\n (rewet) the following nodes have been rewetted\n", 5 );
m = 0;
for( pass=0; pass<rewetPasses; pass++ )
{
for( int n=0; n<Getnp(); n++ )
{
NODE* nd = Getnode(n);
nd->mark = false;
}
sprintf( text, " pass %d ...\n", pass+1 );
REPORT::rpt.Output( text, 5 );
for( int e=0; e<Getne(); e++ )
{
ELEM * el = Getelem(e);
if( isFS(el->flag, ELEM::kBound) ) continue;
TYPE* type = TYPE::Getid( el->type );
// look only for dry elements ------------------------------------------------------
if( isFS(el->flag, ELEM::kDry) )
{
// loop on corner nodes: minimal water elevation ---------------------------------
ncn = el->Getncn(); // number of corner nodes
nnd = el->Getnnd(); // total number of nodes
rewetFlag = false;
wElev = 0.0;
for( j=0, i=0; j<ncn; j++ )
{
if( !isFS(el->nd[j]->flag, NODE::kDry) )
{
// determine averaged water elevation at wet points --------------------------
rewetFlag = true;
wElev += el->nd[j]->v.S;
i++;
}
}
// loop on all nodes: check for rewetting ----------------------------------------
if( i )
{
wElev /= i;
for( j=0; j<nnd; j++ )
{
if( (wElev - el->nd[j]->z) < rewetLimit ) rewetFlag = false;
}
}
// if all nodes have been rewetted, rewet whole element --------------------------
if( rewetFlag )
{
for( j=0; j<ncn; j++ )
{
// re-initialize flow parameters ---------------------------------------------
if( isFS(el->nd[j]->flag, NODE::kDry) )
{
el->nd[j]->mark = true;
el->nd[j]->v.S = wElev;
}
}
for( j=ncn; j<nnd; j++ )
{
if( isFS(el->nd[j]->flag, NODE::kDry) )
{
el->nd[j]->mark = true;
// get left and right corner node to midside node j ------------------------
el->GetLShape()->getCornerNodes( j, &i, &k );
el->nd[j]->v.S = (el->nd[i]->v.S + el->nd[k]->v.S) / 2.0;
}
}
for( j=0; j<nnd; j++ )
{
if( isFS(el->nd[j]->flag, NODE::kDry) )
{
el->nd[j]->v.U = 0.0;
el->nd[j]->v.V = 0.0;
el->nd[j]->v.dUdt = 0.0;
el->nd[j]->v.dVdt = 0.0;
el->nd[j]->v.dSdt = 0.0;
K = el->nd[j]->v.K = dryRew.interpolate(el->nd[j], kVarK, 1);
D = el->nd[j]->v.D = dryRew.interpolate(el->nd[j], kVarD, 1);
if( isFS(project->actualTurb, BCONSET::kVtConstant) )
{
el->nd[j]->vt = type->vt;
}
else if( isFS(project->actualTurb, BCONSET::kVtPrandtlKol) )
{
if( fabs(D) > 0.0 ) vt = cm * cd * K * K / D;
else vt = 0.0;
el->nd[j]->vt = vt;
}
}
}
}
}
}
// check count down for nodes to be rewetted and report ------------------------------
l = 0;
for( int n=0; n<Getnp(); n++ )
{
NODE* nd = Getnode(n);
if( nd->mark )
{
nd->countDown--;
if( nd->countDown <= 0 )
{
CF( nd->flag, NODE::kDry );
// look for boundary conditions ------------------------------------------------
BCON *bc = &nd->bc;
// ... outflow boundary or fixed flow depth h --------------------------------
if( isFS(bc->kind, BCON::kOutlet) || isFS(bc->kind, BCON::kSetS) )
{
nd->v.S = bc->val->S;
}
// ... inflow boundary or fixed velocities U,V -------------------------------
if( isFS(bc->kind, BCON::kInlet) )
{
nd->v.U = bc->val->U * bc->niox / (nd->v.S - nd->z);
nd->v.V = bc->val->U * bc->nioy / (nd->v.S - nd->z);
}
else if( !isFS(bc->kind, BCON::kAutoSlip) )
{
if ( isFS(bc->kind, BCON::kFixU) ) nd->v.U = bc->val->U;
if ( isFS(bc->kind, BCON::kFixV) ) nd->v.V = bc->val->V;
}
# ifdef kDebug
sprintf( text,
" %5d (UVhKDvt): %9.2le %9.2le %9.2le %9.2le %9.2le %9.2le\n",
nd->Getname(),
nd->v.U,
nd->v.V,
nd->v.S - nd->z,
nd->v.K,
nd->v.D,
nd->vt );
REPORT::rpt.Output( text, 5 );
# else
sprintf( text, " %5d", nd->Getname() );
REPORT::rpt.Output( text, 5 );
l++;
if( !( l % 10) ) REPORT::rpt.Output( "\n", 5 );
# endif
m++;
}
else
{
nd->v.U = 0.0;
nd->v.V = 0.0;
nd->v.K = 0.0;
nd->v.D = 0.0;
nd->v.S = nd->z;
}
}
nd->mark = false;
}
# ifndef kDebug
if( l % 10 )
REPORT::rpt.Output( "\n", 5 );
# endif
// rewet all dry elements without dry nodes ------------------------------------------
for( int e=0; e<Getne(); e++ )
{
ELEM* el = Getelem(e);
if( isFS(el->flag, ELEM::kDry) )
{
nnd = el->Getnnd();
rewetFlag = true;
for( j=0; j<nnd; j++ )
{
if( isFS(el->nd[j]->flag, NODE::kDry) )
{
rewetFlag = false;
break;
}
}
if( rewetFlag )
{
CF( el->flag, ELEM::kDry );
}
}
}
}
// loop on all elements: all nodes at wet elements are wet -----------------------------
for( int n=0; n<Getnp(); n++ )
{
NODE* nd = Getnode(n);
SF( nd->flag, NODE::kDry );
nd->mark = false;
}
for( int e=0; e<Getne(); e++ )
{
ELEM* el = Getelem(e);
if( !isFS(el->flag, ELEM::kDry) )
{
nnd = el->Getnnd();
for( j=0; j<nnd; j++ ) CF( el->nd[j]->flag, NODE::kDry );
}
}
for( int n=0; n<Getnp(); n++ )
{
NODE* nd = Getnode(n);
if( isFS(nd->flag, NODE::kDry) )
{
nd->v.U = 0.0;
nd->v.V = 0.0;
nd->v.K = 0.0;
nd->v.D = 0.0;
nd->v.S = nd->z;
}
}
// report elements which have been rewetted --------------------------------------------
REPORT::rpt.Output( "\n (rewet) the following elements have been rewetted\n", 5 );
l = 0;
for( int e=0; e<Getne(); e++ )
{
ELEM* el = Getelem(e);
nnd = el->Getnnd();
if( el->mark && !isFS(el->flag, ELEM::kDry) )
{
for( j=0; j<nnd; j++ )
{
if( isFS(el->nd[j]->flag, NODE::kDry) )
REPORT::rpt.Error ("unexpected error - rewet (1)");
}
sprintf( text, " %5d", el->Getname() );
REPORT::rpt.Output( text, 5 );
l++;
if( !( l % 10) ) REPORT::rpt.Output( "\n", 5 );
}
el->mark = false;
}
if( l % 10 ) REPORT::rpt.Output( "\n", 5 );
# ifndef kDebug
if( l % 10 ) REPORT::rpt.Output( "\n", 5 );
# endif
return l;
}
#include "ConfigurationTest.h"
#include "../testResource.h"
#include "cocos2d.h"
TESTLAYER_CREATE_FUNC(ConfigurationLoadConfig);
TESTLAYER_CREATE_FUNC(ConfigurationQuery);
TESTLAYER_CREATE_FUNC(ConfigurationInvalid);
TESTLAYER_CREATE_FUNC(ConfigurationDefault);
TESTLAYER_CREATE_FUNC(ConfigurationSet);
static NEWTESTFUNC createFunctions[] = {
CF(ConfigurationLoadConfig),
CF(ConfigurationQuery),
CF(ConfigurationInvalid),
CF(ConfigurationDefault),
CF(ConfigurationSet)
};
static int sceneIdx=-1;
#define MAX_LAYER (sizeof(createFunctions) / sizeof(createFunctions[0]))
static Layer* nextAction()
{
sceneIdx++;
sceneIdx = sceneIdx % MAX_LAYER;
auto layer = (createFunctions[sceneIdx])();
layer->init();
layer->autorelease();
&this->architectures_from,
&this->architectures_into);
if (r == RET_NOTHING) {
fprintf(stderr,
"Warning parsing %s, line %u: an empty Architectures field\n"
"causes the whole rule to do nothing.\n",
config_filename(iter),
config_markerline(iter));
}
return r;
}
static const struct configfield pullconfigfields[] = {
CFr("Name", pull_rule, name),
CFr("From", pull_rule, from),
CF("Architectures", pull_rule, architectures),
CF("Components", pull_rule, components),
CF("UDebComponents", pull_rule, udebcomponents),
CF("FilterFormula", pull_rule, includecondition),
CF("FilterSrcList", pull_rule, filtersrclist),
CF("FilterList", pull_rule, filterlist)
};
retvalue pull_getrules(struct pull_rule **rules) {
struct pull_rule *pull = NULL;
retvalue r;
r = configfile_parse("pulls", IGNORABLE(unknownfield),
configparser_pull_rule_init, linkedlistfinish,
"pull rule",
pullconfigfields, ARRAYCOUNT(pullconfigfields), &pull);
main(int argc, char* argv[]){
time_t time1 = time(0), time2;
//-------MPI initialzation-------------
int numprocs, myid, namelen;
char processor_name[MPI_MAX_PROCESSOR_NAME];
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &numprocs);
MPI_Comm_rank(MPI_COMM_WORLD, &myid);
MPI_Get_processor_name(processor_name, &namelen);
fprintf(stderr, "Process %d running on %s\n", myid, processor_name);
string numbers = "0123456789"; // !!!!! np <= 10
string myid_str(numbers, myid, 1);
MPI_Status status;
// define a new MPI data type for particles
MPI_Datatype particletype;
MPI_Type_contiguous(18, MPI_DOUBLE, &particletype); // !!! 14->18 changed
MPI_Type_commit(&particletype);
//-------- end MPI init----------------
// wait for gdb
waitforgdb(myid);
// read input file (e.g. patric.cfg):
if(argv[1] == 0){
printf("No input file name !\n");
MPI_Abort(MPI_COMM_WORLD, 0);
}
input_from_file(argv[1], myid);
double eps_x = rms_emittance_x0; // handy abbreviation
double eps_y = rms_emittance_y0; // same
// Synchronous particle:
SynParticle SP;
SP.Z = Z;
SP.A = A;
SP.gamma0 = 1.0 + (e_kin*1e6*qe)/(mp*clight*clight) ;
SP.beta0 = sqrt((SP.gamma0*SP.gamma0-1.0)/(SP.gamma0*SP.gamma0)) ;
SP.eta0 = 1.0/pow(gamma_t, 2)-1.0/pow(SP.gamma0, 2);
//-------Init Lattice-------
BeamLine lattice;
double tunex, tuney;
SectorMap CF(CF_advance_h/NCF, CF_advance_v/NCF, CF_R, CF_length/NCF, SP.gamma0);
BeamLine CF_cell;
if(madx_input_file == 1){
// read madx sectormap and twiss files
cout << "madx sectormap" << endl;
string data_dir_in = input;
lattice.init(data_dir_in+"/mad/", circum, tunex, tuney);
}
else{
// init constant focusing (CF) sectormap and cell:
cout << "constsnt focusing" << endl;
for(int j=0; j<NCF; j++)
CF_cell.add_map(CF);
lattice.init(CF_cell);
}
// Other variables:
double dx = 2.0*piperadius/(NX-1.0); // needed for Poisson solver and grids
double dy = 2.0*piperadius/(NY-1.0); // needed for Poisson solver and grids
double dz = circum/NZ;
double ds = 0.4; // value needed here only for setting dxs, dys.
double dxs = 4.0*(dx/ds)/(NX-1.0); // only for plotting xs, not for tracking
double dys = 4.0*(dx/ds)/(NX-1.0); // only for plotting ys, not for tracking
double charge = current*circum/(NPIC*SP.beta0*clight*qe); // macro-particle charge Q/e
double zm = 0.5*circum*bunchfactor; // (initial) bunch length
if(init_pic_z == 1 || init_pic_z == 3 || init_pic_z == 4 || init_pic_z == 6)
zm = 1.5*0.5*circum*bunchfactor; // for parabolic bunch
double zm1 = -zm*1.0; // left bunch boundary
double zm2 = zm*1.0; // right bunch boundary
if(init_pic_z==7)
zm=0.25;
double rmsToFull; // ratio of rms to full emittance for Bump; SP
// open output file patric.dat:
string data_dir = ausgabe;
data_dir = data_dir + "/";
string outfile = data_dir + "patric.dat";
FILE *out = fopen(outfile.c_str(), "w");
// init random number generator:
long d = -11*(myid+1); // was -1021 transverse distribution: each slice needs a different initialization !
long dl = -103; // was -103 longitudinal plane: same random set needed
long dran = -101; // for BTF noise excitation: same random sets needed
// set some global lattice parameters
double cell_length = lattice.get_L();
int Nelements = lattice.get_size();
if(myid == 0){
cout << "Nelements:" << Nelements << endl;
cout << "Cell length:" << cell_length << endl;
}
// define pointers to first/last element in beam line:
const list<SectorMap>::iterator first_elem = lattice.get_first_element();
const list<SectorMap>::iterator last_elem = --lattice.get_end_element();
TwissP twiss0, twiss_TK;
lattice.first_element();
twiss0 = last_elem->get_twiss();
twiss_TK = first_elem->get_twiss();
double Ds0 = 0.0; // Dispersion derivative
if(madx_input_file == 0){
// machine tunes from lattice
lattice.phase_advance(tunex, tuney);
tunex = circum/cell_length*tunex/(2.0*PI);
tuney = circum/cell_length*tuney/(2.0*PI);
bumpI=0;
if(myid == 0){
cout << "advancex: " << tunex*180.0/PI << endl;
cout << "tunex0: " << tunex << endl;
cout << "tuney0: " << tuney << endl;
}
}
// Chromatic correction kick:
Chrom Chrom0;
// Octupole:
Octupole Oct0(koct);
// Amplitude detuning; works only for constant focusing; SA
//if(madx_input_file == 0)
//AmplitudeDetuning Amp0(tunex, tuney, dqx_detune/(1.0e-6*eps_x), dqy_detune/(1.0e-6*eps_y), circum/(2.0*PI), CF);
//--------end lattice----------
// set matched RF voltage:
int linrf = 0;
if (cavity == 3) linrf = 1;
double Ym = circum/(2.0*PI)*(1.0-cos(2.0*PI*zm/circum));
if (linrf == 1) Ym = circum/(2.0*PI)*0.5*pow(2.0*PI*zm/circum, 2);
double velm = abs(SP.eta0)*SP.beta0*clight*sqrt(5.0)*momentum_spread*2.0*PI/(circum);
double fsyn = 1.0/(2.0*PI)*velm*sqrt(circum/(2.0*PI))/sqrt(2.0*Ym);
double V0rf = pow(2.0*PI*fsyn, 2)*pow(circum, 2)/(2.0*PI)*mp*SP.A*SP.gamma0/(qe*SP.Z*abs(SP.eta0));
// Init particle distribution:
Pic Pics(&SP, charge, NPIC/numprocs, data_dir + "pics_" + myid_str + ".dat");
Pics.z1 = zm1+myid*(zm2-zm1)/numprocs; // left boundary in z for this slice
Pics.z2 = Pics.z1+(zm2-zm1)/numprocs; // right boundary
double slice_length = Pics.z2-Pics.z1; // slice length
Pic NewPics(&SP, charge, NPIC/numprocs);
NewPics.z1 = Pics.z1;
NewPics.z2 = Pics.z2;
// Init 1D longitudinal grids
Grid1D rho_z_tmp(NZ, dz, -0.5*circum);
Grid1D rho_z(NZ, dz, -0.5*circum, data_dir + "rho_z.dat");
Grid1D dipole_current_x_tmp(NZ, dz, -0.5*circum);
Grid1D dipole_current_x(NZ, dz, -0.5*circum, data_dir + "dipole_x.dat");
Grid1D dipole_current_xs_tmp(NZ, dz, -0.5*circum);
Grid1D dipole_current_xs(NZ, dz, -0.5*circum);
Grid1D dipole_kick_x(NZ, dz, -0.5*circum, data_dir + "dipole_kick_x.dat");
Grid1D dipole_current_y_tmp(NZ, dz, -0.5*circum);
Grid1D dipole_current_y(NZ, dz, -0.5*circum, data_dir + "dipole_y.dat");
// Init 2D transverse grids:
Grid2D rho_xy(NX, NY, dx, dy, data_dir + "rho_xy.dat");
Grid2D rho_xy_tmp(NX, NY, dx, dy);
Grid2D xxs(NX, NX, dx, dxs, data_dir + "xxs.dat");
Grid2D xxs_tmp(NX, NX, dx, dxs);
Grid2D yys(NY, NY, dy, dys, data_dir + "yys.dat");
Grid2D yys_tmp(NY, NY, dy, dys);
Grid2D xsys(NX, NY, dxs, dys, data_dir + "xsys.dat");
Grid2D xsys_tmp(NX, NY, dxs, dys);
Grid2D zx(NZ, NX, dz, dx, data_dir + "zx.dat");
Grid2D zx_tmp(NZ, NX, dz, dx);
Grid2D Ex(NX, NY, dx, dy, data_dir + "Ex.dat");
Grid2D Ey(NX, NY, dx, dy, data_dir + "Ey.dat");
// Init 3D sliced grids (for 3D space charge calculation)
if( fmod((float)NZ_bunch, (float)numprocs) != 0.0 ){
cout << "NZ_bunch kein Vielfaches von numprocs" << endl;
MPI_Abort(MPI_COMM_WORLD, 0);
}
Grid3D rho_xyz(NZ_bunch/numprocs, Pics.z1, Pics.z2, rho_xy);
Grid3D Ey3(NZ_bunch/numprocs, Pics.z1, Pics.z2, rho_xy);
Grid3D Ex3(NZ_bunch/numprocs, Pics.z1, Pics.z2, rho_xy);
// Init 2D Greens function for poisson solver
Greenfb gf1(rho_xy, image_x, image_y); // open boundary condition
// for the beam radius cacluation; factor for rms equivalent
switch(init_pic_xy){
case 0: // Waterbag
rmsToFull = 6;
break;
case 1: // KV
rmsToFull = 4;
break;
case 2: // Semi-Gauss
rmsToFull = 4; // approximate
break;
case 3: // Gauss
rmsToFull = 4; // approximate
break;
default:
printf("Invalid option for transverse particle distribution. Aborting.\n");
MPI_Abort(MPI_COMM_WORLD, 0);
}
// injection bump initialize
Bump lob(tunex);
double a; // beam radius horizontal
switch(bumpI){
case 0:
cout << "no mti" << endl;
max_inj = 1;
amp0=0;
break;
case 1:
// The bump height is defined by user given offcenter parameter. The injection angle is equal to the septum tilt angle (as done in SIS18).
cout << "mti version SP" << endl;
a = sqrt(twiss_TK.betx*eps_x*rmsToFull)*0.001+twiss_TK.Dx*momentum_spread; // half width of injected beam [m] with WB distribution, change to Main, SA
offcenter_x=x_septum + d_septum + a;
amp0=offcenter_x;
amp=amp0;
ampp0=inj_angle;
delAmp=(amp0-2*a)/double(max_inj); //0.0041*3;//
lob.BumpSp(&lattice,max_inj, myid, amp0, ampp0, delAmp); // local orbit bump for beam injection; SP
break;
case 2:
amp=amp0;
cout << "mti flexibility version" << endl;
lob.BumpModi(&lattice,amp);
break;
case 3:
amp=amp0;
cout << "mti flexibility version exponential decrease" << "tau" << tau << endl;
lob.BumpModi(&lattice,amp);
break;
case 4:
amp=amp0;
cout << "mti flexibility version sin decrease" << "tau" << tau << endl;
lob.BumpModi(&lattice,amp);
break;
default:
printf("Invalid option for bump injection. Aborting.\n");
MPI_Abort(MPI_COMM_WORLD, 0);
}
//if(myid == 0)
//cout << "Expected single beamlett tune shifts: dQ_x="
//<< rp*SP.Z*current*circum / (rmsToFull*PI*clight*qe*SP.A*pow(SP.beta0*SP.gamma0, 3)*(eps_x+sqrt(eps_x*eps_y*tunex/tuney)))*1e6
//<< ", dQ_y="
//<< rp*SP.Z*current*circum / (rmsToFull*PI*clight*qe*SP.A*pow(SP.beta0*SP.gamma0, 3)*(eps_y+sqrt(eps_x*eps_y*tuney/tunex)))*1e6
//<< endl;
// print IDL parameter file idl.dat:
if(myid == 0){
//cout << "Vrf [kV]: " << V0rf*1.0e-3 << " fsyn [kHz]: " << fsyn*1.0e-3 << endl;
print_IDL(data_dir, numprocs, cell_length, Nelements, tunex, tuney, lattice, cells, max_inj);
}
//----------------counters and other variables--------------------------
int Nexchange = 1; // exchange of particles between slices after every sector map.
int Nprint = print_cell*Nelements; // output of particles every cell*print_cell
//int Nibs = 1; // correct for IBS every Nibs steps
double Ntot; // total number of particles: for screen output
int counter = 0; // counts sector maps
double s = 0.0; // path length
double Nslice; // total number of slices
double emitx; // emittance: for screen output
double dtheta = 0.0; // btf dipole kick
double pickup_h, pickup_v; // horizontal/vertical pickup signals
double rms_advancex = 0.0, rms_advancey = 0.0; // rms phase advance: for output
int inj_counter = 0; // number of injected beamletts; SP
long N_inj = 0; // number of injected particles
//---------parameters for exchange of particles between slices-------
int destl; //!< ID of left neighbour slice (-1: no neighbour).
int destr; //!< ID of right neighbour
//---finite bunch: no exchange between ends---
if(bc_end == 0){
if(myid == 0){
destl =-1;
destr = myid+1;
}else
if(myid == numprocs-1){
destl = myid-1;
destr =-1;
}else{
destl = myid-1;
destr = myid+1;
}
}
//---periodic (in z) boundary condition---
if(bc_end == 1){
if(myid == 0){
destl = numprocs-1;
destr = myid+1;
}else
if(myid == numprocs-1){
destl = myid-1;
destr = 0;
}
else{
destl = myid-1;
destr = myid+1;
}
}
//--------------------- end-parameters for particle exchange ---------------
long *septLoss = new long;
long *sl_slice = new long;
double *momenta = new double[19];
double *momenta_tot = new double[19];
double tmp=0;
long size_old;
offcenter_y=0.0;
inj_phase_y=0.0e-3;
//--------------------------------------------------------------------------
//----------------------- start loop (do...while) --------------------------
//--------------------------------------------------------------------------
double z0;
do{ // injection; SP
if(!(counter%Nelements))
{ // at beginning each turn...
if(inj_counter < max_inj)
{
size_old=Pics.get_size();
// set longitudinal distribution:
switch(init_pic_z){
case 0: // coasting + Elliptic
Pics.parabolic_dc(bunchfactor, circum, momentum_spread, NPIC, &dl);
break;
case 1: // bunch + Elliptic (1.5 correction factor for bunching)
Pics.parabolic(zm, 0, momentum_spread, NPIC, &dl);
break;
case 2: // coasting + Gauss
Pics.coast_gauss(bunchfactor, circum, momentum_spread, NPIC, &dl);
break;
case 3: // bunch + Gauss
Pics.bunch_gauss(zm, circum, momentum_spread, NPIC, &dl);
break;
case 4: // const. bunch dist.
Pics.bunch_const(zm, circum, momentum_spread, NPIC, &dl,linrf);
break;
case 5: // air bag dist.
Pics.barrier_air_bag(zm, momentum_spread, NPIC, &dl);
break;
case 6: // bunch air bag dist.
Pics.bunch_air_bag(zm, circum, momentum_spread, NPIC, &dl);
break;
case 7: // 168 mirco bunches, injection
z0=-circum/2.;
int l;
for (l=0; l<168; l++){
Pics.parabolic(zm, z0, momentum_spread, NPIC/168, &dl);
z0+=1.286;
}
break;
default:
printf("Invalid option for longitudinal particle distribution. Aborting.\n");
MPI_Abort(MPI_COMM_WORLD, 0);
}
// set transverse distribution:
switch(init_pic_xy){
case 0: // Waterbag
rmsToFull = 6;
Pics.waterbag_xy(1.e-6*eps_x, 1.0e-6*eps_y, twiss_TK.alpx, twiss_TK.alpy, pow(mismatch_x, 2)*twiss_TK.betx, pow(mismatch_y, 2)*twiss_TK.bety,
twiss_TK.Dx, Ds0, offcenter_x, inj_angle, offcenter_y, inj_phase_y, size_old, &d);
break;
case 1: // KV
rmsToFull = 4;
Pics.KV_xy(1.e-6*eps_x, 1.0e-6*eps_y, twiss_TK.alpx, twiss_TK.alpy, pow(mismatch_x, 2)*twiss_TK.betx, pow(mismatch_y, 2)*twiss_TK.bety,
twiss_TK.Dx, Ds0, offcenter_x, inj_angle, offcenter_y, inj_phase_y, size_old, &d);
break;
case 2: // Semi-Gauss
rmsToFull = 4; // approximate
Pics.SG(1.e-6*eps_x, 1.0e-6*eps_y, twiss_TK.alpx, twiss_TK.alpy, pow(mismatch_x, 2)*twiss_TK.betx, pow(mismatch_y, 2)*twiss_TK.bety,
twiss_TK.Dx, Ds0, offcenter_x, inj_angle, offcenter_y, inj_phase_y, size_old, &d);
break;
case 3: // Gauss
rmsToFull = 4; // approximate
Pics.Gauss_xy(1.e-6*eps_x, 1.0e-6*eps_y, twiss_TK.alpx, twiss_TK.alpy, pow(mismatch_x, 2)*twiss_TK.betx, pow(mismatch_y, 2)*twiss_TK.bety,
twiss_TK.Dx, Ds0, offcenter_x, inj_angle, offcenter_y, inj_phase_y, size_old, &d);
break;
default:
printf("Invalid option for transverse particle distribution. Aborting.\n");
MPI_Abort(MPI_COMM_WORLD, 0);
}
if (bumpI!=0)
{
*sl_slice = NewPics.localLoss_x(x_septum, 100.); // loss on septum
loss+=*sl_slice;
MPI_Reduce(sl_slice, septLoss, 1, MPI_LONG, MPI_SUM, 0, MPI_COMM_WORLD);
if(myid == 0)
cout<<"The incoming beamlett number "<<inj_counter+1<< " lost "<<loss<< " macro particles on the septum.\n";
}
N_inj += NPIC;
inj_counter +=1;
}
// bump reduction
if (amp > 0.001 )
{
if(bumpI==1)
{
amp-=delAmp;
ampp0-=delAmp*ampp0/amp0;
lob.decrement();
}
if (bumpI==2)
{
amp-=delAmp;
lob.decrementModi(amp);
}
if (bumpI==3)
{
amp=amp0*exp(-tau*counter/Nelements);
lob.decrementModi(amp);
}
if (bumpI==4)
{
amp=amp0*(1+sin(-tau*counter/Nelements));
lob.decrementModi(amp);
}
}
}
//------------ Start Output----------------------------------------
// store rms momenta every time step in patric.dat:
if(counter%1 == 0){
Nslice = Pics.get_size(); // number of particles in this slice
momenta[0] = Nslice*Pics.rms_emittance_x();
momenta[1] = Nslice*Pics.rms_emittance_y();
momenta[2] = Nslice*Pics.x_max();
momenta[3] = Nslice*Pics.y_max();
momenta[4] = Nslice*Pics.x_rms();
momenta[5] = Nslice*Pics.y_rms();
momenta[6] = Nslice*Pics.rms_momentum_spread();
momenta[7] = Nslice*Pics.xzn(2.0, zm);
momenta[8] = Nslice*Pics.xzn(1.0, zm);
momenta[9] = Nslice;
momenta[10] = Nslice*rms_advancex; // rms phase advance in x
momenta[11] = Nslice*rms_advancey;
momenta[12] = Nslice*Pics.offset_x();
momenta[13] = Nslice*Pics.offset_y();
momenta[14] = Nslice*dtheta; // btf noise signal
momenta[15] = Nslice*pickup_h;
momenta[16] = Nslice*pickup_v;
momenta[17] = Nslice*loss;
momenta[18] = Nslice*N_inj;
// mpi_reduce for summation of all 17 moments over all slices
MPI_Reduce(momenta, momenta_tot, 19, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
Ntot = momenta_tot[9]; // total number of particles over all slices
emitx = momenta_tot[0]/Ntot; // total rms emittance
// stop when loss tolerance level is exceeded (1-Ntot/(max_inj*NPIC))*100.
if(myid == 0 && Ntot/N_inj <= lossTol){ // test on numer of injected particles; SP
cout<<"Loss tolerance exceeded within "<<counter/Nelements+1<<" turns ("<<
Ntot<<" of "<<N_inj<<" macro particles left). Exiting.\n";
cout.flush();
MPI_Abort(MPI_COMM_WORLD, 0);
}
// cout<<counter<<' '<<lattice.get_element()->get_name()<<' '<<lattice.get_element()->get_K(1)<<endl; //tmp
// write momenta
if(myid == 0){
fprintf(out, "%g", s);
for(int i=0; i<19; i++)
if(i != 9){
fprintf(out, "%15g", momenta_tot[i]/Ntot);}
else{
fprintf(out, "%15g", momenta_tot[i]);}
fprintf(out, "\n");
fflush(out);
}
}
//------output every Nprint*sectormap---------
if(counter%Nprint == 0){
if(myid == 0){
// to screen
//printf("saving at s=%g (m) eps_t=%g dp/p=%g zm2=%g Ntotal=%g\n", s, 1.0e6*emitx, Pics.rms_momentum_spread(), zm2, Ntot);
cout.flush();
// electric fields
Ex.print();
Ey.print();
}
// paricle coordinates to pic.dat:
Pics.print(pic_subset);
// collect densities for output only:
Pics.gatherZ(charge*qe/dz, rho_z_tmp);
Pics.gatherX(SP.beta0*clight*charge*qe/dz, dipole_current_x_tmp);
Pics.gatherY(SP.beta0*clight*charge*qe/dz, dipole_current_y_tmp);
Pics.gatherXY(charge*qe/circum, rho_xy_tmp);
Pics.gatherXXs(charge*qe/circum, xxs_tmp);
Pics.gatherYYs(charge*qe/circum, yys_tmp);
Pics.gatherXsYs(charge*qe/circum, xsys_tmp);
Pics.gatherZX(charge*qe/circum, zx_tmp);
// summation over all slices:
MPI_Allreduce(rho_z_tmp.get_grid(), rho_z.get_grid(),
NZ, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
MPI_Allreduce(dipole_current_x_tmp.get_grid(), dipole_current_x.get_grid(),
NZ, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
MPI_Allreduce(dipole_current_y_tmp.get_grid(), dipole_current_y.get_grid(),
NZ, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
MPI_Allreduce(rho_xy_tmp.get_grid(), rho_xy.get_grid(),
NX*NY, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
MPI_Allreduce(xxs_tmp.get_grid(), xxs.get_grid(),
NX*NX, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
MPI_Allreduce(yys_tmp.get_grid(), yys.get_grid(),
NY*NY, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
MPI_Allreduce(xsys_tmp.get_grid(), xsys.get_grid(),
NX*NY, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
MPI_Allreduce(zx_tmp.get_grid(), zx.get_grid(),
NZ*NX, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
// output to density files:
if(myid == 0){
dipole_current_x.print();
dipole_kick_x.print();
dipole_current_y.print();
rho_z.print();
rho_xy.print();
xxs.print();
yys.print();
xsys.print();
zx.print();
}
}
//-----------------end output--------------------------------------------
// at beginning of a cell: calculate advance per (last) cell,
// store old coordinates
if(lattice.get_element() == first_elem){
rms_advancex = Pics.rms_phaseadvance_h(); // Pics.rms_wavelength_h();
rms_advancey = Pics.rms_phaseadvance_v(); // Pics.rms_wavelength_v();
if(footprint == 0)
Pics.store_old_coordinates();
}
if(lattice.get_element()->get_name() == "\"SEPTUM\""){ // losses at septum; SP
loss += Pics.localLoss_x(-piperadius, coll_halfgap);
}
if(lattice.get_element()->get_name() == "\"ACCEPTANCE\""){ // losses at limiting acceptance; SA
double tmp = lattice.get_element()->get_betx();
Pics.localLoss_x(-sqrt(180e-6*tmp), sqrt(180e-6*tmp));
}
// Transport particles through sectormap, update slice position s:
ds = lattice.get_element()->get_L();
s += ds;
Pics.transport(lattice.get_element()->get_map(), piperadius);
//-----exchange particles between slices------------------------
if(counter != 0 && counter%Nexchange == 0 && numprocs > 1){
int Npl; //!< Number of particles to be exchanged with left neighbour
int Npr; //!< particles exchanged with right neighbour
//! vector of particles to be exchanged
vector<Particle> pl, pr;
// send particle to neighbor slices:
if(destl >= 0){
pl = Pics.get_particles_left(circum);
Npl = pl.size();
MPI_Send(&Npl, 1, MPI_INT, destl, 1, MPI_COMM_WORLD);
MPI_Send(&pl[0], Npl, particletype, destl, 1, MPI_COMM_WORLD);
}
if(destr >= 0){
pr = Pics.get_particles_right(circum);
Npr = pr.size();
MPI_Send(&Npr, 1, MPI_INT, destr, 0, MPI_COMM_WORLD);
MPI_Send(&pr[0], Npr, particletype, destr, 0, MPI_COMM_WORLD);
}
// receive from neighbour slices:
Npl = 0; Npr = 0;
vector<Particle> pl_in, pr_in;
if( destl >= 0 ){
MPI_Recv(&Npl, 1, MPI_INT, destl, 0, MPI_COMM_WORLD, &status);
pl_in = vector<Particle>(Npl);
MPI_Recv(&pl_in[0], Npl, particletype, destl, 0, MPI_COMM_WORLD, &status);
}
if(destr >= 0){
MPI_Recv(&Npr, 1, MPI_INT, destr, 1, MPI_COMM_WORLD, &status);
pr_in = vector<Particle>(Npr);
MPI_Recv(&pr_in[0], Npr, particletype, destr, 1, MPI_COMM_WORLD, &status);
}
Pics.add_particles(pl_in);
Pics.add_particles(pr_in);
}
//-----end exchange of particles-------------
// periodic bc without exchange
if(numprocs == 1)
Pics.periodic_bc(circum);
// update wave lengths
//if( footprint == 1){
//Pics.update_wavelength_h(ds, 0.0);
//Pics.update_wavelength_v(ds);}
// nonlinear thin lens kick:
if(octupole_kick == 1)
Pics.kick(Oct0, lattice.get_element()->get_twiss(), ds);
//if(ampdetun_kick == 1) // works only for constant focusing
//Pics.kick(Amp0, lattice.get_element()->get_twiss()ds);
// correct for chromaticity
if(chroma == 1)
Pics.kick(Chrom0,lattice.get_element()->get_twiss(), ds);
// cavity kick every cell:
if(cavity == 1 && counter%Nelements == 0.0)
Pics.cavity_kick(V0rf*cell_length/circum, 1, circum/(2.0*PI));
if(cavity == 2 && counter%Nelements == 0.0)
Pics.barrier_kick(zm1, zm2);
if(cavity == 3 && counter%Nelements == 0.0)
Pics.cavity_kick_linear(V0rf*cell_length/circum, 1, circum/(2.0*PI));
// Pickup signals
Pics.gatherX(SP.beta0*clight*charge*qe/dz, dipole_current_x_tmp);
Pics.gatherY(SP.beta0*clight*charge*qe/dz, dipole_current_y_tmp);
MPI_Allreduce(dipole_current_x_tmp.get_grid(), dipole_current_x.get_grid(), NZ,
MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
MPI_Allreduce(dipole_current_y_tmp.get_grid(), dipole_current_y.get_grid(), NZ,
MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
pickup_h = Pics.pickup_signal(dipole_current_x, circum,
s/(SP.beta0*clight))/current;
pickup_v = Pics.pickup_signal(dipole_current_y, circum,
s/(SP.beta0*clight))/current;
//---------------impedance kicks-----------------------
komplex dqc_t(dqcr, dqci); // for sliced == 0
if(imp_kick == 1){
if(sliced == 0)
Pics.kick(ds/circum*InducedKick(Pics.offset_x(), ds, dqc_t, SP.beta0,
tunex, circum), 0.0);
else{
dipole_kick_x.reset();
if(Rs > 0.0 || leit > 0.0){
Pics.gatherXs(SP.beta0*clight*charge*qe/dz, dipole_current_xs_tmp);
MPI_Allreduce(dipole_current_xs_tmp.get_grid(), dipole_current_xs.get_grid(),
NZ, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD);
InducedWakeKick(dipole_kick_x, dipole_current_x, dipole_current_xs, tunex,
2.0*PI*SP.beta0*clight/circum, nres, Rs, Qs, piperadius,
leit, SP.beta0, SP.gamma0*mp*SP.A*pow(clight, 2), SP.Z*qe);
}
if(Zimage != 0.0)
InducedKick(dipole_kick_x, dipole_current_x, Zimage, SP.beta0,
SP.gamma0*mp*SP.A*pow(clight, 2), SP.Z*qe);
Pics.impedance_kick(dipole_kick_x, circum, ds);
}
}
//---------------end impedance kicks-----------------------
//------------self-consistent space charge kicks after every sectormap----
if(space_charge == 1){
// PIC -> charge density for Poisson solver:
if (sliced == 0){
Pics.gatherXY(charge*qe/circum, rho_xy_tmp);
MPI_Allreduce(rho_xy_tmp.get_grid(), rho_xy.get_grid(), NX*NY, MPI_DOUBLE,
MPI_SUM, MPI_COMM_WORLD);
}else{
Pics.gatherXYZ(charge*qe/rho_xyz.get_dz(), rho_xyz);
// send and receive density ghost grids to neighbor slices:
// what is exchanged here ???
if(destl >= 0)
MPI_Send(rho_xyz.get_ghostl(), NX*NY, MPI_DOUBLE, destl, 2, MPI_COMM_WORLD);
if(destr >= 0){
MPI_Recv(rho_xy_tmp.get_grid(), NX*NY, MPI_DOUBLE, destr, 2, MPI_COMM_WORLD,
&status);
rho_xyz[NZ_bunch/numprocs-1] += rho_xy_tmp;
}
if(destr >= 0)
MPI_Send(rho_xyz.get_ghostr(), NX*NY, MPI_DOUBLE, destr, 3, MPI_COMM_WORLD);
if(destl >= 0){
MPI_Recv(rho_xy_tmp.get_grid(), NX*NY, MPI_DOUBLE, destl, 3, MPI_COMM_WORLD,
&status);
rho_xyz[0]+= rho_xy_tmp;
}
}
// Poisson solver
if(sliced == 0)
poisson_xy(Ex, Ey, rho_xy, gf1);
else{
poisson_xyz(Ex3, Ey3, rho_xyz, gf1);
// send and receive efield ghost grids to neighbor slices:
if(destl >= 0){
MPI_Send(Ex3.get_ghostl(), NX*NY, MPI_DOUBLE, destl, 2,
MPI_COMM_WORLD);
MPI_Send(Ey3.get_ghostl(), NX*NY, MPI_DOUBLE, destl, 4,
MPI_COMM_WORLD);
}
if(destr >= 0){
MPI_Recv(Ex3[NZ_bunch/numprocs-1].get_grid(), NX*NY, MPI_DOUBLE,
destr, 2, MPI_COMM_WORLD, &status);
MPI_Recv(Ey3[NZ_bunch/numprocs-1].get_grid(), NX*NY, MPI_DOUBLE,
destr, 4, MPI_COMM_WORLD, &status);
}
if(destr >= 0){
MPI_Send(Ex3.get_ghostr(), NX*NY, MPI_DOUBLE, destr, 3, MPI_COMM_WORLD);
MPI_Send(Ey3.get_ghostr(), NX*NY, MPI_DOUBLE, destr, 5, MPI_COMM_WORLD);
}
if(destl >= 0){
MPI_Recv(Ex3[0].get_grid(), NX*NY, MPI_DOUBLE, destl, 3, MPI_COMM_WORLD, &status);
MPI_Recv(Ey3[0].get_grid(), NX*NY, MPI_DOUBLE, destl, 5, MPI_COMM_WORLD, &status);
}
}
}
// Shift xs and ys:
if(space_charge == 1 && ds > 0.0){
if(sliced == 0)
Pics.kick(Ex, Ey, ds);
else
Pics.kick(Ex3, Ey3, ds);
}
//---------------end self-consistent space charge kicks---------------
// linear sc kicks:
if(space_charge == 2 && ds > 0.0)
Pics.linear_SC_kick(dQxm, dQym, tunex, tuney, rho_z, current/(SP.beta0*clight),
dipole_current_x, dipole_current_y, circum, ds);
// nonlinear sc kicks:
if(space_charge == 3 && ds > 0.0)
Pics.nonlinear_SC_kick(sqrt(1.0e-6*twiss0.betx*eps_x), sqrt(1.0e-6*twiss0.bety*eps_y),
dQxm, dQym, tunex, tuney, rho_z, current/(SP.beta0*clight),
circum, ds);
// dipole noise modulation kick:
double dnoiseamp = 1.0e-6;
double nus = fsyn/(SP.beta0*clight/circum);
if(btf == 1)
dtheta = Pics.dipole_mod_kick(s/(SP.beta0*clight), ds, circum, dnoiseamp,
(tunex+nus)*SP.beta0*clight/circum, btf_harmonic);
// correct for ibs:
/*if(counter != 0 && counter%Nibs == 0){
double rate_ibs = 1.0e4;
double Dz = rate_ibs*pow(Pics.rms_momentum_spread(), 2);
double Dxy = rate_ibs*0.5*(Pics.rms_emittance_x()+Pics.rms_emittance_y());
double betx = lattice.get_element()->get_betx();
double bety = lattice.get_element()->get_bety();
Pics.langevin(rate_ibs, rate_ibs*0.0, Dxy, Dz*0.0, Nibs*ds, betx, bety,
&d);
}*/
// For bunch compression: Update slice boundaries z1 and z2 from
// new bunch boundaries zm1, zm2:
/*if(counter != 0 && counter%Nexchange == 0){
if(myid == 0)
zm1 = Pics.z_min();
MPI_Bcast(&zm1, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
if(myid == numprocs-1)
zm2 = Pics.z_max();
MPI_Bcast(&zm2, 1, MPI_DOUBLE, numprocs-1, MPI_COMM_WORLD);
Pics.z1 = zm1+myid*(zm2-zm1)/numprocs;
Pics.z2 = Pics.z1+(zm2-zm1)/numprocs;
slice_length = Pics.z2-Pics.z1;
rho_xyz.get_zleft() = zm1;
rho_xyz.get_zright() = zm2;
Ex3.get_zleft() = zm1;
Ex3.get_zright() = zm2;
Ey3.get_zleft() = zm1;
Ey3.get_zright() = zm2;
}*/
// advance in beam line, go to next element:
lattice.next_element();
++counter;
}while(counter != cells*Nelements); //loop check, cells (turns) given by user SA
//------------------end of loop-------------------------------
// close files, free heap:
delete septLoss, sl_slice;
delete[] momenta, momenta_tot; // [] needed here!; SP
fclose(out);
// MPI end:
MPI_Finalize();
time2 = time(0);
double sec = difftime(time2, time1);
double h = floor(sec/3600);
double min = floor(sec/60-60.*h);
sec -= 3600.*h+60.*min;
if(myid == 0)
{cout << "Total losses: " << (1-Ntot/(max_inj*NPIC))*100. << " \%\n" <<
"Stored particles: " << current*circum*Ntot/(qe*Z*SP.beta0*clight*NPIC) << endl <<
"Computation time: " << h << ":" << min << ":" << sec << endl;
}
}
TESTLAYER_CREATE_FUNC(LayerTestCascadingOpacityB);
TESTLAYER_CREATE_FUNC(LayerTestCascadingOpacityC);
TESTLAYER_CREATE_FUNC(LayerTestCascadingColorA);
TESTLAYER_CREATE_FUNC(LayerTestCascadingColorB);
TESTLAYER_CREATE_FUNC(LayerTestCascadingColorC);
TESTLAYER_CREATE_FUNC(LayerTest1);
TESTLAYER_CREATE_FUNC(LayerTest2);
TESTLAYER_CREATE_FUNC(LayerTestBlend);
TESTLAYER_CREATE_FUNC(LayerGradient);
TESTLAYER_CREATE_FUNC(LayerIgnoreAnchorPointPos);
TESTLAYER_CREATE_FUNC(LayerIgnoreAnchorPointRot);
TESTLAYER_CREATE_FUNC(LayerIgnoreAnchorPointScale);
TESTLAYER_CREATE_FUNC(LayerExtendedBlendOpacityTest);
static NEWTESTFUNC createFunctions[] = {
CF(LayerTestCascadingOpacityA),
CF(LayerTestCascadingOpacityB),
CF(LayerTestCascadingOpacityC),
CF(LayerTestCascadingColorA),
CF(LayerTestCascadingColorB),
CF(LayerTestCascadingColorC),
CF(LayerTest1),
CF(LayerTest2),
CF(LayerTestBlend),
CF(LayerGradient),
CF(LayerIgnoreAnchorPointPos),
CF(LayerIgnoreAnchorPointRot),
CF(LayerIgnoreAnchorPointScale),
CF(LayerExtendedBlendOpacityTest)
};
#include "AnimTest.h"
#include "../testResource.h"
#include "cocos2d.h"
#include "cocos2d-better.h"
TESTLAYER_CREATE_FUNC(AnimMotionWelder);
TESTLAYER_CREATE_FUNC(AnimArctic);
TESTLAYER_CREATE_FUNC(AnimAuroraGT);
TESTLAYER_CREATE_FUNC(AnimSpriteX);
TESTLAYER_CREATE_FUNC(AnimSpriteX2011);
TESTLAYER_CREATE_FUNC(AnimClipMappingAuroraGT);
static NEWTESTFUNC createFunctions[] = {
CF(AnimMotionWelder),
CF(AnimArctic),
CF(AnimAuroraGT),
CF(AnimSpriteX),
CF(AnimSpriteX2011),
CF(AnimClipMappingAuroraGT)
};
static int sceneIdx=-1;
#define MAX_LAYER (sizeof(createFunctions) / sizeof(createFunctions[0]))
static CCLayer* nextAction()
{
sceneIdx++;
sceneIdx = sceneIdx % MAX_LAYER;
CCLayer* pLayer = (createFunctions[sceneIdx])();
pLayer->init();
void MODEL::DoDryRewet( PROJECT* project, int* dried, int* wetted )
{
DRYREW *dryRew = ®ion->dryRew;
region->Connection( 0L );
int del = 0;
int wel = 0;
if( dryRew->method == 1 )
{
// mark nodes and elements to be rewetted ------------------------------------------------------
wel = region->Rewet( dryRew->rewetLimit, dryRew->rewetPasses, project );
// mark dry nodes and elements -----------------------------------------------------------------
del = region->Dry( dryRew->dryLimit, dryRew->countDown );
}
else if( dryRew->method == 2 )
{
region->DryRewet( dryRew->dryLimit, dryRew->rewetLimit, dryRew->countDown, &del, &wel );
}
else if( dryRew->method == 3 )
{
region->RewetDry( dryRew->dryLimit, dryRew->rewetLimit, dryRew->countDown, &del, &wel );
}
/*
// future work ...
else if( dryRew->method == 4 )
{
// determine dynamic boundary ------------------------------------------------------------------
region.DynamicBound( np, node, *elem, dryRew->dryLimit, project );
}
*/
//////////////////////////////////////////////////////////////////////////////////////////////////
# ifdef _MPI_
del = project->subdom.Mpi_sum( del );
wel = project->subdom.Mpi_sum( wel );
# endif
char text [200];
sprintf( text, "\n (MODEL::DoDryRewet) %d elements have got dry\n", del );
REPORT::rpt.Output( text, 3 );
sprintf( text, "\n (MODEL::DoDryRewet) %d elements have got wet\n", wel );
REPORT::rpt.Output( text, 3 );
int dryRewFlag = del + wel;
if( dryRewFlag )
{
////////////////////////////////////////////////////////////////////////////////////////////////
// exchange information on dry nodes on interfaces
# ifdef _MPI_
if( project->subdom.npr > 1 )
{
MPI_Comm_Dry( project, true );
//////////////////////////////////////////////////////////////////////////////////////////////
// reset wetted area, in case of dry nodes that are not dry in adjacent subdomains
// added on 20.04.2006, sc
if( dryRew->method == 2 || dryRew->method == 3 )
{
int wetted = 0;
for( int n=0; n<region->Getnp(); n++ )
{
NODE* nd = region->Getnode(n);
nd->mark = false;
double H = nd->v.S - nd->zor;
if( H < dryRew->dryLimit )
{
SF( nd->flag, NODE::kDry );
}
else if( isFS(nd->flag, NODE::kDry) )
{
nd->mark = true;
CF( nd->flag, NODE::kDry );
wetted++;
}
CF( nd->flag, NODE::kMarsh );
nd->z = nd->zor;
}
if( dryRew->method == 2 )
{
region->DryRewet( dryRew->dryLimit, dryRew->rewetLimit, dryRew->countDown, &del, &wel );
}
else if( dryRew->method == 3 )
{
region->RewetDry( dryRew->dryLimit, dryRew->rewetLimit, dryRew->countDown, &del, &wel );
}
////////////////////////////////////////////////////////////////////////////////////////////
MPI_Comm_Dry( project, false );
wetted = project->subdom.Mpi_sum( wetted );
sprintf( text, "\n (MODEL::DoDryRewet) %d interface nodes have got wet\n", wetted );
REPORT::rpt.Output( text, 3 );
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
// reset interface flags: kInface, kInface_DN and kInface_UP; this is
// necessary for the correct ordering of equations in EQS::ResetEqOrder()
project->subdom.SetInface( region );
# endif // #ifdef _MPI_
////////////////////////////////////////////////////////////////////////////////////////////////
// determine 1D boundary elements and ----------------------------------------------------------
// set up slip velocity boundary conditions
Initialize();
SetNormal();
SetRotation();
region->SetSlipFlow();
REPORT::rpt.PrintTime( 3 );
// ================================================================================================
# ifdef kDebug_1
for( int n=0; n<region->Getnp(); n++ )
{
NODE* ndbg = region->Getnode(n);
switch( ndbg->Getname() )
{
case 3654:
REPORT::rpt.Message( "\n" );
REPORT::rpt.Message( "### NODE %6d: inface = %d\n", ndbg->Getname(), ndbg->flag&NODE::kInface );
REPORT::rpt.Message( "### : inface_dn = %d\n", ndbg->flag&NODE::kInface_DN );
REPORT::rpt.Message( "### : inface_up = %d\n", ndbg->flag&NODE::kInface_UP );
REPORT::rpt.Message( "\n" );
REPORT::rpt.Message( "### : dry = %d\n", ndbg->flag&NODE::kDry );
REPORT::rpt.Message( "### : marsh = %d\n", ndbg->flag&NODE::kMarsh );
REPORT::rpt.Message( "### : H = %f\n", ndbg->v.S - ndbg->zor );
REPORT::rpt.Message( "\n" );
REPORT::rpt.Message( "### : bound = %d\n", ndbg->flag&NODE::kBound );
REPORT::rpt.Message( "### : inflow = %d\n", ndbg->flag&NODE::kInlet );
REPORT::rpt.Message( "### : outflow = %d\n", ndbg->flag&NODE::kOutlet );
REPORT::rpt.Message( "### : rotat = %d\n", ndbg->flag&NODE::kRotat );
REPORT::rpt.Message( "### : noMoment = %d\n", ndbg->flag&NODE::kNoMoment );
REPORT::rpt.Message( "\n" );
REPORT::rpt.Message( "### : countDown = %d\n", ndbg->countDown );
{
SUB* sub = ndbg->sub;
while( sub )
{
REPORT::rpt.Message( "### SUBDOM %4d: dry = %d\n", sub->no+1, sub->dry );
sub = sub->next;
}
}
break;
}
}
# endif
// ================================================================================================
}
else
{
// set up structure for connection of nodes to elements ----------------------------------------
// dry elements are not taken into consideration
region->Connection( ELEM::kDry );
}
if( dried ) *dried = del;
if( wetted ) *wetted = wel;
region->firstDryRew = false;
}
void GRID::ReportDry( PROJECT* project,
double dryLimit,
int countDown )
{
int dryNodes = false;
// check for dry nodes -------------------------------------------------------------------
for( int n=0; n<Getnp(); n++ )
{
NODE* nd = Getnode(n);
nd->countDown = 0;
CF( nd->flag, NODE::kDry );
if( (nd->v.S - nd->z) < dryLimit )
{
SF( nd->flag, NODE::kDry );
dryNodes = true;
}
}
// report all dry nodes ------------------------------------------------------------------
if( dryNodes )
{
REPORT::rpt.Output( "\n\n----------------------------------------", 5 );
REPORT::rpt.Output( "------------------------------\n", 5 );
REPORT::rpt.Output( "\n ... the following nodes are dry\n", 5 );
int jdry = 0;
for( int n=0; n<Getnp(); n++ )
{
NODE* nd = Getnode(n);
if( isFS(nd->flag, NODE::kDry) )
{
char text[20];
sprintf( text, " %5d", nd->Getname() );
REPORT::rpt.Output( text, 5 );
jdry++;
if( !( jdry % 10) ) REPORT::rpt.Output( "\n", 5 );
}
}
if( jdry % 10 ) REPORT::rpt.Output( "\n", 5 );
// loop on all elements ----------------------------------------------------------------
for( int e=0; e<Getne(); e++ )
{
ELEM* el = Getelem(e);
CF( el->flag, ELEM::kDry );
int nnd = el->Getnnd();
for( int i=0; i<nnd; i++ )
{
if( isFS(el->nd[i]->flag, NODE::kDry) )
{
SF( el->flag, ELEM::kDry );
break;
}
}
}
for( int n=0; n<Getnp(); n++ )
{
NODE* nd = Getnode(n);
SF( nd->flag, NODE::kDry );
}
// loop on all elements: all nodes at wet elements are wet -----------------------------
for( int e=0; e<Getne(); e++ )
{
ELEM* el = Getelem(e);
if( !isFS(el->flag, ELEM::kDry) )
{
int nnd = el->Getnnd();
for( int i=0; i<nnd; i++ ) CF( el->nd[i]->flag, NODE::kDry );
}
}
int idry = 0;
REPORT::rpt.Output( "\n ... the following elements are dry\n", 5 );
for( int e=0; e<Getne(); e++ )
{
ELEM* el = Getelem(e);
if( isFS(el->flag, ELEM::kDry) )
{
char text[20];
sprintf( text, " %5d", el->Getname() );
REPORT::rpt.Output( text, 5 );
idry++;
if( !( idry % 10) ) REPORT::rpt.Output( "\n", 5 );
}
}
if( idry % 10 ) REPORT::rpt.Output( "\n", 5 );
REPORT::rpt.Output( "\n", 5 );
for( int n=0; n<Getnp(); n++ )
{
NODE* nd = Getnode(n);
if( isFS(nd->flag, NODE::kDry) )
{
nd->v.U = 0.0;
nd->v.V = 0.0;
nd->v.S = nd->z;
nd->v.K = 0.0;
nd->v.D = 0.0;
nd->v.dUdt = 0.0;
nd->v.dVdt = 0.0;
nd->v.dSdt = 0.0;
}
}
}
}
static void
register_curses_constants(lua_State *L)
{
/* colors */
CC(COLOR_BLACK); CC(COLOR_RED); CC(COLOR_GREEN);
CC(COLOR_YELLOW); CC(COLOR_BLUE); CC(COLOR_MAGENTA);
CC(COLOR_CYAN); CC(COLOR_WHITE);
/* alternate character set */
CC(ACS_BLOCK); CC(ACS_BOARD);
CC(ACS_BTEE); CC(ACS_TTEE);
CC(ACS_LTEE); CC(ACS_RTEE);
CC(ACS_LLCORNER); CC(ACS_LRCORNER);
CC(ACS_URCORNER); CC(ACS_ULCORNER);
CC(ACS_LARROW); CC(ACS_RARROW);
CC(ACS_UARROW); CC(ACS_DARROW);
CC(ACS_HLINE); CC(ACS_VLINE);
CC(ACS_BULLET); CC(ACS_CKBOARD); CC(ACS_LANTERN);
CC(ACS_DEGREE); CC(ACS_DIAMOND);
CC(ACS_PLMINUS); CC(ACS_PLUS);
CC(ACS_S1); CC(ACS_S9);
/* attributes */
CC(A_NORMAL); CC(A_STANDOUT); CC(A_UNDERLINE);
CC(A_REVERSE); CC(A_BLINK); CC(A_DIM);
CC(A_BOLD); CC(A_PROTECT); CC(A_INVIS);
CC(A_ALTCHARSET); CC(A_CHARTEXT);
CC(A_ATTRIBUTES);
#ifdef A_COLOR
CC(A_COLOR);
#endif
/* key functions */
CC(KEY_BREAK); CC(KEY_DOWN); CC(KEY_UP);
CC(KEY_LEFT); CC(KEY_RIGHT); CC(KEY_HOME);
CC(KEY_BACKSPACE);
CC(KEY_DL); CC(KEY_IL); CC(KEY_DC);
CC(KEY_IC); CC(KEY_EIC); CC(KEY_CLEAR);
CC(KEY_EOS); CC(KEY_EOL); CC(KEY_SF);
CC(KEY_SR); CC(KEY_NPAGE); CC(KEY_PPAGE);
CC(KEY_STAB); CC(KEY_CTAB); CC(KEY_CATAB);
CC(KEY_ENTER); CC(KEY_SRESET); CC(KEY_RESET);
CC(KEY_PRINT); CC(KEY_LL); CC(KEY_A1);
CC(KEY_A3); CC(KEY_B2); CC(KEY_C1);
CC(KEY_C3); CC(KEY_BTAB); CC(KEY_BEG);
CC(KEY_CANCEL); CC(KEY_CLOSE); CC(KEY_COMMAND);
CC(KEY_COPY); CC(KEY_CREATE); CC(KEY_END);
CC(KEY_EXIT); CC(KEY_FIND); CC(KEY_HELP);
CC(KEY_MARK); CC(KEY_MESSAGE); /* ncurses extension: CC(KEY_MOUSE); */
CC(KEY_MOVE); CC(KEY_NEXT); CC(KEY_OPEN);
CC(KEY_OPTIONS); CC(KEY_PREVIOUS); CC(KEY_REDO);
CC(KEY_REFERENCE); CC(KEY_REFRESH); CC(KEY_REPLACE);
CC(KEY_RESIZE); CC(KEY_RESTART); CC(KEY_RESUME);
CC(KEY_SAVE); CC(KEY_SBEG); CC(KEY_SCANCEL);
CC(KEY_SCOMMAND); CC(KEY_SCOPY); CC(KEY_SCREATE);
CC(KEY_SDC); CC(KEY_SDL); CC(KEY_SELECT);
CC(KEY_SEND); CC(KEY_SEOL); CC(KEY_SEXIT);
CC(KEY_SFIND); CC(KEY_SHELP); CC(KEY_SHOME);
CC(KEY_SIC); CC(KEY_SLEFT); CC(KEY_SMESSAGE);
CC(KEY_SMOVE); CC(KEY_SNEXT); CC(KEY_SOPTIONS);
CC(KEY_SPREVIOUS); CC(KEY_SPRINT); CC(KEY_SREDO);
CC(KEY_SREPLACE); CC(KEY_SRIGHT); CC(KEY_SRSUME);
CC(KEY_SSAVE); CC(KEY_SSUSPEND); CC(KEY_SUNDO);
CC(KEY_SUSPEND); CC(KEY_UNDO);
/* KEY_Fx 0 <= x <= 63 */
CC(KEY_F0);
CF(1); CF(2); CF(3); CF(4); CF(5); CF(6); CF(7); CF(8);
CF(9); CF(10); CF(11); CF(12); CF(13); CF(14); CF(15); CF(16);
CF(17); CF(18); CF(19); CF(20); CF(21); CF(22); CF(23); CF(24);
CF(25); CF(26); CF(27); CF(28); CF(29); CF(30); CF(31); CF(32);
CF(33); CF(34); CF(35); CF(36); CF(37); CF(38); CF(39); CF(40);
CF(41); CF(42); CF(43); CF(44); CF(45); CF(46); CF(47); CF(48);
CF(49); CF(50); CF(51); CF(52); CF(53); CF(54); CF(55); CF(56);
CF(57); CF(58); CF(59); CF(60); CF(61); CF(62); CF(63);
}
int FC(int variable, int** values){
/* Spécifications: fonction récursive qui va executer l'algorithme du foward checking sur avec
les valeurs values sur une variable.*/
int** copie = (int**) malloc(sizeof(int*)*nb_sommet);
int i,j,k,ok=0;
for(i=0;i<nb_sommet;i++)
copie[i] = (int*) malloc(sizeof(int)*taille_domaine);
for(i=0;i<nb_sommet;i++)
for(j=0;j<taille_domaine;j++)
copie[i][j] = values[i][j];
for(i=0;i<taille_domaine;i++){
if(values[variable][i] == 1){
if( CF(values,variable,i) ){
nbAffectation++;
/*if(nbAffectation==1000){
printf("Trop d'affectation\n");
exit(EXIT_FAILURE);
}*/
affectation[variable] = i;
affectationFC(values,variable,i);
//printf("Affectation de la variable %d a la valeur %d\n",variable,i);
//afficheFC(values);
ok = 1;
if(variable+1 < nb_sommet){
ok = FC(variable+1,values);
}
if(ok == 1){
for(i=0;i<nb_sommet;i++)
free(copie[i]);
free(copie);
return 1;
}else{
//printf("L'affectation de la variable %d a la valeur %d ne marche pas, backtrack\n",variable,affectation[variable]);
affectation[variable] = NULL;
for(k=0;k<nb_sommet;k++)
for(j=0;j<taille_domaine;j++)
values[k][j] = copie[k][j];
//afficheFC(values);
}
}else{
//printf("Impossible d'affecter la variable %d a la valeur %d\n",variable,i);
}
}
}
//printf("L'affectation de la variable %d a la valeur %d ne marche pas, backtrack\n",variable,affectation[variable]);
affectation[variable] = NULL;
for(i=0;i<nb_sommet;i++)
for(j=0;j<taille_domaine;j++)
values[i][j] = copie[i][j];
//afficheFC(values);
for(i=0;i<nb_sommet;i++)
free(copie[i]);
free(copie);
return 0;
}
void GRID::DryRewet( double dryLimit,
double rewetLimit,
int countDown,
int* dried,
int* wetted )
{
// -------------------------------------------------------------------------------------
// check for dry nodes
for( int n=0; n<Getnp(); n++ )
{
NODE* nd = Getnode(n);
// mark recently dry nodes
if( isFS(nd->flag, NODE::kDry) ) nd->mark = true;
else nd->mark = false;
CF( nd->flag, NODE::kMarsh );
double H = nd->v.S - nd->zor;
if( H < dryLimit )
{
SF( nd->flag, NODE::kDry );
nd->countDown = countDown;
}
else
{
if( nd->countDown > 0 ) nd->countDown--;
else CF( nd->flag, NODE::kDry );
}
nd->z = nd->zor;
}
// -------------------------------------------------------------------------------------
// loop on all elements: check for dry elements
for( int e=0; e<Getne(); e++ )
{
ELEM* el = Getelem(e);
// mark elements that have been dry --------------------------------------------------
if( isFS(el->flag, ELEM::kDry) ) el->mark = true;
else el->mark = false;
CF( el->flag, ELEM::kDry | ELEM::kMarsh );
int ncn = el->Getncn();
int ndry = 0;
for( int i=0; i<ncn; i++ )
{
if( isFS(el->nd[i]->flag, NODE::kDry) ) ndry++;
}
// set dry flag if all nodes are dry
// set marsh flag if at least one node is dry
if( ndry == ncn )
{
SF( el->flag, ELEM::kDry );
}
else if( ndry )
{
SF( el->flag, ELEM::kMarsh );
for( int i=0; i<ncn; i++ )
{
if( isFS(el->nd[i]->flag, NODE::kDry) )
{
SF( el->nd[i]->flag, NODE::kMarsh );
}
}
}
}
// -------------------------------------------------------------------------------------
// loop on all elements: all nodes at wet elements are wet
for( int n=0; n<Getnp(); n++ )
{
SF( Getnode(n)->flag, NODE::kDry );
}
// initialize water surface in marsh elements
for( int e=0; e<Getne(); e++ )
{
ELEM* el = Getelem(e);
if( !isFS(el->flag, ELEM::kDry) )
{
int ncn = el->Getncn();
int nnd = el->Getnnd();
for( int i=0; i<nnd; i++ ) CF( el->nd[i]->flag, NODE::kDry );
for( int i=0; i<ncn; i++ )
{
double Si, Sj, Sk;
if( isFS(el->nd[i]->flag, NODE::kMarsh) )
{
//----------------------------------------------------------------------------------------
// 01.10.2004, sc
// The following block of code will initialize the water surface in marsh elements.
// This will be done only for elements that have been dry in the previous time step.
//
// improvement on 16.02.2013, sc
// 1. A potential water elevation Si at the dry node is computed from adjacent nodes.
// 2. The water elevation will be initialized according to the variable rewetLimit:
// a) Si > Z + rewetLimit : S = Z + rewetLimit
// b) Si < Z + dryLimit : Z = S - dryLimit
// c) Z + dryLimit < Si < Z + rewetLimit : S = Si
if( el->nd[i]->mark || firstDryRew )
{
int j = (i + 1) % ncn;
int k = (i + ncn - 1) % ncn;
if( !isFS(el->nd[j]->flag, NODE::kMarsh)
&& !isFS(el->nd[k]->flag, NODE::kMarsh) )
{
Sj = el->nd[j]->v.S;
Sk = el->nd[k]->v.S;
Si = (Sj + Sk) / 2.0;
}
else if( !isFS(el->nd[j]->flag, NODE::kMarsh) )
{
Si = el->nd[j]->v.S;
}
else if( !isFS(el->nd[k]->flag, NODE::kMarsh) )
{
Si = el->nd[k]->v.S;
}
else
{
j = (i + 2) % ncn;
if( isFS(el->nd[j]->flag, NODE::kMarsh) )
REPORT::rpt.Error( "unexpected marsh element - dryRewet (1)" );
Si = el->nd[j]->v.S;
}
el->nd[i]->v.S = Si;
// Adapt the water elevation S or bottom elevation z between dryLimit and rewetLimit.
if( el->nd[i]->v.S > el->nd[i]->zor + rewetLimit )
{
el->nd[i]->v.S = el->nd[i]->zor + rewetLimit;
}
if( el->nd[i]->v.S < el->nd[i]->zor + dryLimit )
{
el->nd[i]->z = el->nd[i]->v.S - dryLimit;
}
}
else
{
// Adapt bottom elevation of dry nodes.
// changed on 18.04.2006, sc
if( el->nd[i]->v.S < el->nd[i]->zor + dryLimit )
{
el->nd[i]->z = el->nd[i]->v.S - dryLimit;
}
}
}
}
}
}
// -------------------------------------------------------------------------------------
// interpolate midside nodes
for( int e=0; e<Getne(); e++ )
{
ELEM* el = Getelem(e);
int ncn = el->Getncn();
int nnd = el->Getnnd();
for( int i=ncn; i<nnd; i++ )
{
int left, right;
double leftS, rightS;
double leftZ, rightZ;
// get left and right corner node to midside node i
el->GetLShape()->getCornerNodes( i, &left, &right );
leftS = el->nd[left]->v.S;
rightS = el->nd[right]->v.S;
leftZ = el->nd[left]->z;
rightZ = el->nd[right]->z;
el->nd[i]->v.S = 0.5 * (leftS + rightS);
el->nd[i]->z = 0.5 * (leftZ + rightZ);
if( isFS(el->flag, ELEM::kMarsh)
&& el->nd[i]->z + dryLimit/10.0 < el->nd[i]->zor )
{
SF( el->nd[i]->flag, NODE::kMarsh );
}
}
}
// -------------------------------------------------------------------------------------
// initialize dry nodes
for( int n=0; n<Getnp(); n++ )
{
NODE* nd = Getnode(n);
if( isFS(nd->flag, NODE::kDry) )
{
nd->v.U = 0.0;
nd->v.V = 0.0;
nd->v.S = nd->z = nd->zor;
nd->v.K = 0.0;
nd->v.D = 0.0;
nd->v.dUdt = 0.0;
nd->v.dVdt = 0.0;
nd->v.dSdt = 0.0;
}
}
// -------------------------------------------------------------------------------------
// report elements
char text[100];
REPORT::rpt.Output( "\n (GRID::DryRewet) the following elements have got dry\n", 5 );
int cnt = 0;
for( int e=0; e<Getne(); e++ )
{
ELEM* el = Getelem(e);
if( isFS(el->flag, ELEM::kDry) && !el->mark )
{
sprintf( text, " %6d", el->Getname() );
REPORT::rpt.Output( text, 5 );
cnt++;
if( !(cnt % 10) ) REPORT::rpt.Output( "\n", 5 );
}
}
if( cnt % 10 ) REPORT::rpt.Output( "\n", 5 );
*dried += cnt;
REPORT::rpt.Output( "\n (GRID::DryRewet) the following elements have got wet\n", 5 );
cnt = 0;
for( int e=0; e<Getne(); e++ )
{
ELEM* el = Getelem(e);
if( !isFS(el->flag, ELEM::kDry) && el->mark )
{
sprintf( text, " %6d", el->Getname() );
REPORT::rpt.Output( text, 5 );
cnt++;
if( !(cnt % 10) ) REPORT::rpt.Output( "\n", 5 );
}
}
if( cnt % 10 ) REPORT::rpt.Output( "\n", 5 );
*wetted += cnt;
// -------------------------------------------------------------------------------------
// following the complete list of dry / marsh elements
# ifdef kDebug
REPORT::rpt.Output( "\n (GRID::DryRewet) list of dry elements\n", 5 );
int pos = 0;
int E1 = -1;
int E2 = -1;
int E3 = -1;
for( int e=0; e<Getne(); e++ )
{
ELEM* el = Getelem(e);
if( isFS(el->flag, ELEM::kDry) )
{
if( E1 < 0 )
{
E1 = el->Getname();
}
else if( E2 < 0 )
{
E2 = el->Getname();
if( E2 > E1 + 1 )
{
switch( pos )
{
case 5: REPORT::rpt.Output( "\n", 5 );
pos = 0;
default: sprintf( text, " %6d", E1 );
REPORT::rpt.Output( text, 5 );
break;
}
pos++;
E1 = E2;
E2 = -1;
}
}
else
{
E3 = el->Getname();
if( E3 > E2 + 1 )
{
switch( pos )
{
case 5: REPORT::rpt.Output( "\n", 5 );
pos = 0;
default: sprintf( text, " %6d - %6d", E1, E2 );
REPORT::rpt.Output( text, 5 );
break;
}
pos++;
E1 = E3;
E2 = -1;
}
else
{
E2 = E3;
}
}
}
}
if( E1 > 0 && E2 > 0 )
{
switch( pos )
{
case 5: REPORT::rpt.Output( "\n", 5 );
default: sprintf( text, " %6d - %6d", E1, E2 );
REPORT::rpt.Output( text, 5 );
break;
}
}
else if( E1 > 0 )
{
switch( pos )
{
case 5: REPORT::rpt.Output( "\n", 5 );
default: sprintf( text, " %6d", E1 );
REPORT::rpt.Output( text, 5 );
break;
}
}
REPORT::rpt.Output( "\n", 5 );
# endif
}
#include "NetworkTest.h"
#include "../testResource.h"
#include "cocos2d.h"
#include "cocos2d-better.h"
TESTLAYER_CREATE_FUNC(NetworkTCP);
TESTLAYER_CREATE_FUNC(NetworkUDP);
static NEWTESTFUNC createFunctions[] = {
CF(NetworkTCP),
CF(NetworkUDP)
};
static int sceneIdx=-1;
#define MAX_LAYER (sizeof(createFunctions) / sizeof(createFunctions[0]))
static CCLayer* nextAction()
{
sceneIdx++;
sceneIdx = sceneIdx % MAX_LAYER;
CCLayer* pLayer = (createFunctions[sceneIdx])();
pLayer->init();
pLayer->autorelease();
return pLayer;
}
static CCLayer* backAction()
{
sceneIdx--;
#include "FileUtilsTest.h"
TESTLAYER_CREATE_FUNC(TestResolutionDirectories);
TESTLAYER_CREATE_FUNC(TestSearchPath);
TESTLAYER_CREATE_FUNC(TestFilenameLookup);
TESTLAYER_CREATE_FUNC(TestIsFileExist);
static NEWTESTFUNC createFunctions[] = {
CF(TestResolutionDirectories),
CF(TestSearchPath),
CF(TestFilenameLookup),
CF(TestIsFileExist)
};
static int sceneIdx=-1;
#define MAX_LAYER (sizeof(createFunctions) / sizeof(createFunctions[0]))
static CCLayer* nextAction()
{
sceneIdx++;
sceneIdx = sceneIdx % MAX_LAYER;
CCLayer* pLayer = (createFunctions[sceneIdx])();
pLayer->init();
pLayer->autorelease();
return pLayer;
}
static CCLayer* backAction()
